fuchsia / third_party / vulkan-cts / refs/heads/upstream/opengl-es-cts-3.2.8 / . / doc / testspecs / GLES3 / functional.shaders.builtin_functions.precision.txt

------------------------------------------------------------------------- | |

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. |