| ------------------------------------------------------------------------- |
| drawElements Quality Program Test Specification |
| ----------------------------------------------- |
| |
| Copyright 2014 The Android Open Source Project |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| ------------------------------------------------------------------------- |
| Precision tests for built-in functions |
| |
| Tests: |
| + dEQP-GLES3.functional.shaders.builtin_functions.precision.* |
| |
| |
| These tests check that the GLSL built-in numerical functions produce |
| results that are compliant with the range and precision requirements in |
| the GLSL ES specification. |
| |
| The tests operate by calling the functions with predefined (mostly |
| random) input values in either the vertex or the fragment shader. The |
| result is stored in a transform feedback buffer or in a framebuffer |
| pixel, and then read and compared to a reference interval of acceptable |
| values. Functions are tested with all possible vector and matrix sizes. |
| In the test log floating point numbers are printed out as hexadecimal |
| constants of the form used in e.g. C99. |
| |
| Where the GLSL specification does not specify a particular precision, |
| the tests try to make reasonable requirements. When behavior at |
| infinities hasn't been otherwise specified, C99 Appendix F is used as a |
| reference. Moreover, the highp precision requirements have been adapted |
| to lowp and mediump precisions even though the GLSL specification |
| doesn't provide any guarantees about them. For instance, mediump and |
| lowp operations are expected to produce either an infinity or the |
| maximum/minimum value on overflow. |
| |
| The acceptable results are constrained further by only allowing values |
| from within the codomain of the function. Thus, for instance, sin(x) is |
| not allowed to return a number greater than 1 even when when the nominal |
| error bound would be greater. |
| |
| A number of functions have been defined as derived forms. This means |
| that they are required to produce only results that their expansions |
| could produce, given the precision requirements for the constituent |
| |
| operations. |
| |
| * Arithmetic operations |
| |
| These are as defined in the GLSL ES specification. |
| |
| | operation | precision | domain | |
| |-----------+-----------+-----------------------------| |
| | x + y | < 1 ULP | | |
| | x / y | 2.5 ULP | 2^-126 <= abs(y) <= 2^127-1 | |
| | x - y | < 1 ULP | | |
| | x * y | < 1 ULP | | |
| |
| |
| * Trigonometric functions |
| |
| The precisions for trigonometric functions have been adapted from OpenCL |
| fast relaxed math and half-float specifications. Hyperbolic functions |
| take their precisions from standard formulae as derived forms. |
| |
| Primitives: |
| |
| | function | precision | domain | prec qual | |
| |------------+----------------+---------------------+---------------| |
| | sin(x) | 2^-11 | -pi <= x <= pi | highp | |
| | | 2^-12 * abs(x) | elsewhere | highp | |
| | | 2 ULP | | mediump, lowp | |
| | cos(x) | 2^-11 | -pi <= x <= pi | highp | |
| | | 2^-12 * abs(x) | elsewhere | highp | |
| | | 2 ULP | | mediump, lowp | |
| | asin(x) | 4 ULP | -1 <= x <= 1 | highp | |
| | | 2 ULP | -1 <= x <= 1 | mediump, lowp | |
| | acos(x) | 4 ULP | -1 <= x <= 1 | highp | |
| | | 2 ULP | -1 <= x <= 1 | mediump, lowp | |
| | atan(x, y) | 6 ULP | !(x == 0 && y == 0) | highp | |
| | | 2 ULP | !(x == 0 && y == 0) | mediump, lowp | |
| | atan(x) | 5 ULP | | highp | |
| | | 2 ULP | | mediump, lowp | |
| |
| Derived functions: |
| |
| | function | defined as | |
| |------------+----------------------------------| |
| | radians(x) | (pi / 180.0) * x | |
| | degrees(x) | (180.0 / pi) * x | |
| | tan(x) | sin(x) * (1.0 / cos(x)) | |
| | sinh(x) | (exp(x) - exp(-x)) / 2.0 | |
| | cosh(x) | (exp(x) + exp(-x)) / 2.0 | |
| | tanh(x) | sinh(x) / cosh(x) | |
| | asinh(x) | log(x + sqrt(x * x + 1.0)) | |
| | acosh(x) | log(x + sqrt((x+1.0) * (x-1.0))) | |
| | atanh(x) | 0.5 * log(1.0 + x / (1.0 - x)) | |
| |
| |
| * Exponential functions |
| |
| The precisions for exponential functions for mediump and lowp have been |
| adapted from the OpenCL half-float specification. |
| |
| Primitives: |
| |
| | function | precision | domain | prec qual | |
| |----------------+----------------------+----------------------+-----------| |
| | exp(x) | (3 + 2 * abs(x)) ULP | | highp | |
| | | (2 + 2 * abs(x)) ULP | | mediump | |
| | | 2 ULP | | lowp | |
| | log(x) | 2^-21 | 0.5 <= x && x <= 0.5 | highp | |
| | | 3 ULP | elsewhere | highp | |
| | | 2^-7 | 0.5 <= x && x <= 0.5 | mediump | |
| | | 2 ULP | elsewhere | mediump | |
| | | 2 ULP | | lowp | |
| | exp(x) | (3 + 2 * abs(x)) ULP | | highp | |
| | | (2 + 2 * abs(x)) ULP | | mediump | |
| | | 2 ULP | | lowp | |
| | log2(x) | 2^-21 | 0.5 <= x && x <= 0.5 | highp | |
| | | 3 ULP | elsewhere | highp | |
| | | 2^-7 | 0.5 <= x && x <= 0.5 | mediump | |
| | | 2 ULP | elsewhere | mediump | |
| | | 2 ULP | | lowp | |
| | inversesqrt(x) | 2 ULP | | | |
| |
| Derived functions: |
| |
| | function | defined as | |
| |----------+----------------------| |
| | pow(x) | exp2(y * log2(x)) | |
| | sqrt(x) | 1.0 / inversesqrt(x) | |
| |
| |
| * Common functions |
| |
| The operations that don't do any arithmetic are required to produce |
| exact results. The round() function is allowed to round in either |
| direction on a tie. |
| |
| Primitives: |
| |
| | function | precision | |
| |------------------+-----------| |
| | abs(x) | 0 | |
| | sign(x) | 0 | |
| | floor(x) | 0 | |
| | trunc(x) | 0 | |
| | round(x) | special | |
| | roundEven(x) | 0 | |
| | ceil(x) | 0 | |
| | modf(x, i) | 0 | |
| | min(x, y) | 0 | |
| | max(x, y) | 0 | |
| | clamp(x, lo, hi) | 0 | |
| | step(edge, x) | 0 | |
| |
| Derived functions: |
| |
| | function | defined as | |
| |-----------------------+------------------------------------------------| |
| | fract(x) | x - floor(x) | |
| | mod(x, y) | x - y * floor(x / y) | |
| | mix(x, y, a) | x * (1 - a) + y * a | |
| | smoothstep(e0, e1, x) | { float t = clamp((x - e0) / (e1 - e0),0,1); | |
| | | return t * t * (3 - 2*t); } | |
| |
| |
| * Geometric and matrix functions |
| |
| These are generally defined as derived forms with reference algorithms. |
| For determinant and inverse operations only 2x2 matrices are tested: |
| there are a number of possible algorithms for larger matrices, and the |
| specification does not provide precision requirements for these operations. |
