Source code
Revision control
Copy as Markdown
Other Tools
/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES Utilities
* ------------------------------------------------
*
* 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
*
*
* 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.
*
*/
'use strict';
goog.provide('modules.shared.glsBuiltinPrecisionTests');
goog.require('framework.common.tcuFloatFormat');
goog.require('framework.common.tcuInterval');
goog.require('framework.common.tcuMatrix');
goog.require('framework.common.tcuMatrixUtil');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.delibs.debase.deUtil');
goog.require('framework.opengl.gluShaderProgram');
goog.require('framework.opengl.gluShaderUtil');
goog.require('framework.opengl.gluVarType');
goog.require('framework.opengl.simplereference.sglrGLContext');
goog.require('modules.shared.glsBuiltinPrecisionTestsUnitTests');
goog.require('modules.shared.glsShaderExecUtil');
goog.scope(function() {
var glsBuiltinPrecisionTests = modules.shared.glsBuiltinPrecisionTests;
var tcuTestCase = framework.common.tcuTestCase;
var gluShaderProgram = framework.opengl.gluShaderProgram;
var gluShaderUtil = framework.opengl.gluShaderUtil;
var tcuInterval = framework.common.tcuInterval;
var tcuFloatFormat = framework.common.tcuFloatFormat;
var deRandom = framework.delibs.debase.deRandom;
var glsShaderExecUtil = modules.shared.glsShaderExecUtil;
var sglrGLContext = framework.opengl.simplereference.sglrGLContext;
var deMath = framework.delibs.debase.deMath;
var deUtil = framework.delibs.debase.deUtil;
var gluVarType = framework.opengl.gluVarType;
var tcuMatrix = framework.common.tcuMatrix;
var tcuMatrixUtil = framework.common.tcuMatrixUtil;
var ref = modules.shared.glsBuiltinPrecisionTestsUnitTests.cppreference;
var referenceComparison = modules.shared.glsBuiltinPrecisionTestsUnitTests.referenceComparison;
var DE_ASSERT = function(x) {
if (!x)
throw new Error('Assert failed');
};
var setParentClass = function(child, parent) {
child.prototype = Object.create(parent.prototype);
child.prototype.constructor = child;
};
/** @typedef {(tcuInterval.Interval|Array<tcuInterval.Interval>|tcuMatrix.Matrix)} */
glsBuiltinPrecisionTests.Intervals;
/** @typedef {(number|Array<number>|tcuMatrix.Matrix)} */
glsBuiltinPrecisionTests.Value;
/** @typedef {(string)} */
glsBuiltinPrecisionTests.Typename;
//Change to true for WebGL unit testing
var enableUnittests = false;
/**
* @param {number} value
* @return {boolean}
*/
glsBuiltinPrecisionTests.isFloat = function(value) {
return value % 1 !== 0;
};
/**
* @constructor
* @param {string} R
* @param {string=} P0
* @param {string=} P1
* @param {string=} P2
* @param {string=} P3
*/
glsBuiltinPrecisionTests.Signature = function(R, P0, P1, P2, P3) {
this.Ret = R;
this.Arg0 = P0 === undefined ? 'void' : P0;
this.Arg1 = P1 === undefined ? 'void' : P1;
this.Arg2 = P2 === undefined ? 'void' : P2;
this.Arg3 = P3 === undefined ? 'void' : P3;
};
/** @typedef {Array<glsBuiltinPrecisionTests.FuncBase>} */
glsBuiltinPrecisionTests.FuncSet;
/**
* @constructor
* @template T
* @param {T} A0
* @param {T} A1
* @param {T} A2
* @param {T} A3
*/
glsBuiltinPrecisionTests.Tuple4 = function(A0, A1, A2, A3) {
this.a = A0;
this.b = A1;
this.c = A2;
this.d = A3;
};
/**
* @typedef {!glsBuiltinPrecisionTests.Tuple4<string>}
*/
glsBuiltinPrecisionTests.ParamNames;
/**
* Returns true for all other types except Void
* @param {string} typename
*/
glsBuiltinPrecisionTests.isTypeValid = function(typename) {
if (typename === 'void')
return false;
return true;
};
/**
* Returns true for all other types except Void
* @param {*} In
* @return {number}
*/
glsBuiltinPrecisionTests.numInputs = function(In) {
return (!glsBuiltinPrecisionTests.isTypeValid(In.In0) ? 0 :
!glsBuiltinPrecisionTests.isTypeValid(In.In1) ? 1 :
!glsBuiltinPrecisionTests.isTypeValid(In.In2) ? 2 :
!glsBuiltinPrecisionTests.isTypeValid(In.In3) ? 3 :
4);
};
/**
* Returns true for all other types except Void
* @param {*} Out
* @return {number}
*/
glsBuiltinPrecisionTests.numOutputs = function(Out) {
return (!glsBuiltinPrecisionTests.isTypeValid(Out.Out0) ? 0 :
!glsBuiltinPrecisionTests.isTypeValid(Out.Out1) ? 1 :
2);
};
/**
* @constructor
* @param {glsBuiltinPrecisionTests.Typename=} In0_
* @param {glsBuiltinPrecisionTests.Typename=} In1_
* @param {glsBuiltinPrecisionTests.Typename=} In2_
* @param {glsBuiltinPrecisionTests.Typename=} In3_
*/
glsBuiltinPrecisionTests.InTypes = function(In0_, In1_, In2_, In3_) {
this.In0 = In0_ === undefined ? 'void' : In0_;
this.In1 = In1_ === undefined ? 'void' : In1_;
this.In2 = In2_ === undefined ? 'void' : In2_;
this.In3 = In3_ === undefined ? 'void' : In3_;
};
/**
* @constructor
* @param {glsBuiltinPrecisionTests.Typename=} Out0_
* @param {glsBuiltinPrecisionTests.Typename=} Out1_
*/
glsBuiltinPrecisionTests.OutTypes = function(Out0_, Out1_) {
this.Out0 = Out0_ === undefined ? 'void' : Out0_;
this.Out1 = Out1_ === undefined ? 'void' : Out1_;
};
/**
* @constructor
*/
glsBuiltinPrecisionTests.Environment = function() {
/** @type {Object} */ this.m_map = {};
};
/**
* @param {glsBuiltinPrecisionTests.Variable} variable
* @param {*} value
*/
glsBuiltinPrecisionTests.Environment.prototype.bind = function(variable, value) {
this.m_map[variable.getName()] = value;
};
/**
* @param {*} variable
* @return {glsBuiltinPrecisionTests.Intervals}
*/
glsBuiltinPrecisionTests.Environment.prototype.lookup = function(variable) {
if (variable instanceof glsBuiltinPrecisionTests.Variable)
return this.m_map[variable.getName()];
throw new Error('Invalid lookup input: ' + variable);
};
/**
* @constructor
* @param {tcuFloatFormat.FloatFormat} format_
* @param {gluShaderUtil.precision} floatPrecision_
* @param {glsBuiltinPrecisionTests.Environment} env_
* @param {number=} callDepth_
*/
glsBuiltinPrecisionTests.EvalContext = function(format_, floatPrecision_, env_, callDepth_) {
this.format = format_;
this.floatPrecision = floatPrecision_;
this.env = env_;
this.callDepth = callDepth_ === undefined ? 0 : callDepth_;
};
/**
* @param {string} typename typename
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {glsBuiltinPrecisionTests.Intervals} value
* @return {glsBuiltinPrecisionTests.Intervals}
*/
glsBuiltinPrecisionTests.convert = function(typename, fmt, value) {
var traits = glsBuiltinPrecisionTests.Traits.traitsFactory(typename);
if (value instanceof Array) {
var ret = [];
for (var i = 0; i < value.length; i++)
ret.push(traits.doConvert(fmt, value[i]));
return ret;
}
if (value instanceof tcuMatrix.Matrix) {
var ret = new tcuMatrix.Matrix(value.rows, value.cols);
for (var i = 0; i < value.rows; i++)
for (var j = 0; j < value.cols; j++)
ret.set(i, j, traits.doConvert(fmt, value.get(i, j)));
return ret;
}
return traits.doConvert(fmt, value);
};
/**
* Returns true if every element of `ival` contains the corresponding element of `value`.
* @param {string} typename typename
* @param {glsBuiltinPrecisionTests.Intervals} ival
* @param {*} value
* @return {boolean}
*/
glsBuiltinPrecisionTests.contains = function(typename, ival, value) {
var traits = glsBuiltinPrecisionTests.Traits.traitsFactory(typename);
var contains = true;
if (value instanceof Array) {
for (var i = 0; i < value.length; i++)
contains &= traits.doContains(ival[i], value[i]);
return contains;
}
if (value instanceof tcuMatrix.Matrix) {
for (var i = 0; i < value.rows; i++)
for (var j = 0; j < value.cols; j++)
contains &= traits.doContains(ival.get(i, j), value.get(i, j));
return contains;
}
return traits.doContains(ival, value);
};
/**
* @param {string} typename typename
* @param {glsBuiltinPrecisionTests.Intervals} ival0
* @param {glsBuiltinPrecisionTests.Intervals} ival1
* @return {glsBuiltinPrecisionTests.Intervals}
*/
glsBuiltinPrecisionTests.union = function(typename, ival0, ival1) {
var traits = glsBuiltinPrecisionTests.Traits.traitsFactory(typename);
if (ival0 instanceof Array) {
var ret = [];
for (var i = 0; i < ival0.length; i++)
ret.push(traits.doUnion(ival0[i], ival1[i]));
return ret;
}
if (ival0 instanceof tcuMatrix.Matrix) {
var ret = new tcuMatrix.Matrix(ival0.rows, ival0.cols);
for (var i = 0; i < ival0.rows; i++)
for (var j = 0; j < ival0.cols; j++)
ret.set(i, j, traits.doUnion(ival0.get(i, j), ival1.get(i, j)));
return ret;
}
return traits.doUnion(ival0, ival1);
};
/**
* @param {string} typename
* @constructor
*/
glsBuiltinPrecisionTests.Traits = function(typename) {
this.typename = typename;
this.rows = 1;
this.cols = 1;
};
glsBuiltinPrecisionTests.Traits.prototype.isScalar = function() {
return this.rows == 1 && this.cols == 1;
};
glsBuiltinPrecisionTests.Traits.prototype.isVector = function() {
return this.rows > 0 && this.cols == 1;
};
glsBuiltinPrecisionTests.Traits.prototype.isMatrix = function() {
return this.rows > 0 && this.cols > 1;
};
/**
* @param {string=} typename
*/
glsBuiltinPrecisionTests.Traits.traitsFactory = function(typename) {
switch (typename) {
case 'boolean' : return new glsBuiltinPrecisionTests.TraitsBool();
case 'float' : case 'vec2' : case 'vec3' : case 'vec4' :
case 'mat2' : case 'mat2x3' : case 'mat2x4' :
case 'mat3x2' : case 'mat3' : case 'mat3x4' :
case 'mat4x2' : case 'mat4x3' : case 'mat4' :
return new glsBuiltinPrecisionTests.TraitsFloat(typename);
case 'int' : return new glsBuiltinPrecisionTests.TraitsInt();
case 'void' : return new glsBuiltinPrecisionTests.TraitsVoid();
default:
throw new Error('Invalid typename:' + typename);
}
};
glsBuiltinPrecisionTests.round = function(typename, fmt, value) {
var traits = glsBuiltinPrecisionTests.Traits.traitsFactory(typename);
if (value instanceof Array) {
var ret = [];
for (var i = 0; i < value.length; i++)
ret.push(traits.doRound(fmt, value[i]));
return ret;
}
if (value instanceof tcuMatrix.Matrix) {
var ret = new tcuMatrix.Matrix(value.rows, value.cols);
for (var i = 0; i < value.rows; i++)
for (var j = 0; j < value.cols; j++)
ret.set(i, j, traits.doRound(fmt, value.get(i, j)));
return ret;
}
return traits.doRound(fmt, value);
};
/**
* cast the input typed array to correct type
* @param {string} typename
* @param {goog.TypedArray} input
* @return {goog.TypedArray}
*/
glsBuiltinPrecisionTests.cast = function(typename, input) {
var traits = glsBuiltinPrecisionTests.Traits.traitsFactory(typename);
return traits.doCast(input);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Traits}
*/
glsBuiltinPrecisionTests.TraitsVoid = function() {
glsBuiltinPrecisionTests.Traits.call(this, 'void');
};
setParentClass(glsBuiltinPrecisionTests.TraitsVoid, glsBuiltinPrecisionTests.Traits);
/**
* @param {*} value
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.TraitsVoid.prototype.doMakeIVal = function(value) {
return new tcuInterval.Interval();
};
/**
* @param {*} value1
* @param {*} value2
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.TraitsVoid.prototype.doUnion = function(value1, value2) {
return new tcuInterval.Interval();
};
/**
* @param {*} value
* @return {boolean}
*/
glsBuiltinPrecisionTests.TraitsVoid.prototype.doContains = function(value) {
return true;
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {tcuInterval.Interval} ival
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.TraitsVoid.prototype.doConvert = function(fmt, ival) {
return new tcuInterval.Interval();
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {*} ival
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.TraitsVoid.prototype.doRound = function(fmt, ival) {
return new tcuInterval.Interval();
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {*} ival
*/
glsBuiltinPrecisionTests.TraitsVoid.prototype.doPrintIVal = function(fmt, ival) {
return '()';
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {*} value
*/
glsBuiltinPrecisionTests.TraitsVoid.prototype.doPrintValue = function(fmt, value) {
return '()';
};
glsBuiltinPrecisionTests.dataTypeSize = function(detailedType) {
var size = [1, 1];
switch (detailedType) {
case 'vec2' : size[0] = 2; break;
case 'vec3' : size[0] = 3; break;
case 'vec4' : size[0] = 4; break;
case 'mat2' : size = [2 , 2]; break;
case 'mat2x3' : size = [3 , 2]; break;
case 'mat2x4' : size = [4 , 2]; break;
case 'mat3x2' : size = [2 , 3]; break;
case 'mat3' : size = [3 , 3]; break;
case 'mat3x4' : size = [4 , 3]; break;
case 'mat4x2' : size = [2 , 4]; break;
case 'mat4x3' : size = [3 , 4]; break;
case 'mat4' : size = [4 , 4]; break;
}
return size;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Traits}
* @param {string} typename
* @param {string=} detailedType
*/
glsBuiltinPrecisionTests.ScalarTraits = function(typename, detailedType) {
glsBuiltinPrecisionTests.Traits.call(this, typename);
var size = glsBuiltinPrecisionTests.dataTypeSize(detailedType);
this.rows = size[0];
this.cols = size[1];
/** type{tcuInterval.Interval} */ this.iVal;
};
setParentClass(glsBuiltinPrecisionTests.ScalarTraits, glsBuiltinPrecisionTests.Traits);
glsBuiltinPrecisionTests.ScalarTraits.prototype = Object.create(glsBuiltinPrecisionTests.Traits.prototype);
glsBuiltinPrecisionTests.ScalarTraits.prototype.constructor = glsBuiltinPrecisionTests.ScalarTraits;
/**
* @param {*} value
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.ScalarTraits.prototype.doMakeIVal = function(value) {
// Thankfully all scalar types have a well-defined conversion to `double`,
// hence Interval can represent their ranges without problems.
return new tcuInterval.Interval(/** @type {number} */ (value));
};
/**
* @param {tcuInterval.Interval} a
* @param {tcuInterval.Interval} b
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.ScalarTraits.prototype.doUnion = function(a, b) {
return a.operatorOrBinary(b);
};
/**
* @param {tcuInterval.Interval} a
* @param {number} value
* @return {boolean}
*/
glsBuiltinPrecisionTests.ScalarTraits.prototype.doContains = function(a, value) {
return a.contains(new tcuInterval.Interval(value));
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {tcuInterval.Interval} ival
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.ScalarTraits.prototype.doConvert = function(fmt, ival) {
return fmt.convert(ival);
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {number} value
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.ScalarTraits.prototype.doRound = function(fmt, value) {
return fmt.roundOut(new tcuInterval.Interval(value), false);//TODO cast to double
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.ScalarTraits}
* @param {string} detailedType
*/
glsBuiltinPrecisionTests.TraitsFloat = function(detailedType) {
glsBuiltinPrecisionTests.ScalarTraits.call(this, 'float', detailedType);
};
glsBuiltinPrecisionTests.TraitsFloat.prototype = Object.create(glsBuiltinPrecisionTests.ScalarTraits.prototype);
glsBuiltinPrecisionTests.TraitsFloat.prototype.constructor = glsBuiltinPrecisionTests.TraitsFloat;
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {tcuInterval.Interval} ival
*/
glsBuiltinPrecisionTests.TraitsFloat.prototype.doPrintIVal = function(fmt, ival) {
return fmt.intervalToHex(ival);
};
/**
* @param {goog.TypedArray} input
* @return {goog.TypedArray}
*/
glsBuiltinPrecisionTests.TraitsFloat.prototype.doCast = function(input) {
return new Float32Array(input.buffer);
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {number} value
*/
glsBuiltinPrecisionTests.TraitsFloat.prototype.doPrintValue = function(fmt, value) {
return fmt.floatToHex(value);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.ScalarTraits}
*/
glsBuiltinPrecisionTests.TraitsBool = function() {
glsBuiltinPrecisionTests.ScalarTraits.call(this, 'boolean');
};
glsBuiltinPrecisionTests.TraitsBool.prototype = Object.create(glsBuiltinPrecisionTests.ScalarTraits.prototype);
glsBuiltinPrecisionTests.TraitsBool.prototype.constructor = glsBuiltinPrecisionTests.TraitsBool;
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {tcuInterval.Interval} ival
*/
glsBuiltinPrecisionTests.TraitsBool.prototype.doPrintIVal = function(fmt, ival) {
/** type{string} */ var os = '{';
var ifalse = new tcuInterval.Interval(0);
var itrue = new tcuInterval.Interval(1);
if (ival.contains(ifalse))
os += 'false';
if (ival.contains(ifalse) && ival.contains(itrue))
os += ', ';
if (ival.contains(itrue))
os += 'true';
os += '}';
return os;
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {boolean} value
*/
glsBuiltinPrecisionTests.TraitsBool.prototype.doPrintValue = function(fmt, value) {
return value ? 'true' : 'false';
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.ScalarTraits}
*/
glsBuiltinPrecisionTests.TraitsInt = function() {
glsBuiltinPrecisionTests.ScalarTraits.call(this, 'int');
};
glsBuiltinPrecisionTests.TraitsInt.prototype = Object.create(glsBuiltinPrecisionTests.ScalarTraits.prototype);
glsBuiltinPrecisionTests.TraitsInt.prototype.constructor = glsBuiltinPrecisionTests.TraitsInt;
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {tcuInterval.Interval} ival
*/
glsBuiltinPrecisionTests.TraitsInt.prototype.doPrintIVal = function(fmt, ival) {
return '[' + (ival.lo()) + ', ' + (ival.hi()) + ']';
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {number} value
*/
glsBuiltinPrecisionTests.TraitsInt.prototype.doPrintValue = function(fmt, value) {
return value.toString(10);
};
/**
* @constructor
*/
glsBuiltinPrecisionTests.Statement = function() {
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
*/
glsBuiltinPrecisionTests.Statement.prototype.execute = function(ctx) {
this.doExecute(ctx);
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Statement.prototype.print = function() {
return this.doPrint();
};
glsBuiltinPrecisionTests.Statement.prototype.toString = function() {
return this.print();
};
/**
* Output the functions that this expression refers to
* @param {glsBuiltinPrecisionTests.FuncSet} dst
*
*/
glsBuiltinPrecisionTests.Statement.prototype.getUsedFuncs = function(dst) {
this.doGetUsedFuncs(dst);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
*/
glsBuiltinPrecisionTests.Statement.prototype.doExecute = function(ctx) {
throw new Error('Virtual function. Please override.');
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Statement.prototype.doPrint = function() {
throw new Error('Virtual function. Please override.');
};
/**
* Output the functions that this expression refers to
* @param {glsBuiltinPrecisionTests.FuncSet} dst
*
*/
glsBuiltinPrecisionTests.Statement.prototype.doGetUsedFuncs = function(dst) {
throw new Error('Virtual function. Please override.');
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Statement}
* @param {glsBuiltinPrecisionTests.Variable} variable
* @param {glsBuiltinPrecisionTests.Expr} value
* @param {boolean} isDeclaration
*/
glsBuiltinPrecisionTests.VariableStatement = function(variable, value, isDeclaration) {
this.m_variable = variable;
this.m_value = value;
this.m_isDeclaration = isDeclaration;
};
setParentClass(glsBuiltinPrecisionTests.VariableStatement, glsBuiltinPrecisionTests.Statement);
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
*/
glsBuiltinPrecisionTests.VariableStatement.prototype.doExecute = function(ctx) {
ctx.env.bind(this.m_variable, this.m_value.evaluate(ctx));
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.VariableStatement.prototype.doPrint = function() {
var v = this.m_variable;
var os = '';
if (this.m_isDeclaration)
os += gluVarType.declareVariable(gluVarType.getVarTypeOf(v.typename),
v.getName());
else
os += v.getName();
os += ' = ' + this.m_value.printExpr() + ';\n';
return os;
};
/**
* Output the functions that this expression refers to
* @param {glsBuiltinPrecisionTests.FuncSet} dst
*
*/
glsBuiltinPrecisionTests.VariableStatement.prototype.doGetUsedFuncs = function(dst) {
this.m_value.getUsedFuncs(dst);
};
/**
* @param {glsBuiltinPrecisionTests.Variable} variable
* @param {glsBuiltinPrecisionTests.Expr} definiens
* @return {glsBuiltinPrecisionTests.VariableStatement}
*/
glsBuiltinPrecisionTests.variableDeclaration = function(variable, definiens) {
return new glsBuiltinPrecisionTests.VariableStatement(variable, definiens, true);
};
/**
* @param {string} typename
* @param {string} name
* @param {glsBuiltinPrecisionTests.ExpandContext} ctx
* @param {glsBuiltinPrecisionTests.Expr} expr
* @return {glsBuiltinPrecisionTests.Variable}
*/
glsBuiltinPrecisionTests.bindExpression = function(typename, name, ctx, expr) {
var variable = ctx.genSym(typename, name);
ctx.addStatement(glsBuiltinPrecisionTests.variableDeclaration(variable, expr));
return variable;
};
/**
* Common base class for all expressions regardless of their type.
* @constructor
*/
glsBuiltinPrecisionTests.ExprBase = function() {};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.ExprBase.prototype.printExpr = function() {
return this.doPrintExpr();
};
glsBuiltinPrecisionTests.ExprBase.prototype.toString = function() {
return this.printExpr();
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.ExprBase.prototype.doPrintExpr = function() {
throw new Error('Virtual function. Please override.');
};
/**
* Output the functions that this expression refers to
* @param {glsBuiltinPrecisionTests.FuncSet} dst
*
*/
glsBuiltinPrecisionTests.ExprBase.prototype.getUsedFuncs = function(/*FuncSet&*/ dst) {
this.doGetUsedFuncs(dst);
};
/**
* Output the functions that this expression refers to
* @param {glsBuiltinPrecisionTests.FuncSet} dst
*
*/
glsBuiltinPrecisionTests.ExprBase.prototype.doGetUsedFuncs = function(/*FuncSet&*/ dst) {
throw new Error('Virtual function. Please override.');
};
/**
* Type-specific operations for an expression representing type typename.
* @constructor
* @extends {glsBuiltinPrecisionTests.ExprBase}
* @param {glsBuiltinPrecisionTests.Typename} typename
*/
glsBuiltinPrecisionTests.Expr = function(typename) {
glsBuiltinPrecisionTests.ExprBase.call(this);
this.typename = typename;
};
setParentClass(glsBuiltinPrecisionTests.Expr, glsBuiltinPrecisionTests.ExprBase);
/**
* Type-specific operations for an expression representing type typename.
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
*/
glsBuiltinPrecisionTests.Expr.prototype.evaluate = function(ctx) {
return this.doEvaluate(ctx);
};
/**
* Type-specific operations for an expression representing type typename.
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
*/
glsBuiltinPrecisionTests.Expr.prototype.doEvaluate = function(ctx) {
throw new Error('Virtual function. Please override.');
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Expr}
* @param {glsBuiltinPrecisionTests.Typename} typename
* @param {string=} name
*/
glsBuiltinPrecisionTests.Variable = function(typename, name) {
glsBuiltinPrecisionTests.Expr.call(this, typename);
/** @type {string} */ this.m_name = name || '<undefined>';
};
setParentClass(glsBuiltinPrecisionTests.Variable, glsBuiltinPrecisionTests.Expr);
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Variable.prototype.getName = function() {
return this.m_name;
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Variable.prototype.doPrintExpr = function() {
return this.m_name;
};
glsBuiltinPrecisionTests.Variable.prototype.toString = function() {
return this.doPrintExpr();
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @return {*}
*/
glsBuiltinPrecisionTests.Variable.prototype.doEvaluate = function(ctx) {
return ctx.env.lookup(this);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Variable}
* @param {*=} t
*/
glsBuiltinPrecisionTests.Void = function(t) {
glsBuiltinPrecisionTests.Variable.call(this, 'void');
};
setParentClass(glsBuiltinPrecisionTests.Void, glsBuiltinPrecisionTests.Variable);
glsBuiltinPrecisionTests.Void.prototype.doEvaluate = function(ctx) {
return undefined;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Variable}
* @param {number} value
*/
glsBuiltinPrecisionTests.Constant = function(value) {
glsBuiltinPrecisionTests.Variable.call(this, 'float');
this.m_value = value;
};
setParentClass(glsBuiltinPrecisionTests.Constant, glsBuiltinPrecisionTests.Variable);
glsBuiltinPrecisionTests.Constant.prototype.doEvaluate = function(ctx) {
return new tcuInterval.Interval(this.m_value);
};
/**
* @constructor
* @param {*} typename
*/
glsBuiltinPrecisionTests.DefaultSampling = function(typename) {
this.typename = typename;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Expr}
* @param {glsBuiltinPrecisionTests.Variable} vector
* @param {number} index
*/
glsBuiltinPrecisionTests.VectorVariable = function(vector, index) {
glsBuiltinPrecisionTests.Expr.call(this, vector.typename);
this.m_vector = vector;
this.m_index = index;
};
setParentClass(glsBuiltinPrecisionTests.VectorVariable, glsBuiltinPrecisionTests.Expr);
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.VectorVariable.prototype.doEvaluate = function(ctx) {
var tmp = this.m_vector.doEvaluate(ctx);
return tmp[this.m_index];
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Expr}
* @param {glsBuiltinPrecisionTests.Variable} matrix
* @param {number} row
* @param {number} col
*/
glsBuiltinPrecisionTests.MatrixVariable = function(matrix, row, col) {
glsBuiltinPrecisionTests.Expr.call(this, matrix.typename);
this.m_matrix = matrix;
this.m_row = row;
this.m_col = col;
};
setParentClass(glsBuiltinPrecisionTests.MatrixVariable, glsBuiltinPrecisionTests.Expr);
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.MatrixVariable.prototype.doEvaluate = function(ctx) {
var tmp = this.m_matrix.doEvaluate(ctx);
return tmp.get(this.m_row, this.m_col);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Expr}
* @param {glsBuiltinPrecisionTests.Typename} typename
* @param {glsBuiltinPrecisionTests.Func} func
* @param {glsBuiltinPrecisionTests.Expr=} arg0
* @param {glsBuiltinPrecisionTests.Expr=} arg1
* @param {glsBuiltinPrecisionTests.Expr=} arg2
* @param {glsBuiltinPrecisionTests.Expr=} arg3
*/
glsBuiltinPrecisionTests.Apply = function(typename, func, arg0, arg1, arg2, arg3) {
glsBuiltinPrecisionTests.Expr.call(this, typename);
this.m_func = func;
/** @type {glsBuiltinPrecisionTests.Tuple4} */ this.m_args;
if (arg0 instanceof glsBuiltinPrecisionTests.Tuple4)
this.m_args = /** @type {glsBuiltinPrecisionTests.Tuple4} */ (arg0);
else {
this.m_args = new glsBuiltinPrecisionTests.Tuple4(arg0 || new glsBuiltinPrecisionTests.Void(),
arg1 || new glsBuiltinPrecisionTests.Void(),
arg2 || new glsBuiltinPrecisionTests.Void(),
arg3 || new glsBuiltinPrecisionTests.Void());
}
};
setParentClass(glsBuiltinPrecisionTests.Apply, glsBuiltinPrecisionTests.Expr);
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Apply.prototype.doPrintExpr = function() {
var args = [this.m_args.a, this.m_args.b, this.m_args.c, this.m_args.d];
return this.m_func.print(args);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @return {glsBuiltinPrecisionTests.Intervals}
*/
glsBuiltinPrecisionTests.Apply.prototype.doEvaluate = function(ctx) {
var debug = false;
if (debug) {
glsBuiltinPrecisionTests.Apply.prototype.doEvaluate.level = glsBuiltinPrecisionTests.Apply.prototype.doEvaluate.level || 0;
var level = glsBuiltinPrecisionTests.Apply.prototype.doEvaluate.level;
glsBuiltinPrecisionTests.Apply.prototype.doEvaluate.level++;
var name = this.m_func.constructor.toString();
name = name.replace(/[\s\S]*glsBuiltinPrecisionTests\./m, '').replace(/\.call[\s\S]*/m, '');
if (this.m_func.getName)
name += ' ' + this.m_func.getName();
console.log('<' + level + '> Function ' + name);
}
var a = this.m_args.a.evaluate(ctx);
var b = this.m_args.b.evaluate(ctx);
var c = this.m_args.c.evaluate(ctx);
var d = this.m_args.d.evaluate(ctx);
var retVal = this.m_func.applyFunction(ctx, a, b, c, d);
if (debug) {
console.log('<' + level + '> a: ' + a);
console.log('<' + level + '> b: ' + b);
console.log('<' + level + '> returning: ' + retVal);
glsBuiltinPrecisionTests.Apply.prototype.doEvaluate.level--;
}
return retVal;
};
/**
* @param {glsBuiltinPrecisionTests.Func} func
* @param {glsBuiltinPrecisionTests.Expr=} arg0
* @param {glsBuiltinPrecisionTests.Expr=} arg1
* @param {glsBuiltinPrecisionTests.Expr=} arg2
* @param {glsBuiltinPrecisionTests.Expr=} arg3
*/
var app = function(func, arg0, arg1, arg2, arg3) {
return new glsBuiltinPrecisionTests.Apply('float', func, arg0, arg1, arg2, arg3);
};
/**
* @param {glsBuiltinPrecisionTests.FuncSet} dst
*/
glsBuiltinPrecisionTests.Apply.prototype.doGetUsedFuncs = function(dst) {
this.m_func.getUsedFuncs(dst);
this.m_args.a.getUsedFuncs(dst);
this.m_args.b.getUsedFuncs(dst);
this.m_args.c.getUsedFuncs(dst);
this.m_args.d.getUsedFuncs(dst);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Apply}
* @param {glsBuiltinPrecisionTests.Func} func
* @param {glsBuiltinPrecisionTests.Expr=} arg0
* @param {glsBuiltinPrecisionTests.Expr=} arg1
* @param {glsBuiltinPrecisionTests.Expr=} arg2
* @param {glsBuiltinPrecisionTests.Expr=} arg3
*/
glsBuiltinPrecisionTests.ApplyScalar = function(func, arg0, arg1, arg2, arg3) {
glsBuiltinPrecisionTests.Apply.call(this, 'float', func, arg0, arg1, arg2, arg3);
};
setParentClass(glsBuiltinPrecisionTests.ApplyScalar, glsBuiltinPrecisionTests.Apply);
glsBuiltinPrecisionTests.ApplyScalar.prototype.doEvaluate = function(ctx) {
var debug = false;
if (debug) {
glsBuiltinPrecisionTests.ApplyScalar.prototype.doEvaluate.level = glsBuiltinPrecisionTests.ApplyScalar.prototype.doEvaluate.level || 0;
var level = glsBuiltinPrecisionTests.ApplyScalar.prototype.doEvaluate.level;
glsBuiltinPrecisionTests.ApplyScalar.prototype.doEvaluate.level++;
var name = this.m_func.constructor.toString();
name = name.replace(/[\s\S]*glsBuiltinPrecisionTests\./m, '').replace(/\.call[\s\S]*/m, '');
if (this.m_func.getName)
name += ' ' + this.m_func.getName();
console.log('scalar<' + level + '> Function ' + name);
}
var a = this.m_args.a.evaluate(ctx);
var b = this.m_args.b.evaluate(ctx);
var c = this.m_args.c.evaluate(ctx);
var d = this.m_args.d.evaluate(ctx);
if (a instanceof Array) {
var ret = [];
for (var i = 0; i < a.length; i++) {
var p0 = a instanceof Array ? a[i] : a;
var p1 = b instanceof Array ? b[i] : b;
var p2 = c instanceof Array ? c[i] : c;
var p3 = d instanceof Array ? d[i] : d;
ret.push(this.m_func.applyFunction(ctx, p0, p1, p2, p3));
}
return ret;
}
var retVal = this.m_func.applyFunction(ctx, a, b, c, d);
if (debug) {
console.log('scalar<' + level + '> a: ' + a);
console.log('scalar<' + level + '> b: ' + b);
console.log('scalar<' + level + '> return1: ' + ret);
console.log('scalar<' + level + '> return2: ' + retVal);
glsBuiltinPrecisionTests.Apply.prototype.doEvaluate.level--;
}
return retVal;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Apply}
*/
glsBuiltinPrecisionTests.ApplyVar = function(typename, func, arg0, arg1, arg2, arg3) {
glsBuiltinPrecisionTests.Apply.call(this, typename, func, arg0, arg1, arg2, arg3);
};
setParentClass(glsBuiltinPrecisionTests.ApplyVar, glsBuiltinPrecisionTests.Apply);
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @return {glsBuiltinPrecisionTests.Intervals}
*/
glsBuiltinPrecisionTests.ApplyVar.prototype.doEvaluate = function(ctx) {
return this.m_func.applyFunction(ctx,
ctx.env.lookup(this.m_args.a), ctx.env.lookup(this.m_args.b),
ctx.env.lookup(this.m_args.c), ctx.env.lookup(this.m_args.d),
[this.m_args.a.getName(), this.m_args.b.getName(),
this.m_args.c.getName(), this.m_args.d.getName()]);
};
/**
* @constructor
*/
glsBuiltinPrecisionTests.FuncBase = function() {};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.FuncBase.prototype.getName = function() {
return '';
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.FuncBase.prototype.getRequiredExtension = function() {
return '';
};
/**
* @param {Array<glsBuiltinPrecisionTests.ExprBase>} args
* @return {string}
*/
glsBuiltinPrecisionTests.FuncBase.prototype.print = function(args) {
return '';
};
/**
* Index of output parameter, or -1 if none of the parameters is output.
* @return {number}
*/
glsBuiltinPrecisionTests.FuncBase.prototype.getOutParamIndex = function() {
return -1;
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.FuncBase.prototype.printDefinition = function() {
return this.doPrintDefinition();
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.FuncBase.prototype.doPrintDefinition = function() {
throw new Error('Virtual function. Please override.');
};
/**
* typedef set<const FuncBase*> FuncSet;
* @param {glsBuiltinPrecisionTests.FuncSet} dst
*/
glsBuiltinPrecisionTests.FuncBase.prototype.getUsedFuncs = function(dst) {
this.doGetUsedFuncs(dst);
};
/**
* @param {glsBuiltinPrecisionTests.FuncSet} dst
*/
glsBuiltinPrecisionTests.FuncBase.prototype.doGetUsedFuncs = function(dst) {};
/*************************************/
/**
* \brief Function objects.
*
* Each Func object represents a GLSL function. It can be applied to interval
* arguments, and it returns the an interval that is a conservative
* approximation of the image of the GLSL function over the argument
* intervals. That is, it is given a set of possible arguments and it returns
* the set of possible values.
*
* @constructor
* @extends {glsBuiltinPrecisionTests.FuncBase}
* @param {glsBuiltinPrecisionTests.Signature} Sig_ template <typename Sig_>
*/
glsBuiltinPrecisionTests.Func = function(Sig_) {
glsBuiltinPrecisionTests.FuncBase.call(this);
this.Sig = Sig_;
this.Ret = this.Sig.Ret;
this.Arg0 = this.Sig.Arg0;
this.Arg1 = this.Sig.Arg1;
this.Arg2 = this.Sig.Arg2;
this.Arg3 = this.Sig.Arg3;
};
glsBuiltinPrecisionTests.Func.prototype = Object.create(glsBuiltinPrecisionTests.FuncBase.prototype);
glsBuiltinPrecisionTests.Func.prototype.constructor = glsBuiltinPrecisionTests.Func;
/**
* @param {Array<glsBuiltinPrecisionTests.ExprBase>} args
* @return {string}
*/
glsBuiltinPrecisionTests.Func.prototype.print = function(args) {
return this.doPrint(args);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {glsBuiltinPrecisionTests.Intervals=} Iarg0
* @param {glsBuiltinPrecisionTests.Intervals=} Iarg1
* @param {glsBuiltinPrecisionTests.Intervals=} Iarg2
* @param {glsBuiltinPrecisionTests.Intervals=} Iarg3
* @return {glsBuiltinPrecisionTests.Intervals}
*/
glsBuiltinPrecisionTests.Func.prototype.applyFunction = function(ctx, Iarg0, Iarg1, Iarg2, Iarg3, variablenames) {
return this.applyArgs(ctx, new glsBuiltinPrecisionTests.Tuple4(Iarg0, Iarg1, Iarg2, Iarg3), variablenames);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {glsBuiltinPrecisionTests.Tuple4} args
* @return {glsBuiltinPrecisionTests.Intervals}
*/
glsBuiltinPrecisionTests.Func.prototype.applyArgs = function(ctx, args, variablenames) {
return this.doApply(ctx, args, variablenames);
};
/**
* @return {glsBuiltinPrecisionTests.ParamNames}
*/
glsBuiltinPrecisionTests.Func.prototype.getParamNames = function() {
return this.doGetParamNames();
};
/**
* @param {Array<glsBuiltinPrecisionTests.ExprBase>} args
* @return {string}
*/
glsBuiltinPrecisionTests.Func.prototype.doPrint = function(args) {
/** type{string} */ var os = this.getName() + '(';
// TODO: fix the generics
for (var i = 0; i < args.length; i++)
if (glsBuiltinPrecisionTests.isTypeValid(args[i].typename)) {
if (i != 0)
os += ', ';
os += args[i];
}
os += ')';
return os;
};
/**
* @return {glsBuiltinPrecisionTests.ParamNames} args
*/
glsBuiltinPrecisionTests.Func.prototype.doGetParamNames = function() {
/** @type {glsBuiltinPrecisionTests.ParamNames} */ var names = new glsBuiltinPrecisionTests.Tuple4('a', 'b', 'c', 'd');
return names;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Func}
* @param {glsBuiltinPrecisionTests.Signature} Sig template <typename Sig>
*
*/
glsBuiltinPrecisionTests.PrimitiveFunc = function(Sig) {
glsBuiltinPrecisionTests.Func.call(this, Sig);
this.Ret = Sig.Ret;
};
glsBuiltinPrecisionTests.PrimitiveFunc.prototype = Object.create(glsBuiltinPrecisionTests.Func.prototype);
glsBuiltinPrecisionTests.PrimitiveFunc.prototype.constructor = glsBuiltinPrecisionTests.PrimitiveFunc;
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
* @param {string} typename
*
*/
glsBuiltinPrecisionTests.Cond = function(typename) {
var sig = new glsBuiltinPrecisionTests.Signature(typename, 'boolean', typename, typename);
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Cond, glsBuiltinPrecisionTests.PrimitiveFunc);
glsBuiltinPrecisionTests.Cond.prototype.getName = function() {
return '_cond';
};
glsBuiltinPrecisionTests.Cond.prototype.doPrint = function(args) {
var str = '(' + args[0] + ' ? ' + args[1] + ' : ' + args[2] + ')';
return str;
};
glsBuiltinPrecisionTests.Cond.prototype.doApply = function(ctx, iargs) {
var ret;
if (glsBuiltinPrecisionTests.contains(this.Sig.Arg0, iargs.a, 1))
ret = iargs.b;
if (glsBuiltinPrecisionTests.contains(this.Sig.Arg0, iargs.a, 0)) {
if (ret)
ret = glsBuiltinPrecisionTests.union(this.Sig.Ret, ret, iargs.c);
else
ret = iargs.c;
}
if (ret)
return ret;
return new tcuInterval.Interval();
};
/**
* If multipleInputs is false, GenVec duplicates first input to proper size
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
* @param {number} size
* @param {boolean=} multipleInputs
*/
glsBuiltinPrecisionTests.GenVec = function(size, multipleInputs) {
var vecName = glsBuiltinPrecisionTests.sizeToName(size);
var p = [
size >= 1 ? 'float' : undefined,
size >= 2 ? 'float' : undefined,
size >= 3 ? 'float' : undefined,
size >= 4 ? 'float' : undefined
];
var sig = new glsBuiltinPrecisionTests.Signature(vecName, p[0], p[1], p[2], p[3]);
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, sig);
this.size = size;
this.vecName = vecName;
this.multipleInputs = multipleInputs || false;
};
setParentClass(glsBuiltinPrecisionTests.GenVec, glsBuiltinPrecisionTests.PrimitiveFunc);
glsBuiltinPrecisionTests.GenVec.prototype.getName = function() {
return this.vecName;
};
glsBuiltinPrecisionTests.GenVec.prototype.doApply = function(ctx, iargs) {
if (this.size == 1)
return iargs.a;
var ret = this.multipleInputs ?
[iargs.a, iargs.b, iargs.c, iargs.d] :
[iargs.a, iargs.a, iargs.a, iargs.a];
return ret.slice(0, this.size);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
* @param {number} rows
* @param {number} cols
*/
glsBuiltinPrecisionTests.GenMat = function(rows, cols) {
var name = glsBuiltinPrecisionTests.dataTypeNameOfMatrix('float', rows, cols);
var vecName = glsBuiltinPrecisionTests.sizeToName(rows);
var p = [
cols >= 1 ? vecName : undefined,
cols >= 2 ? vecName : undefined,
cols >= 3 ? vecName : undefined,
cols >= 4 ? vecName : undefined
];
var sig = new glsBuiltinPrecisionTests.Signature(name, p[0], p[1], p[2], p[3]);
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, sig);
this.rows = rows;
this.cols = cols;
this.name = name;
this.vecName = vecName;
};
setParentClass(glsBuiltinPrecisionTests.GenMat, glsBuiltinPrecisionTests.PrimitiveFunc);
glsBuiltinPrecisionTests.GenMat.prototype.getName = function() {
return this.name;
};
glsBuiltinPrecisionTests.GenMat.prototype.doApply = function(ctx, iargs) {
var ret = new tcuMatrix.Matrix(this.rows, this.cols);
var inputs = [iargs.a, iargs.b, iargs.c, iargs.d];
for (var i = 0; i < this.rows; i++)
for (var j = 0; j < this.cols; j++)
ret.set(i, j, inputs[j][i]);
return ret;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
* @param {string} typename
*
*/
glsBuiltinPrecisionTests.CompareOperator = function(typename) {
var sig = new glsBuiltinPrecisionTests.Signature('boolean', typename, typename);
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.CompareOperator, glsBuiltinPrecisionTests.PrimitiveFunc);
glsBuiltinPrecisionTests.CompareOperator.prototype.doPrint = function(args) {
var str = '(' + args[0] + this.getSymbol() + args[1] + ')';
return str;
};
glsBuiltinPrecisionTests.CompareOperator.prototype.doApply = function(ctx, iargs) {
var arg0 = iargs.a;
var arg1 = iargs.b;
var ret = new tcuInterval.Interval();
if (this.canSucceed(arg0, arg1))
ret = new tcuInterval.Interval(1);
if (this.canFail(arg0, arg1))
ret.operatorOrAssignBinary(new tcuInterval.Interval(0));
return ret;
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.CompareOperator.prototype.getSymbol = function() {
throw new Error('Virtual function. Please override.');
};
/**
* @param {tcuInterval.Interval} arg0
* @param {tcuInterval.Interval} arg1
* @return {boolean}
*/
glsBuiltinPrecisionTests.CompareOperator.prototype.canSucceed = function(arg0, arg1) {
throw new Error('Virtual function. Please override.');
};
/**
* @param {tcuInterval.Interval} arg0
* @param {tcuInterval.Interval} arg1
* @return {boolean}
*/
glsBuiltinPrecisionTests.CompareOperator.prototype.canFail = function(arg0, arg1) {
throw new Error('Virtual function. Please override.');
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CompareOperator}
* @param {string} typename
*
*/
glsBuiltinPrecisionTests.LessThan = function(typename) {
glsBuiltinPrecisionTests.CompareOperator.call(this, typename);
};
setParentClass(glsBuiltinPrecisionTests.LessThan, glsBuiltinPrecisionTests.CompareOperator);
glsBuiltinPrecisionTests.LessThan.prototype.getSymbol = function() {
return '<';
};
glsBuiltinPrecisionTests.LessThan.prototype.canSucceed = function(a, b) {
return (a.lo() < b.hi());
};
glsBuiltinPrecisionTests.LessThan.prototype.canFail = function(a, b) {
return !(a.hi() < b.lo());
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
*
*/
glsBuiltinPrecisionTests.FloatFunc1 = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, sig);
};
glsBuiltinPrecisionTests.FloatFunc1.prototype = Object.create(glsBuiltinPrecisionTests.PrimitiveFunc.prototype);
glsBuiltinPrecisionTests.FloatFunc1.prototype.constructor = glsBuiltinPrecisionTests.FloatFunc1;
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {glsBuiltinPrecisionTests.Tuple4} iargs
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc1.prototype.doApply = function(ctx, iargs) {
var a = /** @type {tcuInterval.Interval} */ (iargs.a);
return this.applyMonotone(ctx, a);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {tcuInterval.Interval} iarg0
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc1.prototype.applyMonotone = function(ctx, iarg0) {
/** @type {tcuInterval.Interval} */ var ret = new tcuInterval.Interval();
/**
* @param {number=} x
* @param {number=} y
* @return {tcuInterval.Interval}
*/
var body = function(x, y) {
x = x || 0;
return this.applyPoint(ctx, x);
};
ret = tcuInterval.applyMonotone1(iarg0, body.bind(this));
ret.operatorOrAssignBinary(this.innerExtrema(ctx, iarg0));
ret.operatorAndAssignBinary(this.getCodomain().operatorOrBinary(new tcuInterval.Interval(NaN)));
return ctx.format.convert(ret);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {tcuInterval.Interval} iargs
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc1.prototype.innerExtrema = function(ctx, iargs) {
return new tcuInterval.Interval(); // empty interval, i.e. no extrema
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {number} arg0
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc1.prototype.applyPoint = function(ctx, arg0) {
var exact = this.applyExact(arg0);
var prec = this.precision(ctx, exact, arg0);
var a = new tcuInterval.Interval(exact);
var b = tcuInterval.withNumbers(-prec, prec);
return tcuInterval.Interval.operatorSum(a, b);
};
/**
* @param {number} x
* @return {number}
*/
glsBuiltinPrecisionTests.FloatFunc1.prototype.applyExact = function(x) {
throw new Error('Internal error. Cannot apply');
};
/**
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc1.prototype.getCodomain = function() {
return tcuInterval.unbounded(true);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {number} x
* @param {number} y
* @return {number}
*/
glsBuiltinPrecisionTests.FloatFunc1.prototype.precision = function(ctx, x, y) {
return 0;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FloatFunc1}
*/
glsBuiltinPrecisionTests.Negate = function() {
glsBuiltinPrecisionTests.FloatFunc1.call(this);
};
setParentClass(glsBuiltinPrecisionTests.Negate, glsBuiltinPrecisionTests.FloatFunc1);
glsBuiltinPrecisionTests.Negate.prototype.getName = function() {
return '_negate';
};
glsBuiltinPrecisionTests.Negate.prototype.doPrint = function(args) {
return '-' + args[0];
};
glsBuiltinPrecisionTests.Negate.prototype.precision = function(ctx, ret, x) {
return 0;
};
glsBuiltinPrecisionTests.Negate.prototype.applyExact = function(x) {
return -x;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FloatFunc1}
*/
glsBuiltinPrecisionTests.InverseSqrt = function() {
glsBuiltinPrecisionTests.FloatFunc1.call(this);
};
setParentClass(glsBuiltinPrecisionTests.InverseSqrt, glsBuiltinPrecisionTests.FloatFunc1);
glsBuiltinPrecisionTests.InverseSqrt.prototype.getName = function() {
return 'inversesqrt';
};
glsBuiltinPrecisionTests.InverseSqrt.prototype.precision = function(ctx, ret, x) {
if (x <= 0)
return NaN;
return ctx.format.ulp(ret, 2.0);
};
glsBuiltinPrecisionTests.InverseSqrt.prototype.applyExact = function(x) {
return 1 / Math.sqrt(x);
};
glsBuiltinPrecisionTests.InverseSqrt.prototype.getCodomain = function() {
return tcuInterval.withNumbers(0, Infinity);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FloatFunc1}
*/
glsBuiltinPrecisionTests.Round = function() {
glsBuiltinPrecisionTests.FloatFunc1.call(this);
};
setParentClass(glsBuiltinPrecisionTests.Round, glsBuiltinPrecisionTests.FloatFunc1);
glsBuiltinPrecisionTests.Round.prototype.getName = function() {
return 'round';
};
glsBuiltinPrecisionTests.Round.prototype.precision = function(ctx, ret, x) {
return 0;
};
glsBuiltinPrecisionTests.Round.prototype.applyPoint = function(ctx, x) {
var truncated = Math.trunc(x);
var fract = x - truncated;
var ret = new tcuInterval.Interval();
// When x is inf or -inf, truncated would be inf or -inf too. Then fract
// would be NaN (inf - inf). While in native c code, it would be 0 (inf) or -0 (-inf).
// This behavior in JS differs from that in native c code.
if (Math.abs(fract) <= 0.5 || isNaN(fract))
ret.operatorOrAssignBinary(new tcuInterval.Interval(truncated));
if (Math.abs(fract) >= 0.5)
ret.operatorOrAssignBinary(new tcuInterval.Interval(truncated + deMath.deSign(fract)));
return ret;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FloatFunc1}
* @param {string} name
* @param {tcuInterval.DoubleFunc1} func
*/
glsBuiltinPrecisionTests.CFloatFunc1 = function(name, func) {
glsBuiltinPrecisionTests.FloatFunc1.call(this);
/** @type {string} */ this.m_name = name;
/** @type {tcuInterval.DoubleFunc1} */this.m_func = func;
};
glsBuiltinPrecisionTests.CFloatFunc1.prototype = Object.create(glsBuiltinPrecisionTests.FloatFunc1.prototype);
glsBuiltinPrecisionTests.CFloatFunc1.prototype.constructor = glsBuiltinPrecisionTests.CFloatFunc1;
/**
* @return {string}
*/
glsBuiltinPrecisionTests.CFloatFunc1.prototype.getName = function() {
return this.m_name;
};
/**
* @param {number} x
* @return {number}
*/
glsBuiltinPrecisionTests.CFloatFunc1.prototype.applyExact = function(x) {
return this.m_func(x);
};
/**
* PrimitiveFunc<Signature<float, float, float> >
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
*/
glsBuiltinPrecisionTests.FloatFunc2 = function() {
/** @type {glsBuiltinPrecisionTests.Signature} */ var Sig = new glsBuiltinPrecisionTests.Signature('float', 'float', 'float');
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, Sig);
};
glsBuiltinPrecisionTests.FloatFunc2.prototype = Object.create(glsBuiltinPrecisionTests.PrimitiveFunc.prototype);
glsBuiltinPrecisionTests.FloatFunc2.prototype.constructor = glsBuiltinPrecisionTests.FloatFunc2;
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {glsBuiltinPrecisionTests.Tuple4} iargs
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc2.prototype.doApply = function(ctx, iargs) {
var a = /** @type {tcuInterval.Interval} */ (iargs.a);
var b = /** @type {tcuInterval.Interval} */ (iargs.b);
return this.applyMonotone(ctx, a, b);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {tcuInterval.Interval} xi
* @param {tcuInterval.Interval} yi
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc2.prototype.applyMonotone = function(ctx, xi, yi) {
/** @type {tcuInterval.Interval} */ var ret = new tcuInterval.Interval();
/**
* @param {number=} x
* @param {number=} y
* @return {tcuInterval.Interval}
*/
var body = function(x, y) {
x = x || 0;
y = y || 0;
return this.applyPoint(ctx, x, y);
};
ret = tcuInterval.applyMonotone2(xi, yi, body.bind(this));
ret.operatorOrAssignBinary(this.innerExtrema(ctx, xi, yi));
ret.operatorAndAssignBinary(this.getCodomain().operatorOrBinary(new tcuInterval.Interval(NaN)));
return ctx.format.convert(ret);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {tcuInterval.Interval} xi
* @param {tcuInterval.Interval} yi
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc2.prototype.innerExtrema = function(ctx, xi, yi) {
return new tcuInterval.Interval(); // empty interval, i.e. no extrema
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {number} x
* @param {number} y
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc2.prototype.applyPoint = function(ctx, x, y) {
/** @type {number} */ var exact = this.applyExact(x, y);
var prec = this.precision(ctx, exact, x, y);
var a = new tcuInterval.Interval(exact);
var b = tcuInterval.withNumbers(-prec, prec);
return tcuInterval.Interval.operatorSum(a, b);
};
/**
* @param {number} x
* @param {number} y
* @return {number}
*/
glsBuiltinPrecisionTests.FloatFunc2.prototype.applyExact = function(x, y) {
throw new Error('Virtual function. Please override');
};
/**
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc2.prototype.getCodomain = function() {
return tcuInterval.unbounded(true);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {number} ret
* @param {number} x
* @param {number} y
* @return {number}
*/
glsBuiltinPrecisionTests.FloatFunc2.prototype.precision = function(ctx, ret, x, y) {
throw new Error('Virtual function. Please override');
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FloatFunc2}
* @param {string} name
* @param {tcuInterval.DoubleFunc2} func
*/
glsBuiltinPrecisionTests.CFloatFunc2 = function(name, func) {
glsBuiltinPrecisionTests.FloatFunc2.call(this);
/** @type {string} */ this.m_name = name;
/** @type {tcuInterval.DoubleFunc2} */ this.m_func = func;
};
glsBuiltinPrecisionTests.CFloatFunc2.prototype = Object.create(glsBuiltinPrecisionTests.FloatFunc2.prototype);
glsBuiltinPrecisionTests.CFloatFunc2.prototype.constructor = glsBuiltinPrecisionTests.CFloatFunc2;
/**
* @return {string}
*/
glsBuiltinPrecisionTests.CFloatFunc2.prototype.getName = function() {
return this.m_name;
};
/**
* @param {number} x
* @param {number} y
* @return {number}
*/
glsBuiltinPrecisionTests.CFloatFunc2.prototype.applyExact = function(x, y) {
return this.m_func(x, y);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FloatFunc2}
*/
glsBuiltinPrecisionTests.InfixOperator = function() {
glsBuiltinPrecisionTests.FloatFunc2.call(this);
};
glsBuiltinPrecisionTests.InfixOperator.prototype = Object.create(glsBuiltinPrecisionTests.FloatFunc2.prototype);
glsBuiltinPrecisionTests.InfixOperator.prototype.constructor = glsBuiltinPrecisionTests.InfixOperator;
/**
* @return {string}
*/
glsBuiltinPrecisionTests.InfixOperator.prototype.getSymbol = function() {
glsBuiltinPrecisionTests.FloatFunc2.call(this);
return '';
};
/**
* @param {Array<glsBuiltinPrecisionTests.ExprBase>} args
* @return {string}
*/
glsBuiltinPrecisionTests.InfixOperator.prototype.doPrint = function(args) {
return '(' + args[0] + ' ' + this.getSymbol() + ' ' + args[1] + ')';
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {number} x
* @param {number} y
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.InfixOperator.prototype.applyPoint = function(ctx, x, y) {
/** @type {number} */ var exact = this.applyExact(x, y);
// Allow either representable number on both sides of the exact value,
// but require exactly representable values to be preserved.
return ctx.format.roundOut(new tcuInterval.Interval(exact), isFinite(x) && isFinite(y));
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {number} x
* @param {number} y
* @param {number} z
* @return {number}
*/
glsBuiltinPrecisionTests.InfixOperator.prototype.precision = function(ctx, x, y, z) {
return 0;
};
/**
* Signature<float, float, float, float>
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
*/
glsBuiltinPrecisionTests.FloatFunc3 = function() {
/** @type {glsBuiltinPrecisionTests.Signature} */ var sig = new glsBuiltinPrecisionTests.Signature('float', 'float', 'float', 'float');
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, sig);
};
glsBuiltinPrecisionTests.FloatFunc3.prototype = Object.create(glsBuiltinPrecisionTests.PrimitiveFunc.prototype);
glsBuiltinPrecisionTests.FloatFunc3.prototype.constructor = glsBuiltinPrecisionTests.FloatFunc3;
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {glsBuiltinPrecisionTests.Tuple4} iargs
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc3.prototype.doApply = function(ctx, iargs) {
var a = /** @type {tcuInterval.Interval} */ (iargs.a);
var b = /** @type {tcuInterval.Interval} */ (iargs.b);
var c = /** @type {tcuInterval.Interval} */ (iargs.c);
var retVal = this.applyMonotone(ctx, a, b, c);
return retVal;
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {tcuInterval.Interval} xi
* @param {tcuInterval.Interval} yi
* @param {tcuInterval.Interval} zi
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc3.prototype.applyMonotone = function(ctx, xi, yi, zi) {
/**
* @param {number=} x
* @param {number=} y
* @param {number=} z
* @return {tcuInterval.Interval}
*/
var body = function(x, y, z) {
x = x || 0;
y = y || 0;
z = z || 0;
return this.applyPoint(ctx, x, y, z);
};
var ret = tcuInterval.applyMonotone3(xi, yi, zi, body.bind(this));
var retVal;
ret.operatorOrAssignBinary(this.innerExtrema(ctx, xi, yi, zi));
ret.operatorAndAssignBinary(this.getCodomain().operatorOrBinary(new tcuInterval.Interval(NaN)));
retVal = ctx.format.convert(ret);
return retVal;
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {tcuInterval.Interval} xi
* @param {tcuInterval.Interval} yi
* @param {tcuInterval.Interval} zi
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc3.prototype.innerExtrema = function(ctx, xi, yi, zi) {
return new tcuInterval.Interval(); // empty interval, i.e. no extrema
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {number} x
* @param {number} y
* @param {number} z
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc3.prototype.applyPoint = function(ctx, x, y, z) {
/** @type {number} */ var exact = this.applyExact(x, y, z);
/** @type {number} */ var prec = this.precision(ctx, exact, x, y, z);
var a = new tcuInterval.Interval(exact);
var b = tcuInterval.withNumbers(-prec, prec);
return tcuInterval.Interval.operatorSum(a, b);
};
/**
* @param {number} x
* @param {number} y
* @param {number} z
* @return {number}
*/
glsBuiltinPrecisionTests.FloatFunc3.prototype.applyExact = function(x, y, z) {
throw new Error('Virtual function. Please override');
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {number} result
* @param {number} x
* @param {number} y
* @param {number} z
* @return {number}
*/
glsBuiltinPrecisionTests.FloatFunc3.prototype.precision = function(ctx, result, x, y, z) {
throw new Error('Virtual function. Please override');
};
/**
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.FloatFunc3.prototype.getCodomain = function() {
return tcuInterval.unbounded(true);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FloatFunc3}
*/
glsBuiltinPrecisionTests.Clamp = function() {
glsBuiltinPrecisionTests.FloatFunc3.call(this);
};
setParentClass(glsBuiltinPrecisionTests.Clamp, glsBuiltinPrecisionTests.FloatFunc3);
glsBuiltinPrecisionTests.Clamp.prototype.getName = function() {
return 'clamp';
};
glsBuiltinPrecisionTests.Clamp.prototype.applyExact = function(x, minVal, maxVal) {
var debug = false;
var retVal;
retVal = deMath.clamp(x, minVal, maxVal);
if (debug) {
console.log('> minVal: ' + minVal);
console.log('> maxVal: ' + maxVal);
console.log('> x: ' + x);
console.log('> ret: ' + retVal);
}
return retVal;
};
glsBuiltinPrecisionTests.Clamp.prototype.precision = function(ctx, result, x, minVal, maxVal) {
var debug = false;
var retVal;
retVal = minVal > maxVal ? NaN : 0;
if (debug) {
console.log('precision> minVal: ' + minVal);
console.log('precision> maxVal: ' + maxVal);
console.log('precision> x: ' + x);
console.log('precision> ret: ' + retVal);
}
return retVal;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.InfixOperator}
*/
glsBuiltinPrecisionTests.Add = function() {
glsBuiltinPrecisionTests.InfixOperator.call(this);
};
glsBuiltinPrecisionTests.Add.prototype = Object.create(glsBuiltinPrecisionTests.InfixOperator.prototype);
glsBuiltinPrecisionTests.Add.prototype.constructor = glsBuiltinPrecisionTests.Add;
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Add.prototype.getName = function() {
return 'add';
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Add.prototype.getSymbol = function() {
return '+';
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {glsBuiltinPrecisionTests.Tuple4} iargs
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.Add.prototype.doApply = function(ctx, iargs) {
var a = /** @type {tcuInterval.Interval} */ (iargs.a);
var b = /** @type {tcuInterval.Interval} */ (iargs.b);
// Fast-path for common case
if (iargs.a.isOrdinary() && iargs.b.isOrdinary()) {
/** type{tcuInterval.Interval} */ var ret;
ret = tcuInterval.setIntervalBounds(
function(dummy) {
return iargs.a.lo() + iargs.b.lo();
},
function(dummy) {
return iargs.a.hi() + iargs.b.hi();
});
return ctx.format.convert(ctx.format.roundOut(ret, true));
}
return this.applyMonotone(ctx, a, b);
};
/**
* @param {number} x
* @param {number} y
* @return {number}
*/
glsBuiltinPrecisionTests.Add.prototype.applyExact = function(x, y) {
return x + y;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.InfixOperator}
*/
glsBuiltinPrecisionTests.Sub = function() {
glsBuiltinPrecisionTests.InfixOperator.call(this);
};
glsBuiltinPrecisionTests.Sub.prototype = Object.create(glsBuiltinPrecisionTests.InfixOperator.prototype);
glsBuiltinPrecisionTests.Sub.prototype.constructor = glsBuiltinPrecisionTests.Sub;
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Sub.prototype.getName = function() {
return 'sub';
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Sub.prototype.getSymbol = function() {
return '-';
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {glsBuiltinPrecisionTests.Tuple4} iargs
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.Sub.prototype.doApply = function(ctx, iargs) {
var a = /** @type {tcuInterval.Interval} */ (iargs.a);
var b = /** @type {tcuInterval.Interval} */ (iargs.b);
var retVal;
// Fast-path for common case
if (iargs.a.isOrdinary() && iargs.b.isOrdinary()) {
/** type{tcuInterval.Interval} */ var ret;
ret = tcuInterval.setIntervalBounds(
function(dummy) {
return iargs.a.lo() - iargs.b.hi();
},
function(dummy) {
return iargs.a.hi() - iargs.b.lo();
});
return ctx.format.convert(ctx.format.roundOut(ret, true));
}
retVal = this.applyMonotone(ctx, a, b);
return retVal;
};
/**
* @param {number} x
* @param {number} y
* @return {number}
*/
glsBuiltinPrecisionTests.Sub.prototype.applyExact = function(x, y) {
return x - y;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.InfixOperator}
*/
glsBuiltinPrecisionTests.Mul = function() {
glsBuiltinPrecisionTests.InfixOperator.call(this);
};
glsBuiltinPrecisionTests.Mul.prototype = Object.create(glsBuiltinPrecisionTests.InfixOperator.prototype);
glsBuiltinPrecisionTests.Mul.prototype.constructor = glsBuiltinPrecisionTests.Mul;
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Mul.prototype.getName = function() {
return 'mul';
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Mul.prototype.getSymbol = function() {
return '*';
};
glsBuiltinPrecisionTests.isNegative = function(n) {
return ((n = +n) || 1 / n) < 0;
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {glsBuiltinPrecisionTests.Tuple4} iargs
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.Mul.prototype.doApply = function(ctx, iargs) {
var a = /** @type {tcuInterval.Interval} */ (iargs.a);
var b = /** @type {tcuInterval.Interval} */ (iargs.b);
// Fast-path for common case
if (iargs.a.isOrdinary() && iargs.b.isOrdinary()) {
/** type{tcuInterval.Interval} */ var ret = new tcuInterval.Interval();
if (glsBuiltinPrecisionTests.isNegative(a.hi())) {
a = a.operatorNegative();
b = b.operatorNegative();
}
if (a.lo() >= 0 && b.lo() >= 0) {
ret = tcuInterval.setIntervalBounds(
function(dummy) {
return iargs.a.lo() * iargs.b.lo();
},
function(dummy) {
return iargs.a.hi() * iargs.b.hi();
});
return ctx.format.convert(ctx.format.roundOut(ret, true));
}
if (a.lo() >= 0 && b.hi() <= 0) {
ret = tcuInterval.setIntervalBounds(
function(dummy) {
return iargs.a.hi() * iargs.b.lo();
},
function(dummy) {
return iargs.a.lo() * iargs.b.hi();
});
return ctx.format.convert(ctx.format.roundOut(ret, true));
}
}
return this.applyMonotone(ctx, a, b);
};
/**
* @param {number} x
* @param {number} y
* @return {number}
*/
glsBuiltinPrecisionTests.Mul.prototype.applyExact = function(x, y) {
return x * y;
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {tcuInterval.Interval} xi
* @param {tcuInterval.Interval} yi
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.Mul.prototype.innerExtrema = function(ctx, xi, yi) {
if (((xi.contains(tcuInterval.NEGATIVE_INFINITY) || xi.contains(tcuInterval.POSITIVE_INFINITY)) && yi.contains(tcuInterval.ZERO)) ||
((yi.contains(tcuInterval.NEGATIVE_INFINITY) || yi.contains(tcuInterval.POSITIVE_INFINITY)) && xi.contains(tcuInterval.ZERO)))
return new tcuInterval.Interval(NaN);
return new tcuInterval.Interval(); // empty interval, i.e. no extrema
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.InfixOperator}
*/
glsBuiltinPrecisionTests.Div = function() {
glsBuiltinPrecisionTests.InfixOperator.call(this);
};
glsBuiltinPrecisionTests.Div.prototype = Object.create(glsBuiltinPrecisionTests.InfixOperator.prototype);
glsBuiltinPrecisionTests.Div.prototype.constructor = glsBuiltinPrecisionTests.Div;
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Div.prototype.getName = function() {
return 'div';
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Div.prototype.getSymbol = function() {
return '/';
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {tcuInterval.Interval} nom
* @param {tcuInterval.Interval} den
* @return {tcuInterval.Interval}
*/
glsBuiltinPrecisionTests.Div.prototype.innerExtrema = function(ctx, nom, den) {
var ret = new tcuInterval.Interval();
if (den.contains(tcuInterval.ZERO)) {
if (nom.contains(tcuInterval.ZERO))
ret.operatorOrAssignBinary(tcuInterval.NAN);
if (nom.lo() < 0 || nom.hi() > 0.0)
ret.operatorOrAssignBinary(tcuInterval.unbounded());
}
return ret;
};
glsBuiltinPrecisionTests.Div.prototype.precision = function(ctx, ret, nom, den) {
var fmt = ctx.format;
// \todo [2014-03-05 lauri] Check that the limits in GLSL 3.10 are actually correct.
// For now, we assume that division's precision is 2.5 ULP when the value is within
// [2^MINEXP, 2^MAXEXP-1]
if (den === 0)
return 0; // Result must be exactly inf
else if (deMath.deInBounds32(Math.abs(den),
deMath.deLdExp(1, fmt.getMinExp()),
deMath.deLdExp(1, fmt.getMaxExp() - 1)))
return fmt.ulp(ret, 2.5);
else
return Infinity; // Can be any number, but must be a number.
};
/**
* @param {number} x
* @param {number} y
* @return {number}
*/
glsBuiltinPrecisionTests.Div.prototype.applyExact = function(x, y) {
return x / y;
};
glsBuiltinPrecisionTests.Div.prototype.applyPoint = function(ctx, x, y) {
var ret = glsBuiltinPrecisionTests.FloatFunc2.prototype.applyPoint.call(this, ctx, x, y);
if (isFinite(x) && isFinite(y) && y != 0) {
var dst = ctx.format.convert(ret);
if (dst.contains(tcuInterval.NEGATIVE_INFINITY)) {
ret.operatorOrAssignBinary(-ctx.format.getMaxValue());
}
if (dst.contains(tcuInterval.POSITIVE_INFINITY)) {
ret.operatorOrAssignBinary(+ctx.format.getMaxValue());
}
}
return ret;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
*/
glsBuiltinPrecisionTests.CompWiseFunc = function(typename, Sig) {
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, Sig);
this.typename = typename;
};
setParentClass(glsBuiltinPrecisionTests.CompWiseFunc, glsBuiltinPrecisionTests.PrimitiveFunc);
/**
* @return {string}
*/
glsBuiltinPrecisionTests.CompWiseFunc.prototype.getName = function() {
return this.doGetScalarFunc().getName();
};
/**
* @param {Array<glsBuiltinPrecisionTests.ExprBase>} args
* @return {string}
*/
glsBuiltinPrecisionTests.CompWiseFunc.prototype.doPrint = function(args) {
return this.doGetScalarFunc().print(args);
};
/**
* @return {glsBuiltinPrecisionTests.Func}
*/
glsBuiltinPrecisionTests.CompWiseFunc.prototype.doGetScalarFunc = function() {
throw new Error('Virtual function. Please override.');
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CompWiseFunc}
* @param {number} rows
* @param {number} cols
*/
glsBuiltinPrecisionTests.CompMatFuncBase = function(rows, cols) {
var name = glsBuiltinPrecisionTests.dataTypeNameOfMatrix('float', rows, cols);
glsBuiltinPrecisionTests.CompWiseFunc.call(this, 'float', new glsBuiltinPrecisionTests.Signature(name, name, name));
this.rows = rows;
this.cols = cols;
};
setParentClass(glsBuiltinPrecisionTests.CompMatFuncBase, glsBuiltinPrecisionTests.CompWiseFunc);
glsBuiltinPrecisionTests.CompMatFuncBase.prototype.doApply = function(ctx, iargs) {
var ret = new tcuMatrix.Matrix(this.rows, this.cols);
var fun = this.doGetScalarFunc();
for (var row = 0; row < this.rows; ++row)
for (var col = 0; col < this.cols; ++col)
ret.set(row, col, fun.applyFunction(ctx,
iargs.a.get(row, col),
iargs.b.get(row, col)));
return ret;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CompMatFuncBase}
* @param {function(new:glsBuiltinPrecisionTests.Func)} F
* @param {number} rows
* @param {number} cols
*/
glsBuiltinPrecisionTests.CompMatFunc = function(F, rows, cols) {
glsBuiltinPrecisionTests.CompMatFuncBase.call(this, rows, cols);
this.m_function = F;
};
setParentClass(glsBuiltinPrecisionTests.CompMatFunc, glsBuiltinPrecisionTests.CompMatFuncBase);
/**
* @return {glsBuiltinPrecisionTests.Func}
*/
glsBuiltinPrecisionTests.CompMatFunc.prototype.doGetScalarFunc = function() {
return new this.m_function();
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Mul}
*/
glsBuiltinPrecisionTests.ScalarMatrixCompMult = function() {
glsBuiltinPrecisionTests.Mul.call(this);
};
setParentClass(glsBuiltinPrecisionTests.ScalarMatrixCompMult, glsBuiltinPrecisionTests.Mul);
/**
* @return {string}
*/
glsBuiltinPrecisionTests.ScalarMatrixCompMult.prototype.getName = function() {
return 'matrixCompMult';
};
/**
* @param {Array<glsBuiltinPrecisionTests.ExprBase>} args
* @return {string}
*/
glsBuiltinPrecisionTests.ScalarMatrixCompMult.prototype.doPrint = function(args) {
return glsBuiltinPrecisionTests.Func.prototype.doPrint.call(this, args);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CompMatFunc}
* @param {number} rows
* @param {number} cols
*/
glsBuiltinPrecisionTests.MatrixCompMult = function(rows, cols) {
glsBuiltinPrecisionTests.CompMatFunc.call(this, glsBuiltinPrecisionTests.ScalarMatrixCompMult, rows, cols);
};
setParentClass(glsBuiltinPrecisionTests.MatrixCompMult, glsBuiltinPrecisionTests.CompMatFunc);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
* @param {number} rows
* @param {number} cols
*/
glsBuiltinPrecisionTests.OuterProduct = function(rows, cols) {
var name = glsBuiltinPrecisionTests.dataTypeNameOfMatrix('float', rows, cols);
var sig = new glsBuiltinPrecisionTests.Signature(name, 'vec' + rows, 'vec' + cols);
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, sig);
this.rows = rows;
this.cols = cols;
};
setParentClass(glsBuiltinPrecisionTests.OuterProduct, glsBuiltinPrecisionTests.PrimitiveFunc);
/**
* @return {string}
*/
glsBuiltinPrecisionTests.OuterProduct.prototype.getName = function() {
return 'outerProduct';
};
glsBuiltinPrecisionTests.OuterProduct.prototype.doApply = function(ctx, iargs) {
var ret = new tcuMatrix.Matrix(this.rows, this.cols);
var mul = new glsBuiltinPrecisionTests.Mul();
for (var row = 0; row < this.rows; ++row) {
for (var col = 0; col < this.cols; ++col)
ret.set(row, col, mul.applyFunction(ctx, iargs.a[row], iargs.b[col]));
}
return ret;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
* @param {number} rows
* @param {number} cols
*/
glsBuiltinPrecisionTests.Transpose = function(rows, cols) {
var nameRet = glsBuiltinPrecisionTests.dataTypeNameOfMatrix('float', rows, cols);
var nameParam = glsBuiltinPrecisionTests.dataTypeNameOfMatrix('float', cols, rows);
var sig = new glsBuiltinPrecisionTests.Signature(nameRet, nameParam);
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, sig);
this.rows = rows;
this.cols = cols;
};
setParentClass(glsBuiltinPrecisionTests.Transpose, glsBuiltinPrecisionTests.PrimitiveFunc);
/**
* @return {string}
*/
glsBuiltinPrecisionTests.Transpose.prototype.getName = function() {
return 'transpose';
};
glsBuiltinPrecisionTests.Transpose.prototype.doApply = function(ctx, iargs) {
var ret = new tcuMatrix.Matrix(this.rows, this.cols);
for (var row = 0; row < this.rows; ++row)
for (var col = 0; col < this.cols; ++col)
ret.set(row, col, iargs.a.get(col, row));
return ret;
};
/**
* @constructor
* @param {*} In
*/
glsBuiltinPrecisionTests.Inputs = function(In) {
// vector<typename In::In0> in0;
// vector<typename In::In1> in1;
// vector<typename In::In2> in2;
// vector<typename In::In3> in3;
this.in0 = [];
this.in1 = [];
this.in2 = [];
this.in3 = [];
};
/**
* @constructor
* @param {number} size
* @param {*} Out
*/
glsBuiltinPrecisionTests.Outputs = function(size, Out) {
// Outputs (size_t size) : out0(size), out1(size) {}
this.out0 = [];
this.out1 = [];
};
/**
* @constructor
* @param {*} In
* @param {*} Out
*/
glsBuiltinPrecisionTests.Variables = function(In, Out) {
this.in0 = new glsBuiltinPrecisionTests.Variable(In.In0);
this.in1 = new glsBuiltinPrecisionTests.Variable(In.In1);
this.in2 = new glsBuiltinPrecisionTests.Variable(In.In2);
this.in3 = new glsBuiltinPrecisionTests.Variable(In.In3);
this.out0 = new glsBuiltinPrecisionTests.Variable(Out.Out0);
this.out1 = new glsBuiltinPrecisionTests.Variable(Out.Out1);
};
/**
* @constructor
* @param {function(new:glsBuiltinPrecisionTests.Func)} F
* @return {glsBuiltinPrecisionTests.GenFuncs}
*/
glsBuiltinPrecisionTests.makeVectorizedFuncs = function(F) {
return new glsBuiltinPrecisionTests.GenFuncs(
new F(),
new glsBuiltinPrecisionTests.VectorizedFunc(new F(), 2),
new glsBuiltinPrecisionTests.VectorizedFunc(new F(), 3),
new glsBuiltinPrecisionTests.VectorizedFunc(new F(), 4));
};
/**
* @constructor
* @param {glsBuiltinPrecisionTests.Typename} typename
*/
glsBuiltinPrecisionTests.Sampling = function(typename) {
this.typename = typename;
};
/**
* @param {glsBuiltinPrecisionTests.Typename} typename
* @param {number=} size
* @return {glsBuiltinPrecisionTests.Sampling}
*/
glsBuiltinPrecisionTests.SamplingFactory = function(typename, size) {
if (size > 1)
return new glsBuiltinPrecisionTests.DefaultSamplingVector(typename, size);
switch (typename) {
case 'vec4' : return new glsBuiltinPrecisionTests.DefaultSamplingVector('float', 4);
case 'vec3' : return new glsBuiltinPrecisionTests.DefaultSamplingVector('float', 3);
case 'vec2' : return new glsBuiltinPrecisionTests.DefaultSamplingVector('float', 2);
case 'boolean' : return new glsBuiltinPrecisionTests.DefaultSamplingBool(typename);
case 'float' : return new glsBuiltinPrecisionTests.DefaultSamplingFloat(typename);
case 'mat2': return new glsBuiltinPrecisionTests.DefaultSamplingMatrix('float', 2, 2);
case 'mat2x3': return new glsBuiltinPrecisionTests.DefaultSamplingMatrix('float', 3, 2);
case 'mat2x4': return new glsBuiltinPrecisionTests.DefaultSamplingMatrix('float', 4, 2);
case 'mat3x2': return new glsBuiltinPrecisionTests.DefaultSamplingMatrix('float', 2, 3);
case 'mat3': return new glsBuiltinPrecisionTests.DefaultSamplingMatrix('float', 3, 3);
case 'mat3x4': return new glsBuiltinPrecisionTests.DefaultSamplingMatrix('float', 4, 3);
case 'mat4x2': return new glsBuiltinPrecisionTests.DefaultSamplingMatrix('float', 2, 4);
case 'mat4x3': return new glsBuiltinPrecisionTests.DefaultSamplingMatrix('float', 3, 4);
case 'mat4': return new glsBuiltinPrecisionTests.DefaultSamplingMatrix('float', 4, 4);
case 'int' : return new glsBuiltinPrecisionTests.DefaultSamplingInt(typename);
}
return new glsBuiltinPrecisionTests.DefaultSamplingVoid(typename);
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {Array<*>} arr
*/
glsBuiltinPrecisionTests.Sampling.prototype.genFixeds = function(fmt, arr) {
throw new Error('Virtual function. Please override.');
};
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {gluShaderUtil.precision} precision
* @param {deRandom.Random} random
* @return {*}
*/
glsBuiltinPrecisionTests.Sampling.prototype.genRandom = function(fmt, precision, random) {
return 0;
};
/**
* @return {number}
*/
glsBuiltinPrecisionTests.Sampling.prototype.getWeight = function() {
return 0;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Sampling}
* @param {glsBuiltinPrecisionTests.Typename} typename
*/
glsBuiltinPrecisionTests.DefaultSamplingVoid = function(typename) {
glsBuiltinPrecisionTests.Sampling.call(this, typename);
};
glsBuiltinPrecisionTests.DefaultSamplingVoid.prototype = Object.create(glsBuiltinPrecisionTests.Sampling.prototype);
glsBuiltinPrecisionTests.DefaultSamplingVoid.prototype.constructor = glsBuiltinPrecisionTests.DefaultSamplingVoid;
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {Array<number>} dst
*/
glsBuiltinPrecisionTests.DefaultSamplingVoid.prototype.genFixeds = function(fmt, dst) {
dst.push(NaN);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Sampling}
* @param {glsBuiltinPrecisionTests.Typename} typename
*/
glsBuiltinPrecisionTests.DefaultSamplingBool = function(typename) {
glsBuiltinPrecisionTests.Sampling.call(this, typename);
};
glsBuiltinPrecisionTests.DefaultSamplingBool.prototype = Object.create(glsBuiltinPrecisionTests.Sampling.prototype);
glsBuiltinPrecisionTests.DefaultSamplingBool.prototype.constructor = glsBuiltinPrecisionTests.DefaultSamplingBool;
/**
* @param {tcuFloatFormat.FloatFormat} fmt
* @param {Array<Boolean>} dst
*/
glsBuiltinPrecisionTests.DefaultSamplingBool.prototype.genFixeds = function(fmt, dst) {
dst.push(true);
dst.push(false);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Sampling}
* @param {glsBuiltinPrecisionTests.Typename} typename
*/
glsBuiltinPrecisionTests.DefaultSamplingInt = function(typename) {
glsBuiltinPrecisionTests.Sampling.call(this, typename);
};
glsBuiltinPrecisionTests.DefaultSamplingInt.prototype = Object.create(glsBuiltinPrecisionTests.Sampling.prototype);
glsBuiltinPrecisionTests.DefaultSamplingInt.prototype.constructor = glsBuiltinPrecisionTests.DefaultSamplingInt;
glsBuiltinPrecisionTests.DefaultSamplingInt.prototype.genRandom = function(fmt, prec, rnd) {
/** @type {number} */ var exp = rnd.getInt(0, this.getNumBits(prec) - 2);
/** @type {number} */ var sign = rnd.getBool() ? -1 : 1;
return sign * rnd.getInt(0, 1 << exp);
};
glsBuiltinPrecisionTests.DefaultSamplingInt.prototype.genFixeds = function(fmt, dst) {
dst.push(0);
dst.push(-1);
dst.push(1);
};
glsBuiltinPrecisionTests.DefaultSamplingInt.prototype.getWeight = function() {
return 1.0;
};
/**
* @param {gluShaderUtil.precision} prec
* @return {number}
*/
glsBuiltinPrecisionTests.DefaultSamplingInt.prototype.getNumBits = function(prec) {
switch (prec) {
case gluShaderUtil.precision.PRECISION_LOWP: return 8;
case gluShaderUtil.precision.PRECISION_MEDIUMP: return 16;
case gluShaderUtil.precision.PRECISION_HIGHP: return 32;
default:
throw new Error('Invalid precision: ' + prec);
}
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Sampling}
* @param {glsBuiltinPrecisionTests.Typename} typename
*/
glsBuiltinPrecisionTests.DefaultSamplingFloat = function(typename) {
glsBuiltinPrecisionTests.Sampling.call(this, typename);
};
glsBuiltinPrecisionTests.DefaultSamplingFloat.prototype = Object.create(glsBuiltinPrecisionTests.Sampling.prototype);
glsBuiltinPrecisionTests.DefaultSamplingFloat.prototype.constructor = glsBuiltinPrecisionTests.DefaultSamplingFloat;
glsBuiltinPrecisionTests.DefaultSamplingFloat.prototype.genRandom = function(format, prec, rnd) {
/** type{number} */ var minExp = format.getMinExp();
/** type{number} */ var maxExp = format.getMaxExp();
/** type{boolean} */ var haveSubnormal = format.hasSubnormal() != tcuFloatFormat.YesNoMaybe.NO;
// Choose exponent so that the cumulative distribution is cubic.
// This makes the probability distribution quadratic, with the peak centered on zero.
/** type{number} */ var minRoot = deMath.deCbrt(minExp - 0.5 - (haveSubnormal ? 1.0 : 0.0));
/** type{number} */ var maxRoot = deMath.deCbrt(maxExp + 0.5);
/** type{number} */ var fractionBits = format.getFractionBits();
/** type{number} */ var exp = deMath.rint(Math.pow(rnd.getFloat(minRoot, maxRoot),
3.0));
/** type{number} */ var base = 0.0; // integral power of two
/** type{number} */ var quantum = 0.0; // smallest representable difference in the binade
/** type{number} */ var significand = 0.0; // Significand.
// DE_ASSERT(fractionBits < std::numeric_limits<float>::digits);
// Generate some occasional special numbers
switch (rnd.getInt(0, 64)) {
case 0: return 0;
case 1: return Number.POSITIVE_INFINITY;
case 2: return Number.NEGATIVE_INFINITY;
case 3: return NaN;
default: break;
}
if (exp >= minExp) {
// Normal number
base = deMath.deFloatLdExp(1.0, exp);
quantum = deMath.deFloatLdExp(1.0, exp - fractionBits);
} else {
// Subnormal
base = 0.0;
quantum = deMath.deFloatLdExp(1.0, minExp - fractionBits);
}
switch (rnd.getInt(0, 16)) {
// The highest number in this binade, significand is all bits one.
case 0:
significand = base - quantum;
break;
// Significand is one.
case 1:
significand = quantum;
break;
// Significand is zero.
case 2:
significand = 0.0;
break;
// Random (evenly distributed) significand.
default: {
/** type{number} */ var intFraction = rnd.getInt() & ((1 << fractionBits) - 1);
significand = intFraction * quantum;
}
}
// Produce positive numbers more often than negative.
return (rnd.getInt(0, 3) == 0 ? -1.0 : 1.0) * (base + significand);
};
glsBuiltinPrecisionTests.DefaultSamplingFloat.prototype.genFixeds = function(format, dst) {
/** @type {number} */ var minExp = format.getMinExp();
/** @type {number} */ var maxExp = format.getMaxExp();
/** @type {number} */ var fractionBits = format.getFractionBits();
/** @type {number} */ var minQuantum = deMath.deFloatLdExp(1.0, minExp - fractionBits);
/** @type {number} */ var minNormalized = deMath.deFloatLdExp(1.0, minExp);
/** @type {number} */ var maxQuantum = deMath.deFloatLdExp(1.0, maxExp - fractionBits);
// If unit testing is enabled, include exact numbers
if (enableUnittests) {
dst.push(0.2);
dst.push(0.5);
}
// NaN
dst.push(NaN);
// Zero
dst.push(0.0);
for (var sign = -1; sign <= 1; sign += 2) {
// Smallest subnormal
dst.push(sign * minQuantum);
// Largest subnormal
dst.push(sign * (minNormalized - minQuantum));
// Smallest normalized
dst.push(sign * minNormalized);
// Next smallest normalized
dst.push(sign * (minNormalized + minQuantum));
dst.push(sign * 0.5);
dst.push(sign * 1.0);
dst.push(sign * 2.0);
// Largest number
dst.push(sign * (deMath.deFloatLdExp(1.0, maxExp) +
(deMath.deFloatLdExp(1.0, maxExp) - maxQuantum)));
dst.push(sign * Number.POSITIVE_INFINITY);
}
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Sampling}
* @param {glsBuiltinPrecisionTests.Typename} typename
* @param {number} size
*/
glsBuiltinPrecisionTests.DefaultSamplingVector = function(typename, size) {
glsBuiltinPrecisionTests.Sampling.call(this, typename);
this.size = size;
};
glsBuiltinPrecisionTests.DefaultSamplingVector.prototype = Object.create(glsBuiltinPrecisionTests.Sampling.prototype);
glsBuiltinPrecisionTests.DefaultSamplingVector.prototype.constructor = glsBuiltinPrecisionTests.DefaultSamplingVector;
glsBuiltinPrecisionTests.DefaultSamplingVector.prototype.genRandom = function(fmt, prec, rnd) {
/** @type {Array<*>} */ var ret = [];
for (var ndx = 0; ndx < this.size; ++ndx)
ret[ndx] = glsBuiltinPrecisionTests.SamplingFactory(this.typename).genRandom(fmt, prec, rnd);
return ret;
};
glsBuiltinPrecisionTests.DefaultSamplingVector.prototype.genFixeds = function(fmt, dst) {
/** @type {Array<*>} */ var scalars = [];
glsBuiltinPrecisionTests.SamplingFactory(this.typename).genFixeds(fmt, scalars);
for (var scalarNdx = 0; scalarNdx < scalars.length; ++scalarNdx) {
var value = [];
for (var i = 0; i < this.size; i++)
value[i] = scalars[scalarNdx];
dst.push(value);
}
};
glsBuiltinPrecisionTests.DefaultSamplingVector.prototype.getWeight = function() {
return Math.pow(glsBuiltinPrecisionTests.SamplingFactory(this.typename).getWeight(), this.size);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Sampling}
* @param {glsBuiltinPrecisionTests.Typename} typename
* @param {number} rows
* @param {number} cols
*/
glsBuiltinPrecisionTests.DefaultSamplingMatrix = function(typename, rows, cols) {
glsBuiltinPrecisionTests.Sampling.call(this, typename);
this.rows = rows;
this.cols = cols;
};
glsBuiltinPrecisionTests.DefaultSamplingMatrix.prototype = Object.create(glsBuiltinPrecisionTests.Sampling.prototype);
glsBuiltinPrecisionTests.DefaultSamplingMatrix.prototype.constructor = glsBuiltinPrecisionTests.DefaultSamplingMatrix;
glsBuiltinPrecisionTests.DefaultSamplingMatrix.prototype.genRandom = function(fmt, prec, rnd) {
/** @type {tcuMatrix.Matrix} */ var ret = new tcuMatrix.Matrix(this.rows, this.cols);
var sampler = glsBuiltinPrecisionTests.SamplingFactory(this.typename);
for (var rowNdx = 0; rowNdx < this.rows; ++rowNdx)
for (var colNdx = 0; colNdx < this.cols; ++colNdx)
ret.set(rowNdx, colNdx, sampler.genRandom(fmt, prec, rnd));
return ret;
};
glsBuiltinPrecisionTests.DefaultSamplingMatrix.prototype.genFixeds = function(fmt, dst) {
/** @type {Array<number>} */ var scalars = [];
glsBuiltinPrecisionTests.SamplingFactory(this.typename).genFixeds(fmt, scalars);
for (var scalarNdx = 0; scalarNdx < scalars.length; ++scalarNdx)
dst.push(new tcuMatrix.Matrix(this.rows, this.cols, scalars[scalarNdx]));
if (this.cols == this.rows) {
var mat = new tcuMatrix.Matrix(this.rows, this.cols, 0);
var x = 1;
mat.set(0, 0, x);
for (var ndx = 0; ndx < this.cols; ++ndx) {
mat.set(this.cols - 1 - ndx, ndx, x);
x *= 2;
}
dst.push(mat);
}
};
glsBuiltinPrecisionTests.DefaultSamplingMatrix.prototype.getWeight = function() {
return Math.pow(glsBuiltinPrecisionTests.SamplingFactory(this.typename).getWeight(), this.rows * this.cols);
};
/**
* @constructor
* @param {number=} size
* @param {glsBuiltinPrecisionTests.InTypes} In
*/
glsBuiltinPrecisionTests.Samplings = function(In, size) {
this.in0 = glsBuiltinPrecisionTests.SamplingFactory(In.In0, size);
this.in1 = glsBuiltinPrecisionTests.SamplingFactory(In.In1, size);
this.in2 = glsBuiltinPrecisionTests.SamplingFactory(In.In2, size);
this.in3 = glsBuiltinPrecisionTests.SamplingFactory(In.In3, size);
};
/**
* @param {glsBuiltinPrecisionTests.InTypes} In
* @param {number=} size
* @constructor
* @extends {glsBuiltinPrecisionTests.Samplings}
*/
glsBuiltinPrecisionTests.DefaultSamplings = function(In, size) {
glsBuiltinPrecisionTests.Samplings.call(this, In, size);
};
/**
* @constructor
* @extends {tcuTestCase.DeqpTest}
* @param {glsBuiltinPrecisionTests.Context} context
* @param {string} name
* @param {string} extension
*/
glsBuiltinPrecisionTests.PrecisionCase = function(context, name, extension) {
/** @type {string} */ this.m_extension = extension === undefined ? '' : extension;
/** @type {glsBuiltinPrecisionTests.Context} */ this.m_ctx = context;
/** @type {*} */ this.m_status;
/** @type {deRandom.Random} */ this.m_rnd = new deRandom.Random(1234); // (0xdeadbeefu + context.testContext.getCommandLine().getBaseSeed())
tcuTestCase.DeqpTest.call(this, name, extension);
};
glsBuiltinPrecisionTests.PrecisionCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
glsBuiltinPrecisionTests.PrecisionCase.prototype.constructor = glsBuiltinPrecisionTests.PrecisionCase;
/**
* @return {tcuFloatFormat.FloatFormat}
*/
glsBuiltinPrecisionTests.PrecisionCase.prototype.getFormat = function() {
return this.m_ctx.floatFormat;
};
/**
* Return an output value extracted from flat array
* @param {goog.NumberArray} output
* @param {number} index Index of the element to extract
* @param {*} reference Reference for type informaion
* @return {glsBuiltinPrecisionTests.Value}
*/
glsBuiltinPrecisionTests.getOutput = function(output, index, reference) {
if (reference instanceof Array) {
var ret = [];
var size = reference.length;
for (var i = 0; i < size; i++)
ret[i] = output[size * index + i];
return ret;
}
if (reference instanceof tcuMatrix.Matrix) {
var ret = new tcuMatrix.Matrix(reference.rows, reference.cols);
var size = reference.rows * reference.cols;
for (var i = 0; i < reference.rows; i++)
for (var j = 0; j < reference.cols; j++)
ret.set(i, j, output[size * index + j * reference.rows + i]);
return ret;
}
return output[index];
};
/**
* @param {glsBuiltinPrecisionTests.Variables} variables Variables<In, Out>
* @param {glsBuiltinPrecisionTests.Inputs} inputs Inputs<In>
* @param {glsBuiltinPrecisionTests.Statement} stmt
*/
glsBuiltinPrecisionTests.PrecisionCase.prototype.testStatement = function(variables, inputs, stmt) {
/** @type {tcuFloatFormat.FloatFormat} */ var fmt = this.getFormat();
/** @type {number} */ var inCount = glsBuiltinPrecisionTests.numInputs(this.In);
/** @type {number} */ var outCount = glsBuiltinPrecisionTests.numOutputs(this.Out);
/** @type {number} */ var numValues = (inCount > 0) ? inputs.in0.length : 1;
/** @type {tcuFloatFormat.FloatFormat} */ var highpFmt = this.m_ctx.highpFormat;
var outputs = [];
/** @type {number} */ var maxMsgs = 100;
/** @type {number} */ var numErrors = 0;
/** @type {glsShaderExecUtil.ShaderSpec} */ var spec = new glsShaderExecUtil.ShaderSpec();
/** @type {glsBuiltinPrecisionTests.Environment} */ var env = new glsBuiltinPrecisionTests.Environment(); // Hoisted out of the inner loop for optimization.
switch (inCount) {
case 4: DE_ASSERT(inputs.in3.length == numValues);
case 3: DE_ASSERT(inputs.in2.length == numValues);
case 2: DE_ASSERT(inputs.in1.length == numValues);
case 1: DE_ASSERT(inputs.in0.length == numValues);
default: break;
}
if (enableUnittests)
numValues = 2;
// TODO: Fix logging
//Print out the statement and its definitions
// bufferedLogToConsole("Statement: " + stmt);
// var funcInfo = ''
// var funcs = {};
// stmt.getUsedFuncs(funcs);
// for (var key in funcs) {
// var func = funcs[key];
// funcInfo += func.printDefinition();
// };
// if (funcInfo.length > 0)
// bufferedLogToConsole('Reference definitions:' + funcInfo);
// Initialize ShaderSpec from precision, variables and statement.
spec.globalDeclarations = 'precision ' + gluShaderUtil.getPrecisionName(this.m_ctx.precision) + ' float;\n';
if (this.m_extension.length > 0)
spec.globalDeclarations += '#extension ' + this.m_extension + ' : require\n';
spec.inputs = [];
switch (inCount) {
case 4: spec.inputs[3] = this.makeSymbol(variables.in3);
case 3: spec.inputs[2] = this.makeSymbol(variables.in2);
case 2: spec.inputs[1] = this.makeSymbol(variables.in1);
case 1: spec.inputs[0] = this.makeSymbol(variables.in0);
default: break;
}
spec.outputs = [];
switch (outCount) {
case 2: spec.outputs[1] = this.makeSymbol(variables.out1);
case 1: spec.outputs[0] = this.makeSymbol(variables.out0);
default: break;
}
spec.source = stmt;
if (enableUnittests == false) {
// Run the shader with inputs.
/** @type {glsShaderExecUtil.ShaderExecutor} */
var executor = glsShaderExecUtil.createExecutor(this.m_ctx.shaderType, spec);
/** @type {Array<*>} */ var inputArr =
[
tcuMatrixUtil.flatten(inputs.in0), tcuMatrixUtil.flatten(inputs.in1), tcuMatrixUtil.flatten(inputs.in2), tcuMatrixUtil.flatten(inputs.in3)
];
// executor.log(log());
if (!executor.isOk())
testFailed('Shader compilation failed');
executor.useProgram();
var outputArray = executor.execute(numValues, inputArr);
switch (outCount) {
case 2:
outputs[1] = glsBuiltinPrecisionTests.cast(this.Out.Out1, outputArray[1]);
case 1:
outputs[0] = glsBuiltinPrecisionTests.cast(this.Out.Out0, outputArray[0]);
default: break;
}
}
// Initialize environment with dummy values so we don't need to bind in inner loop.
var in0 = new tcuInterval.Interval();
var in1 = new tcuInterval.Interval();
var in2 = new tcuInterval.Interval();
var in3 = new tcuInterval.Interval();
var reference0 = new tcuInterval.Interval();
var reference1 = new tcuInterval.Interval();
env.bind(variables.in0, in0);
env.bind(variables.in1, in1);
env.bind(variables.in2, in2);
env.bind(variables.in3, in3);
env.bind(variables.out0, reference0);
env.bind(variables.out1, reference1);
// For each input tuple, compute output reference interval and compare
// shader output to the reference.
for (var valueNdx = 0; valueNdx < numValues; valueNdx++) {
/** @type {boolean} */ var result = true;
var value0, value1;
var msg = '';
var in0_ = glsBuiltinPrecisionTests.convert(this.Arg0, fmt, glsBuiltinPrecisionTests.round(this.Arg0, fmt, inputs.in0[valueNdx]));
var in1_ = glsBuiltinPrecisionTests.convert(this.Arg1, fmt, glsBuiltinPrecisionTests.round(this.Arg1, fmt, inputs.in1[valueNdx]));
var in2_ = glsBuiltinPrecisionTests.convert(this.Arg2, fmt, glsBuiltinPrecisionTests.round(this.Arg2, fmt, inputs.in2[valueNdx]));
var in3_ = glsBuiltinPrecisionTests.convert(this.Arg3, fmt, glsBuiltinPrecisionTests.round(this.Arg3, fmt, inputs.in3[valueNdx]));
env.bind(variables.in0, in0_);
env.bind(variables.in1, in1_);
env.bind(variables.in2, in2_);
env.bind(variables.in3, in3_);
stmt.execute(new glsBuiltinPrecisionTests.EvalContext(fmt, this.m_ctx.precision, env));
switch (outCount) {
case 2:
reference1 = glsBuiltinPrecisionTests.convert(this.Out.Out1, highpFmt, env.lookup(variables.out1));
if (enableUnittests)
result = referenceComparison(reference1, valueNdx + outCount - 1, this.m_ctx.floatFormat);
else {
value1 = glsBuiltinPrecisionTests.getOutput(outputs[1], valueNdx, reference1);
if (!glsBuiltinPrecisionTests.contains(this.Out.Out1, reference1, value1)) {
msg = 'Shader output 1 (' + value1 + ') is outside acceptable range: ' + reference1;
result = false;
}
}
case 1:
reference0 = glsBuiltinPrecisionTests.convert(this.Out.Out0, highpFmt, env.lookup(variables.out0));
if (enableUnittests)
result = referenceComparison(reference0, valueNdx + outCount - 1, this.m_ctx.floatFormat);
else {
value0 = glsBuiltinPrecisionTests.getOutput(outputs[0], valueNdx, reference0);
if (!glsBuiltinPrecisionTests.contains(this.Out.Out0, reference0, value0)) {
msg = 'Shader output 0 (' + value0 + ') is outside acceptable range: ' + reference0;
result = false;
}
}
default: break;
}
if (!result)
++numErrors;
if (!result && numErrors <= maxMsgs) {
/** @type {string} */ var builder = '';
builder += (result ? 'Passed' : 'Failed') + '\n' + msg + '\n sample:\n' + valueNdx;
if (inCount > 0) {
builder += '\t' + variables.in0.getName() + ' = ' +
inputs.in0[valueNdx] + '\n';
}
if (inCount > 1) {
builder += '\t' + variables.in1.getName() + ' = ' +
inputs.in1[valueNdx] + '\n';
}
if (inCount > 2) {
builder += '\t' + variables.in2.getName() + ' = ' +
inputs.in2[valueNdx] + '\n';
}
if (inCount > 3) {
builder += '\t' + variables.in3.getName() + ' = ' +
inputs.in3[valueNdx] + '\n';
}
if (enableUnittests == false) {
if (outCount > 0) {
builder += '\t' + variables.out0.getName() + ' = ' +
value0 + '\n' +
'\tExpected range: ' +
reference0 + '\n';
}
if (outCount > 1) {
builder += '\t' + variables.out1.getName() + ' = ' +
value1 + '\n' +
'\tExpected range: ' +
reference1 + '\n';
}
}
bufferedLogToConsole(builder);
}
}
if (numErrors > maxMsgs) {
bufferedLogToConsole('(Skipped ' + (numErrors - maxMsgs) + ' messages.)');
}
if (numErrors == 0) {
testPassed('All ' + numValues + ' inputs passed.');
} else {
testFailed('' + numErrors + '/' + numValues + ' inputs failed.');
}
};
/**
* @param {glsBuiltinPrecisionTests.Variable} variable Variable<typename>
* @return {glsShaderExecUtil.Symbol}
*/
glsBuiltinPrecisionTests.PrecisionCase.prototype.makeSymbol = function(variable) {
var v = variable;
return new glsShaderExecUtil.Symbol(v.getName(), gluVarType.getVarTypeOf(v.typename, this.m_size, this.m_ctx.precision));
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Tuple4}
* @param {*} in0
* @param {*} in1
* @param {*} in2
* @param {*} in3
*/
glsBuiltinPrecisionTests.InTuple = function(in0, in1, in2, in3) {
glsBuiltinPrecisionTests.Tuple4.call(this, in0, in1, in2, in3);
};
glsBuiltinPrecisionTests.InTuple.prototype = Object.create(glsBuiltinPrecisionTests.Tuple4.prototype);
glsBuiltinPrecisionTests.InTuple.prototype.constructor = glsBuiltinPrecisionTests.InTuple;
/**
* @param {*} In
* @param {glsBuiltinPrecisionTests.Samplings} samplings Samplings<In>
* @param {tcuFloatFormat.FloatFormat} floatFormat
* @param {gluShaderUtil.precision} intPrecision
* @param {number} numSamples
* @param {deRandom.Random} rnd
* @return {glsBuiltinPrecisionTests.Inputs}
*/
glsBuiltinPrecisionTests.generateInputs = function(In, samplings, floatFormat, intPrecision, numSamples, rnd) {
/*Inputs<In>*/ var ret = new glsBuiltinPrecisionTests.Inputs(In);
/*Inputs<In>*/ var fixedInputs = new glsBuiltinPrecisionTests.Inputs(In);
// set<InTuple<In>, InputLess<InTuple<In> > > seenInputs;
/** @type {Array<glsBuiltinPrecisionTests.InTuple,glsBuiltinPrecisionTests.InputLess>} */
var seenInputs = [];
samplings.in0.genFixeds(floatFormat, fixedInputs.in0);
samplings.in1.genFixeds(floatFormat, fixedInputs.in1);
samplings.in2.genFixeds(floatFormat, fixedInputs.in2);
samplings.in3.genFixeds(floatFormat, fixedInputs.in3);
for (var ndx0 = 0; ndx0 < fixedInputs.in0.length; ++ndx0) {
for (var ndx1 = 0; ndx1 < fixedInputs.in1.length; ++ndx1) {
for (var ndx2 = 0; ndx2 < fixedInputs.in2.length; ++ndx2) {
for (var ndx3 = 0; ndx3 < fixedInputs.in3.length; ++ndx3) {
var tuple = new glsBuiltinPrecisionTests.InTuple(fixedInputs.in0[ndx0],
fixedInputs.in1[ndx1],
fixedInputs.in2[ndx2],
fixedInputs.in3[ndx3]);
seenInputs.push(tuple);
ret.in0.push(tuple.a);
ret.in1.push(tuple.b);
ret.in2.push(tuple.c);
ret.in3.push(tuple.d);
}
}
}
}
for (var ndx = 0; ndx < numSamples; ++ndx) {
var in0 = samplings.in0.genRandom(floatFormat, intPrecision, rnd);
var in1 = samplings.in1.genRandom(floatFormat, intPrecision, rnd);
var in2 = samplings.in2.genRandom(floatFormat, intPrecision, rnd);
var in3 = samplings.in3.genRandom(floatFormat, intPrecision, rnd);
var tuple = new glsBuiltinPrecisionTests.InTuple(in0, in1, in2, in3);
// if (de::contains(seenInputs, tuple))
// continue;
seenInputs.push(tuple);
ret.in0.push(in0);
ret.in1.push(in1);
ret.in2.push(in2);
ret.in3.push(in3);
}
return ret;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PrecisionCase}
* @param {string} name
* @param {glsBuiltinPrecisionTests.FuncBase} func
*/
glsBuiltinPrecisionTests.FuncCaseBase = function(context, name, func) {
glsBuiltinPrecisionTests.PrecisionCase.call(this, context, name, func.getRequiredExtension());
};
glsBuiltinPrecisionTests.FuncCaseBase.prototype = Object.create(glsBuiltinPrecisionTests.PrecisionCase.prototype);
glsBuiltinPrecisionTests.FuncCaseBase.prototype.constructor = glsBuiltinPrecisionTests.FuncCaseBase;
glsBuiltinPrecisionTests.FuncCaseBase.prototype.iterate = function() {
assertMsgOptions(!(this.m_extension !== undefined && this.m_extension.trim() !== '') &&
!sglrGLContext.isExtensionSupported(gl, this.m_extension),
'Unsupported extension: ' + this.m_extension, false, true);
this.runTest();
// m_status.setTestContextResult(m_testCtx);
return tcuTestCase.IterateResult.STOP;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FuncCaseBase}
* @param {glsBuiltinPrecisionTests.Context} context
* @param {string} name
* @param {glsBuiltinPrecisionTests.Func} func
*/
glsBuiltinPrecisionTests.InOutFuncCase = function(context, name, func) {
glsBuiltinPrecisionTests.FuncCaseBase.call(this, context, name, func);
this.Sig = func.Sig;
this.m_func = func;
this.Ret = func.Sig.Ret;
this.Arg0 = func.Sig.Arg0;
this.Arg1 = func.Sig.Arg1;
this.Arg2 = func.Sig.Arg2;
this.Arg3 = func.Sig.Arg3;
this.In = new glsBuiltinPrecisionTests.InTypes(this.Arg0, this.Arg2, this.Arg3);
this.Out = new glsBuiltinPrecisionTests.OutTypes(this.Ret, this.Arg1);
this.m_size = this.m_func.m_size;
};
glsBuiltinPrecisionTests.InOutFuncCase.prototype = Object.create(glsBuiltinPrecisionTests.FuncCaseBase.prototype);
glsBuiltinPrecisionTests.InOutFuncCase.prototype.constructor = glsBuiltinPrecisionTests.InOutFuncCase;
/**
* Samplings<In>
* @return {glsBuiltinPrecisionTests.Samplings}
*/
glsBuiltinPrecisionTests.InOutFuncCase.prototype.getSamplings = function() {
return new glsBuiltinPrecisionTests.DefaultSamplings(this.In, this.m_size);
};
/**
* @param {glsBuiltinPrecisionTests.Signature} Sig_
*/
glsBuiltinPrecisionTests.InOutFuncCase.prototype.runTest = function(Sig_) {
/** @type {glsBuiltinPrecisionTests.Inputs} */ var inputs = (glsBuiltinPrecisionTests.generateInputs(
this.In,
this.getSamplings(),
this.m_ctx.floatFormat,
this.m_ctx.precision,
this.m_ctx.numRandoms,
this.m_rnd));
var variables = new glsBuiltinPrecisionTests.Variables(this.In, this.Out);
// Variables<In, Out> variables;
//
variables.out0 = new glsBuiltinPrecisionTests.Variable(this.Out.Out0, 'out0');
variables.out1 = new glsBuiltinPrecisionTests.Variable(this.Arg1, 'out1');
variables.in0 = new glsBuiltinPrecisionTests.Variable(this.Arg0, 'in0');
variables.in1 = new glsBuiltinPrecisionTests.Variable(this.Arg2, 'in1');
variables.in2 = new glsBuiltinPrecisionTests.Variable(this.Arg3, 'in2');
variables.in3 = new glsBuiltinPrecisionTests.Variable('void', 'in3');
var expr = glsBuiltinPrecisionTests.applyVar(this.m_func,
variables.in0, variables.out1,
variables.in1, variables.in2);
var stmt = glsBuiltinPrecisionTests.variableAssignment(variables.out0, expr);
this.testStatement(variables, inputs, stmt);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FuncCaseBase}
* @param {glsBuiltinPrecisionTests.Context} context
* @param {string} name
* @param {glsBuiltinPrecisionTests.Func} func
*/
glsBuiltinPrecisionTests.FuncCase = function(context, name, func) {
glsBuiltinPrecisionTests.FuncCaseBase.call(this, context, name, func);
this.Sig = func.Sig;
this.m_func = func;
this.Ret = func.Sig.Ret;
this.Arg0 = func.Sig.Arg0;
this.Arg1 = func.Sig.Arg1;
this.Arg2 = func.Sig.Arg2;
this.Arg3 = func.Sig.Arg3;
this.In = new glsBuiltinPrecisionTests.InTypes(this.Arg0, this.Arg1, this.Arg2, this.Arg3);
this.Out = new glsBuiltinPrecisionTests.OutTypes(this.Ret);
this.m_size = this.m_func.m_size;
};
glsBuiltinPrecisionTests.FuncCase.prototype = Object.create(glsBuiltinPrecisionTests.FuncCaseBase.prototype);
glsBuiltinPrecisionTests.FuncCase.prototype.constructor = glsBuiltinPrecisionTests.FuncCase;
/**
* Samplings<In>
* @return {glsBuiltinPrecisionTests.Samplings}
*/
glsBuiltinPrecisionTests.FuncCase.prototype.getSamplings = function() {
return new glsBuiltinPrecisionTests.DefaultSamplings(this.In, this.m_size);
};
/**
* @param {glsBuiltinPrecisionTests.Signature} Sig_
*/
glsBuiltinPrecisionTests.FuncCase.prototype.runTest = function(Sig_) {
/** @type {glsBuiltinPrecisionTests.Inputs} */ var inputs = (glsBuiltinPrecisionTests.generateInputs(
this.In,
this.getSamplings(),
this.m_ctx.floatFormat,
this.m_ctx.precision,
this.m_ctx.numRandoms,
this.m_rnd));
var variables = new glsBuiltinPrecisionTests.Variables(this.In, this.Out);
// Variables<In, Out> variables;
//
variables.out0 = new glsBuiltinPrecisionTests.Variable(this.Ret, 'out0');
variables.out1 = new glsBuiltinPrecisionTests.Variable('void', 'out1');
variables.in0 = new glsBuiltinPrecisionTests.Variable(this.Arg0, 'in0');
variables.in1 = new glsBuiltinPrecisionTests.Variable(this.Arg1, 'in1');
variables.in2 = new glsBuiltinPrecisionTests.Variable(this.Arg2, 'in2');
variables.in3 = new glsBuiltinPrecisionTests.Variable(this.Arg3, 'in3');
var expr = glsBuiltinPrecisionTests.applyVar(this.m_func,
variables.in0, variables.in1,
variables.in2, variables.in3);
var stmt = glsBuiltinPrecisionTests.variableAssignment(variables.out0, expr);
this.testStatement(variables, inputs, stmt);
};
/**
* @param {glsBuiltinPrecisionTests.Func} func
* @param {glsBuiltinPrecisionTests.Variable} arg0
* @param {glsBuiltinPrecisionTests.Variable} arg1
* @param {glsBuiltinPrecisionTests.Variable} arg2
* @param {glsBuiltinPrecisionTests.Variable} arg3
* @return {glsBuiltinPrecisionTests.ApplyVar}
*/
glsBuiltinPrecisionTests.applyVar = function(func, arg0, arg1, arg2, arg3) {
return new glsBuiltinPrecisionTests.ApplyVar(func.Sig, func, arg0, arg1, arg2, arg3);
};
/**
* @param {glsBuiltinPrecisionTests.Variable} variable
* @param {glsBuiltinPrecisionTests.ApplyVar} value
* @param {boolean} isDeclaration
*/
glsBuiltinPrecisionTests.variableStatement = function(variable, value, isDeclaration) {
return new glsBuiltinPrecisionTests.VariableStatement(variable, value, isDeclaration);
};
/**
* @param {glsBuiltinPrecisionTests.Variable} variable
* @param {glsBuiltinPrecisionTests.ApplyVar} value
*/
glsBuiltinPrecisionTests.variableAssignment = function(variable, value) {
return glsBuiltinPrecisionTests.variableStatement(variable, value, false);
};
/**
* @constructor
*/
glsBuiltinPrecisionTests.CaseFactories = function() {};
/**
* @return {Array<glsBuiltinPrecisionTests.CaseFactory>}
*/
glsBuiltinPrecisionTests.CaseFactories.prototype.getFactories = function() {};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CaseFactories}
*/
glsBuiltinPrecisionTests.BuiltinFuncs = function() {
/** @type {Array<glsBuiltinPrecisionTests.CaseFactory>} */ this.m_factories = [];
};
glsBuiltinPrecisionTests.BuiltinFuncs.prototype = Object.create(glsBuiltinPrecisionTests.CaseFactories.prototype);
glsBuiltinPrecisionTests.BuiltinFuncs.prototype.constructor = glsBuiltinPrecisionTests.BuiltinFuncs;
/**
* @return {Array<glsBuiltinPrecisionTests.CaseFactory>}
*/
glsBuiltinPrecisionTests.BuiltinFuncs.prototype.getFactories = function() {
return this.m_factories.slice();
};
/**
* @param {glsBuiltinPrecisionTests.CaseFactory} fact
*/
glsBuiltinPrecisionTests.BuiltinFuncs.prototype.addFactory = function(fact) {
this.m_factories.push(fact);
};
/**
* @param {glsBuiltinPrecisionTests.Context} context
* @param {string} name
* @param {glsBuiltinPrecisionTests.Func} func
* @return {glsBuiltinPrecisionTests.PrecisionCase}
*/
glsBuiltinPrecisionTests.createFuncCase = function(context, name, func) {
switch (func.getOutParamIndex()) {
case -1:
return new glsBuiltinPrecisionTests.FuncCase(context, name, func);
case 1:
return new glsBuiltinPrecisionTests.InOutFuncCase(context, name, func);
default:
throw new Error(!'Impossible');
}
};
/**
* @constructor
*/
glsBuiltinPrecisionTests.CaseFactory = function() {};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.CaseFactory.prototype.getName = function() {
return '';
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.CaseFactory.prototype.getDesc = function() {
return '';
};
/**
* @param {glsBuiltinPrecisionTests.Context} ctx
*/
glsBuiltinPrecisionTests.CaseFactory.prototype.createCase = function(ctx) {
throw new Error('Virtual function. Please override.');
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CaseFactory}
* @param {glsBuiltinPrecisionTests.Func} func
*/
glsBuiltinPrecisionTests.SimpleFuncCaseFactory = function(func) {
glsBuiltinPrecisionTests.CaseFactory.call(this);
this.m_func = func;
};
setParentClass(glsBuiltinPrecisionTests.SimpleFuncCaseFactory, glsBuiltinPrecisionTests.CaseFactory);
glsBuiltinPrecisionTests.SimpleFuncCaseFactory.prototype.getName = function() {
return this.m_func.getName().toLowerCase();
};
glsBuiltinPrecisionTests.SimpleFuncCaseFactory.prototype.getDesc = function() {
return "Function '" + this.getName() + "'";
};
glsBuiltinPrecisionTests.SimpleFuncCaseFactory.prototype.createCase = function(ctx) {
return glsBuiltinPrecisionTests.createFuncCase(ctx, ctx.name, this.m_func);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CaseFactory}
*/
glsBuiltinPrecisionTests.FuncCaseFactory = function() {
glsBuiltinPrecisionTests.CaseFactory.call(this);
};
setParentClass(glsBuiltinPrecisionTests.FuncCaseFactory, glsBuiltinPrecisionTests.CaseFactory);
glsBuiltinPrecisionTests.FuncCaseFactory.prototype.getFunc = function() {
throw new Error('Virtual function. Please override.');
};
glsBuiltinPrecisionTests.FuncCaseFactory.prototype.getName = function() {
return this.getFunc().getName().toLowerCase();
};
glsBuiltinPrecisionTests.FuncCaseFactory.prototype.getDesc = function() {
return "Function '" + this.getFunc().getName() + "'";
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FuncCaseFactory}
*/
glsBuiltinPrecisionTests.TemplateFuncCaseFactory = function(genF) {
glsBuiltinPrecisionTests.FuncCaseFactory.call(this);
this.m_genF = genF;
};
setParentClass(glsBuiltinPrecisionTests.TemplateFuncCaseFactory, glsBuiltinPrecisionTests.FuncCaseFactory);
glsBuiltinPrecisionTests.TemplateFuncCaseFactory.prototype.getFunc = function() {
return new this.m_genF(1);
};
/**
* @param {glsBuiltinPrecisionTests.Context} ctx
*/
glsBuiltinPrecisionTests.TemplateFuncCaseFactory.prototype.createCase = function(ctx) {
var group = tcuTestCase.newTest(ctx.name, ctx.name);
group.addChild(glsBuiltinPrecisionTests.createFuncCase(ctx, 'scalar', new this.m_genF(1)));
group.addChild(glsBuiltinPrecisionTests.createFuncCase(ctx, 'vec2', new this.m_genF(2)));
group.addChild(glsBuiltinPrecisionTests.createFuncCase(ctx, 'vec3', new this.m_genF(3)));
group.addChild(glsBuiltinPrecisionTests.createFuncCase(ctx, 'vec4', new this.m_genF(4)));
return group;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FuncCaseFactory}
*/
glsBuiltinPrecisionTests.MatrixFuncCaseFactory = function(genF) {
glsBuiltinPrecisionTests.FuncCaseFactory.call(this);
this.m_genF = genF;
};
setParentClass(glsBuiltinPrecisionTests.MatrixFuncCaseFactory, glsBuiltinPrecisionTests.FuncCaseFactory);
glsBuiltinPrecisionTests.MatrixFuncCaseFactory.prototype.getFunc = function() {
return new this.m_genF(2, 2);
};
/**
* @param {glsBuiltinPrecisionTests.Context} ctx
*/
glsBuiltinPrecisionTests.MatrixFuncCaseFactory.prototype.createCase = function(ctx) {
var group = tcuTestCase.newTest(ctx.name, ctx.name);
this.addCase(ctx, group, 2, 2);
this.addCase(ctx, group, 3, 2);
this.addCase(ctx, group, 4, 2);
this.addCase(ctx, group, 2, 3);
this.addCase(ctx, group, 3, 3);
this.addCase(ctx, group, 4, 3);
this.addCase(ctx, group, 2, 4);
this.addCase(ctx, group, 3, 4);
this.addCase(ctx, group, 4, 4);
return group;
};
/**
* @param {glsBuiltinPrecisionTests.Context} ctx
* @param {tcuTestCase.DeqpTest} group
* @param {number} rows
* @param {number} cols
*/
glsBuiltinPrecisionTests.MatrixFuncCaseFactory.prototype.addCase = function(ctx, group, rows, cols) {
var name = glsBuiltinPrecisionTests.dataTypeNameOfMatrix('float', rows, cols);
group.addChild(glsBuiltinPrecisionTests.createFuncCase(ctx, name, new this.m_genF(rows, cols)));
};
glsBuiltinPrecisionTests.dataTypeNameOfMatrix = function(typename, rows, cols) {
switch (typename) {
case 'float':
if (rows === cols)
return 'mat' + rows;
else
return 'mat' + cols + 'x' + rows;
}
throw new Error('Invalid arguments (' + typename + ', ' + rows + ', ' + cols + ')');
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.FuncCaseFactory}
*/
glsBuiltinPrecisionTests.SquareMatrixFuncCaseFactory = function(genF) {
glsBuiltinPrecisionTests.FuncCaseFactory.call(this);
this.m_genF = genF;
};
setParentClass(glsBuiltinPrecisionTests.SquareMatrixFuncCaseFactory, glsBuiltinPrecisionTests.FuncCaseFactory);
glsBuiltinPrecisionTests.SquareMatrixFuncCaseFactory.prototype.getFunc = function() {
return new this.m_genF(2);
};
/**
* @param {glsBuiltinPrecisionTests.Context} ctx
*/
glsBuiltinPrecisionTests.SquareMatrixFuncCaseFactory.prototype.createCase = function(ctx) {
var group = tcuTestCase.newTest(ctx.name, ctx.name);
group.addChild(glsBuiltinPrecisionTests.createFuncCase(ctx, 'mat2', new this.m_genF(2)));
return group;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
* @param {glsBuiltinPrecisionTests.Func} scalarFunc
* @param {number=} size
*/
glsBuiltinPrecisionTests.GenFunc = function(scalarFunc, size) {
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, scalarFunc.Sig);
this.m_func = scalarFunc;
this.m_size = size;
};
glsBuiltinPrecisionTests.GenFunc.prototype = Object.create(glsBuiltinPrecisionTests.PrimitiveFunc.prototype);
glsBuiltinPrecisionTests.GenFunc.prototype.constructor = glsBuiltinPrecisionTests.GenFunc;
/**
* @return {string}
*/
glsBuiltinPrecisionTests.GenFunc.prototype.getName = function() {
return this.m_func.getName();
};
/**
* @return {number}
*/
glsBuiltinPrecisionTests.GenFunc.prototype.getOutParamIndex = function() {
return this.m_func.getOutParamIndex();
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.GenFunc.prototype.getRequiredExtension = function() {
return this.m_func.getRequiredExtension();
};
/**
* @param {Array<glsBuiltinPrecisionTests.ExprBase>} args
*/
glsBuiltinPrecisionTests.GenFunc.prototype.doPrint = function(args) {
return this.m_func.print(args);
};
/**
* @param {glsBuiltinPrecisionTests.EvalContext} ctx
* @param {glsBuiltinPrecisionTests.Tuple4} iargs
* @return {*}
*/
glsBuiltinPrecisionTests.GenFunc.prototype.doApply = function(ctx, iargs) {
/** @type {Array<*>} */ var ret = [];
if (this.m_size > 1) {
for (var ndx = 0; ndx < this.m_size; ++ndx) {
var a = iargs.a === undefined ? undefined : iargs.a[ndx];
var b = iargs.b === undefined ? undefined : iargs.b[ndx];
var c = iargs.c === undefined ? undefined : iargs.c[ndx];
var d = iargs.d === undefined ? undefined : iargs.d[ndx];
ret[ndx] = this.m_func.applyFunction(ctx, a, b, c, d);
}
} else
ret[0] = this.m_func.applyFunction(ctx, iargs.a, iargs.b, iargs.c, iargs.d);
return ret;
};
/**
* @param {glsBuiltinPrecisionTests.FuncSet} dst
*/
glsBuiltinPrecisionTests.GenFunc.prototype.doGetUsedFuncs = function(dst) {
this.m_func.getUsedFuncs(dst);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.GenFunc}
* @param {glsBuiltinPrecisionTests.Func} func
* @param {number} size
*/
glsBuiltinPrecisionTests.VectorizedFunc = function(func, size) {
glsBuiltinPrecisionTests.GenFunc.call(this, func, size);
};
glsBuiltinPrecisionTests.VectorizedFunc.prototype = Object.create(glsBuiltinPrecisionTests.GenFunc.prototype);
glsBuiltinPrecisionTests.VectorizedFunc.prototype.constructor = glsBuiltinPrecisionTests.VectorizedFunc;
/**
* @constructor
* @param {glsBuiltinPrecisionTests.Func} func_
* @param {glsBuiltinPrecisionTests.GenFunc} func2_
* @param {glsBuiltinPrecisionTests.GenFunc} func3_
* @param {glsBuiltinPrecisionTests.GenFunc} func4_
*/
glsBuiltinPrecisionTests.GenFuncs = function(func_, func2_, func3_, func4_) {
this.func = func_;
this.func2 = func2_;
this.func3 = func3_;
this.func4 = func4_;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CaseFactory}
* @param {glsBuiltinPrecisionTests.GenFuncs} funcs
* @param {string} name
*/
glsBuiltinPrecisionTests.GenFuncCaseFactory = function(funcs, name) {
glsBuiltinPrecisionTests.CaseFactory.call(this);
this.m_funcs = funcs;
this.m_name = name;
};
glsBuiltinPrecisionTests.GenFuncCaseFactory.prototype = Object.create(glsBuiltinPrecisionTests.CaseFactory.prototype);
glsBuiltinPrecisionTests.GenFuncCaseFactory.prototype.constructor = glsBuiltinPrecisionTests.GenFuncCaseFactory;
/**
* @param {glsBuiltinPrecisionTests.Context} ctx
* @return {tcuTestCase.DeqpTest}
*/
glsBuiltinPrecisionTests.GenFuncCaseFactory.prototype.createCase = function(ctx) {
/** @type {tcuTestCase.DeqpTest} */
var group = tcuTestCase.newTest(ctx.name, ctx.name);
group.addChild(glsBuiltinPrecisionTests.createFuncCase(ctx, 'scalar', this.m_funcs.func));
group.addChild(glsBuiltinPrecisionTests.createFuncCase(ctx, 'vec2', this.m_funcs.func2));
group.addChild(glsBuiltinPrecisionTests.createFuncCase(ctx, 'vec3', this.m_funcs.func3));
group.addChild(glsBuiltinPrecisionTests.createFuncCase(ctx, 'vec4', this.m_funcs.func4));
return group;
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.GenFuncCaseFactory.prototype.getName = function() {
return this.m_name;
};
/**
* @return {string}
*/
glsBuiltinPrecisionTests.GenFuncCaseFactory.prototype.getDesc = function() {
return "Function '" + this.m_funcs.func.getName() + "'";
};
/**
* @constructor
* @param {string} name_
* @param {tcuFloatFormat.FloatFormat} floatFormat_
* @param {tcuFloatFormat.FloatFormat} highpFormat_
* @param {gluShaderUtil.precision} precision_
* @param {gluShaderProgram.shaderType} shaderType_
* @param {number} numRandoms_
*/
glsBuiltinPrecisionTests.Context = function(name_, floatFormat_, highpFormat_, precision_, shaderType_, numRandoms_) {
/** @type {string} */ this.name = name_;
/** @type {tcuFloatFormat.FloatFormat} */ this.floatFormat = floatFormat_;
/** @type {tcuFloatFormat.FloatFormat} */ this.highpFormat = highpFormat_;
/** @type {gluShaderUtil.precision} */ this.precision = precision_;
/** @type {gluShaderProgram.shaderType} */ this.shaderType = shaderType_;
/** @type {number} */ this.numRandoms = numRandoms_;
};
/**
* @constructor
* @param {tcuFloatFormat.FloatFormat} highp_
* @param {tcuFloatFormat.FloatFormat} mediump_
* @param {tcuFloatFormat.FloatFormat} lowp_
* @param {Array<gluShaderProgram.shaderType>} shaderTypes_
* @param {number} numRandoms_
*/
glsBuiltinPrecisionTests.PrecisionTestContext = function(highp_, mediump_, lowp_, shaderTypes_, numRandoms_) {
/** @type {Array<gluShaderProgram.shaderType>} */ this.shaderTypes = shaderTypes_;
/** @type {Array<tcuFloatFormat.FloatFormat>} */ this.formats = [];
this.formats[gluShaderUtil.precision.PRECISION_HIGHP] = highp_;
this.formats[gluShaderUtil.precision.PRECISION_MEDIUMP] = mediump_;
this.formats[gluShaderUtil.precision.PRECISION_LOWP] = lowp_;
/** @type {number} */ this.numRandoms = numRandoms_;
};
/**
* \brief Simple incremental counter.
*
* This is used to make sure that different ExpandContexts will not produce
* overlapping temporary names.
* @constructor
*
*/
glsBuiltinPrecisionTests.Counter = function() {
this.m_count = 0;
};
glsBuiltinPrecisionTests.Counter.prototype.get = function() {
return this.m_count++;
};
/**
* @constructor
*/
glsBuiltinPrecisionTests.ExpandContext = function(counter) {
this.m_counter = counter;
this.m_statements = [];
};
/**
* @param {string} typename
* @param {string} baseName
* @return {glsBuiltinPrecisionTests.Variable}
*/
glsBuiltinPrecisionTests.ExpandContext.prototype.genSym = function(typename, baseName) {
return new glsBuiltinPrecisionTests.Variable(typename, baseName + this.m_counter.get());
};
glsBuiltinPrecisionTests.ExpandContext.prototype.addStatement = function(/*const StatementP&*/ stmt) {
this.m_statements.push(stmt);
};
glsBuiltinPrecisionTests.ExpandContext.prototype.getStatements = function() {
return this.m_statements;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Func}
* @param {glsBuiltinPrecisionTests.Signature} Sig_ template <typename Sig_>
*/
glsBuiltinPrecisionTests.DerivedFunc = function(Sig_) {
glsBuiltinPrecisionTests.Func.call(this, Sig_);
};
setParentClass(glsBuiltinPrecisionTests.DerivedFunc, glsBuiltinPrecisionTests.Func);
glsBuiltinPrecisionTests.DerivedFunc.prototype.doPrintDefinition = function() {
var os = '';
var paramNames = this.getParamNames();
this.initialize();
os += this.Ret + ' ' + this.getName() +
'(';
if (glsBuiltinPrecisionTests.isTypeValid(this.Arg0))
os += this.Arg0 + ' ' + paramNames.a;
if (glsBuiltinPrecisionTests.isTypeValid(this.Arg1))
os += ', ' + this.Arg1 + ' ' + paramNames.b;
if (glsBuiltinPrecisionTests.isTypeValid(this.Arg2))
os += ', ' + this.Arg2 + ' ' + paramNames.c;
if (glsBuiltinPrecisionTests.isTypeValid(this.Arg3))
os += ', ' + this.Arg3 + ' ' + paramNames.d;
os += ')\n{\n';
for (var ndx = 0; ndx < this.m_body.length; ++ndx)
os += this.m_body[ndx];
os += 'return ' + this.m_ret + ';\n';
os += '}\n';
return os;
};
glsBuiltinPrecisionTests.DerivedFunc.prototype.doApply = function(ctx, args) {
var funEnv = new glsBuiltinPrecisionTests.Environment();
this.initialize();
funEnv.bind(this.m_var0, args.a);
funEnv.bind(this.m_var1, args.b);
funEnv.bind(this.m_var2, args.c);
funEnv.bind(this.m_var3, args.d);
var funCtx = new glsBuiltinPrecisionTests.EvalContext(ctx.format, ctx.floatPrecision, funEnv, ctx.callDepth);
for (var ndx = 0; ndx < this.m_body.length; ++ndx)
this.m_body[ndx].execute(funCtx);
var ret = this.m_ret.evaluate(funCtx);
// \todo [lauri] Store references instead of values in environment
args.a = funEnv.lookup(this.m_var0);
args.b = funEnv.lookup(this.m_var1);
args.c = funEnv.lookup(this.m_var2);
args.d = funEnv.lookup(this.m_var3);
return ret;
};
glsBuiltinPrecisionTests.DerivedFunc.prototype.initialize = function() {
if (!this.m_ret) {
var paramNames = this.getParamNames();
var symCounter = new glsBuiltinPrecisionTests.Counter();
var ctx = new glsBuiltinPrecisionTests.ExpandContext(symCounter);
this.m_var0 = new glsBuiltinPrecisionTests.Variable(this.Arg0, paramNames.a);
this.m_var1 = new glsBuiltinPrecisionTests.Variable(this.Arg1, paramNames.b);
this.m_var2 = new glsBuiltinPrecisionTests.Variable(this.Arg2, paramNames.c);
this.m_var3 = new glsBuiltinPrecisionTests.Variable(this.Arg3, paramNames.d);
var args = new glsBuiltinPrecisionTests.Tuple4(this.m_var0,
this.m_var1, this.m_var2, this.m_var3);
this.m_ret = this.doExpand(ctx, args);
this.m_body = ctx.getStatements();
}
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.Func}
* @param {glsBuiltinPrecisionTests.Signature} Sig_ template <typename Sig_>
*/
glsBuiltinPrecisionTests.Alternatives = function(Sig_) {
glsBuiltinPrecisionTests.Func.call(this, Sig_);
};
setParentClass(glsBuiltinPrecisionTests.Alternatives,glsBuiltinPrecisionTests.Func);
glsBuiltinPrecisionTests.Alternatives.prototype.getName = function() {
return 'alternatives';
};
glsBuiltinPrecisionTests.Alternatives.prototype.doPrintDefinition = function() {};
glsBuiltinPrecisionTests.Alternatives.prototype.doGetUsedFuncs = function(dst) {};
glsBuiltinPrecisionTests.Alternatives.prototype.doApply = function(ctx,args) {
return glsBuiltinPrecisionTests.union(this.Sig.Ret,args.a,args.b);
};
glsBuiltinPrecisionTests.Alternatives.prototype.doPrint = function(args) {
return '{' + args[0] + '|' + args[1] + '}';
};
glsBuiltinPrecisionTests.sizeToName = function(size) {
switch (size) {
case 4: return 'vec4';
case 3: return 'vec3';
case 2: return 'vec2';
}
return 'float';
};
/**
* @constructor
* @param {number} size
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Dot = function(size) {
var name = glsBuiltinPrecisionTests.sizeToName(size);
var sig = new glsBuiltinPrecisionTests.Signature('float', name, name);
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
this.m_inputSize = size;
};
setParentClass(glsBuiltinPrecisionTests.Dot, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Dot.prototype.getName = function() {
return 'dot';
};
glsBuiltinPrecisionTests.Dot.prototype.doExpand = function(ctx, args) {
if (this.m_inputSize > 1) {
var val = app(new glsBuiltinPrecisionTests.Mul(),
new glsBuiltinPrecisionTests.VectorVariable(args.a, 0), new glsBuiltinPrecisionTests.VectorVariable(args.b, 0));
for (var i = 1; i < this.m_inputSize; i++) {
var tmp = new glsBuiltinPrecisionTests.Apply('float', new glsBuiltinPrecisionTests.Mul(),
new glsBuiltinPrecisionTests.VectorVariable(args.a, i), new glsBuiltinPrecisionTests.VectorVariable(args.b, i));
val = app(new glsBuiltinPrecisionTests.Add(), val, tmp);
}
return val;
} else {
// args.a * args.b
var ret = app(new glsBuiltinPrecisionTests.Mul(), args.a, args.b);
return ret;
}
};
/**
* @constructor
* @param {number} size
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Length = function(size) {
var name = glsBuiltinPrecisionTests.sizeToName(size);
var sig = new glsBuiltinPrecisionTests.Signature('float', name);
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
this.m_inputSize = size;
};
setParentClass(glsBuiltinPrecisionTests.Length, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Length.prototype.getName = function() {
return 'length';
};
glsBuiltinPrecisionTests.Length.prototype.doExpand = function(ctx, args) {
//sqrt(dot(args.a, args.a));
var v0 = app(new glsBuiltinPrecisionTests.Dot(this.m_inputSize), args.a, args.a);
var v1 = app(new glsBuiltinPrecisionTests.Sqrt(), v0);
return v1;
};
/**
* @constructor
* @param {number} size
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Distance = function(size) {
var name = glsBuiltinPrecisionTests.sizeToName(size);
var sig = new glsBuiltinPrecisionTests.Signature('float', name, name);
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
this.m_inputSize = size;
};
setParentClass(glsBuiltinPrecisionTests.Distance, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Distance.prototype.getName = function() {
return 'distance';
};
glsBuiltinPrecisionTests.Distance.prototype.doExpand = function(ctx, args) {
//length(args.a - args.b);
var v0 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Sub(), args.a, args.b);
var v1 = app(new glsBuiltinPrecisionTests.Length(this.m_inputSize), v0);
return v1;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Cross = function() {
var sig = new glsBuiltinPrecisionTests.Signature('vec3', 'vec3', 'vec3');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
this.m_inputSize = 3;
};
setParentClass(glsBuiltinPrecisionTests.Cross, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Cross.prototype.getName = function() {
return 'cross';
};
glsBuiltinPrecisionTests.Cross.prototype.doExpand = function(ctx, args) {
// vec3(x.a[1] * x.b[2] - x.b[1] * x.a[2],
// x.a[2] * x.b[0] - x.b[2] * x.a[0],
// x.a[0] * x.b[1] - x.b[0] * x.a[1]);
var a = [], b = [];
for (var i = 0; i < this.m_inputSize; i++) {
a[i] = new glsBuiltinPrecisionTests.VectorVariable(args.a, i);
b[i] = new glsBuiltinPrecisionTests.VectorVariable(args.b, i);
}
var v0 = app(new glsBuiltinPrecisionTests.Mul(), a[1], b[2]);
var v1 = app(new glsBuiltinPrecisionTests.Mul(), b[1], a[2]);
var v2 = app(new glsBuiltinPrecisionTests.Sub(), v0, v1);
var v3 = app(new glsBuiltinPrecisionTests.Mul(), a[2], b[0]);
var v4 = app(new glsBuiltinPrecisionTests.Mul(), b[2], a[0]);
var v5 = app(new glsBuiltinPrecisionTests.Sub(), v3, v4);
var v6 = app(new glsBuiltinPrecisionTests.Mul(), a[0], b[1]);
var v7 = app(new glsBuiltinPrecisionTests.Mul(), b[0], a[1]);
var v8 = app(new glsBuiltinPrecisionTests.Sub(), v6, v7);
var v9 = app(new glsBuiltinPrecisionTests.GenVec(this.m_inputSize, true), v2, v5, v8);
return v9;
};
/**
* @constructor
* @param {number} size
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Normalize = function(size) {
var name = glsBuiltinPrecisionTests.sizeToName(size);
var sig = new glsBuiltinPrecisionTests.Signature(name, name);
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
this.m_inputSize = size;
};
setParentClass(glsBuiltinPrecisionTests.Normalize, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Normalize.prototype.getName = function() {
return 'normalize';
};
glsBuiltinPrecisionTests.Normalize.prototype.doExpand = function(ctx, args) {
//args.a / length<Size>(args.a);
var v0 = app(new glsBuiltinPrecisionTests.Length(this.m_inputSize), args.a);
var v1 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Div(), args.a, v0);
return v1;
};
/**
* @constructor
* @param {number} size
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.FaceForward = function(size) {
var name = glsBuiltinPrecisionTests.sizeToName(size);
var sig = new glsBuiltinPrecisionTests.Signature(name, name, name, name);
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
this.m_inputSize = size;
this.typename = name;
};
setParentClass(glsBuiltinPrecisionTests.FaceForward, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.FaceForward.prototype.getName = function() {
return 'faceforward';
};
glsBuiltinPrecisionTests.FaceForward.prototype.doExpand = function(ctx, args) {
//cond(dot(args.c, args.b) < constant(0.0f), args.a, -args.a);
var zero = new glsBuiltinPrecisionTests.Constant(0);
var v0 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Negate(), args.a);
var v1 = app(new glsBuiltinPrecisionTests.Dot(this.m_inputSize), args.c, args.b);
var v2 = app(new glsBuiltinPrecisionTests.LessThan('float'), v1, zero);
var v3 = app(new glsBuiltinPrecisionTests.Cond(this.typename), v2, args.a, v0);
return v3;
};
/**
* @constructor
* @param {number} size
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Reflect = function(size) {
var name = glsBuiltinPrecisionTests.sizeToName(size);
var sig = new glsBuiltinPrecisionTests.Signature(name, name, name);
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
this.m_inputSize = size;
};
setParentClass(glsBuiltinPrecisionTests.Reflect, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Reflect.prototype.getName = function() {
return 'reflect';
};
glsBuiltinPrecisionTests.Reflect.prototype.doExpand = function(ctx, args) {
//args.a - (args.b * dot(args.b, args.a) * constant(2.0f));
var two = new glsBuiltinPrecisionTests.Constant(2);
var v0 = app(new glsBuiltinPrecisionTests.Dot(this.m_inputSize), args.b, args.a);
var v1 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Mul(), args.b, v0);
var v2 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Mul(), v1, two);
var v3 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Sub(), args.a, v2);
return v3;
};
/**
* @constructor
* @param {number} size
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Refract = function(size) {
var name = glsBuiltinPrecisionTests.sizeToName(size);
var sig = new glsBuiltinPrecisionTests.Signature(name, name, name, 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
this.m_inputSize = size;
this.typename = name;
};
setParentClass(glsBuiltinPrecisionTests.Refract, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Refract.prototype.getName = function() {
return 'refract';
};
glsBuiltinPrecisionTests.Refract.prototype.doExpand = function(ctx, args) {
var i = args.a;
var n = args.b;
var eta = args.c;
var zero = new glsBuiltinPrecisionTests.Constant(0);
var one = new glsBuiltinPrecisionTests.Constant(1);
// dotNI = dot(n, i)
var v0 = app(new glsBuiltinPrecisionTests.Dot(this.m_inputSize), n, i);
var dotNI = glsBuiltinPrecisionTests.bindExpression('float', 'dotNI', ctx, v0);
// k = 1 - eta * eta * (1 - dotNI * dotNI)
var v1 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Mul(), dotNI, dotNI);
var v2 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Sub(), one, v1);
var v3 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Mul(), eta, eta);
var v4 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Mul(), v3, v2);
var v5 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Sub(), one, v4);
var k = glsBuiltinPrecisionTests.bindExpression('float', 'k', ctx, v5);
// i * eta - n * (eta * dotNI + sqrt(k))
var v6 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Mul(), eta, dotNI);
var v7 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Sqrt(), k);
var v8 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Add(), v6, v7);
var v9 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Mul(), n, v8);
var v10 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Mul(), i, eta);
var v11 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.Sub(), v10, v9);
var v12 = new glsBuiltinPrecisionTests.ApplyScalar(new glsBuiltinPrecisionTests.LessThan('float'), k, zero);
var zeroVector = app(new glsBuiltinPrecisionTests.GenVec(this.m_inputSize), zero);
var v13 = app(new glsBuiltinPrecisionTests.Cond(this.typename), v12, zeroVector, v11);
return v13;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Radians = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Radians, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Radians.prototype.getName = function() {
return 'radians';
};
glsBuiltinPrecisionTests.Radians.prototype.doExpand = function(ctx, args) {
var val = app(new glsBuiltinPrecisionTests.Div(),
new glsBuiltinPrecisionTests.Constant(Math.PI),
new glsBuiltinPrecisionTests.Constant(180));
return new glsBuiltinPrecisionTests.Apply('float',
new glsBuiltinPrecisionTests.Mul(),
val,
args.a);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Degrees = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Degrees, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Degrees.prototype.getName = function() {
return 'degrees';
};
glsBuiltinPrecisionTests.Degrees.prototype.doExpand = function(ctx, args) {
var val = app(new glsBuiltinPrecisionTests.Div(),
new glsBuiltinPrecisionTests.Constant(180),
new glsBuiltinPrecisionTests.Constant(Math.PI));
return new glsBuiltinPrecisionTests.Apply('float',
new glsBuiltinPrecisionTests.Mul(),
val,
args.a);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Sinh = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Sinh, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Sinh.prototype.getName = function() {
return 'sinh';
};
glsBuiltinPrecisionTests.Sinh.prototype.doExpand = function(ctx, args) {
// (exp(x) - exp(-x)) / constant(2.0f)
var x = args.a;
var v0 = app(new glsBuiltinPrecisionTests.Exp(), x);
var v1 = app(new glsBuiltinPrecisionTests.Negate(), x);
var v2 = app(new glsBuiltinPrecisionTests.Exp(), v1);
var v3 = app(new glsBuiltinPrecisionTests.Sub(), v0, v2);
var v4 = new glsBuiltinPrecisionTests.Constant(2);
var v5 = new glsBuiltinPrecisionTests.Apply('float', new glsBuiltinPrecisionTests.Div, v3, v4);
return v5;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Cosh = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Cosh, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Cosh.prototype.getName = function() {
return 'cosh';
};
glsBuiltinPrecisionTests.Cosh.prototype.doExpand = function(ctx, args) {
// (exp(x) + exp(-x)) / constant(2.0f)
var x = args.a;
var v0 = app(new glsBuiltinPrecisionTests.Exp(), x);
var v1 = app(new glsBuiltinPrecisionTests.Negate(), x);
var v2 = app(new glsBuiltinPrecisionTests.Exp(), v1);
var v3 = app(new glsBuiltinPrecisionTests.Add(), v0, v2);
var v4 = new glsBuiltinPrecisionTests.Constant(2);
var v5 = new glsBuiltinPrecisionTests.Apply('float', new glsBuiltinPrecisionTests.Div, v3, v4);
return v5;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Tanh = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Tanh, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Tanh.prototype.getName = function() {
return 'tanh';
};
glsBuiltinPrecisionTests.Tanh.prototype.doExpand = function(ctx, args) {
// sinh(x) / cosh(x)
var x = args.a;
var v0 = app(new glsBuiltinPrecisionTests.Sinh(), x);
var v1 = app(new glsBuiltinPrecisionTests.Cosh(), x);
var v2 = new glsBuiltinPrecisionTests.Apply('float', new glsBuiltinPrecisionTests.Div, v0, v1);
return v2;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.ASinh = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.ASinh, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.ASinh.prototype.getName = function() {
return 'asinh';
};
glsBuiltinPrecisionTests.ASinh.prototype.doExpand = function(ctx, args) {
// log(x + sqrt(x * x + constant(1.0f)))
var x = args.a;
var v0 = app(new glsBuiltinPrecisionTests.Mul(), x, x);
var v1 = new glsBuiltinPrecisionTests.Constant(1);
var v2 = app(new glsBuiltinPrecisionTests.Add(), v0, v1);
var v3 = app(new glsBuiltinPrecisionTests.Sqrt(), v2);
var v4 = app(new glsBuiltinPrecisionTests.Add(), x, v3);
var v5 = app(new glsBuiltinPrecisionTests.Log(), v4);
return v5;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.ACosh = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.ACosh, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.ACosh.prototype.getName = function() {
return 'acosh';
};
glsBuiltinPrecisionTests.ACosh.prototype.doExpand = function(ctx, args) {
// log(x + sqrt((x + constant(1.0f)) * (x - constant(1.0f))))
var x = args.a;
var one = new glsBuiltinPrecisionTests.Constant(1);
var v0 = app(new glsBuiltinPrecisionTests.Add(), x, one);
var v1 = app(new glsBuiltinPrecisionTests.Sub(), x, one);
var v2 = app(new glsBuiltinPrecisionTests.Mul(), v0, v1);
var v3 = app(new glsBuiltinPrecisionTests.Sqrt(), v2);
var v4 = app(new glsBuiltinPrecisionTests.Add(), x, v3);
var v5 = app(new glsBuiltinPrecisionTests.Log(), v4);
return v5;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.ATanh = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.ATanh, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.ATanh.prototype.getName = function() {
return 'atanh';
};
glsBuiltinPrecisionTests.ATanh.prototype.doExpand = function(ctx, args) {
// constant(0.5f) * log((constant(1.0f) + x) / (constant(1.0f) - x))
var x = args.a;
var one = new glsBuiltinPrecisionTests.Constant(1);
var half = new glsBuiltinPrecisionTests.Constant(0.5);
var v0 = app(new glsBuiltinPrecisionTests.Add(), one, x);
var v1 = app(new glsBuiltinPrecisionTests.Sub(), one, x);
var v2 = app(new glsBuiltinPrecisionTests.Div(), v0, v1);
var v3 = app(new glsBuiltinPrecisionTests.Log(), v2);
var v4 = app(new glsBuiltinPrecisionTests.Mul(), half, v3);
return v4;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Sqrt = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Sqrt, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Sqrt.prototype.getName = function() {
return 'sqrt';
};
glsBuiltinPrecisionTests.Sqrt.prototype.doExpand = function(ctx, args) {
// constant(1.0f) / app<InverseSqrt>(x)
var x = args.a;
var one = new glsBuiltinPrecisionTests.Constant(1);
var v0 = app(new glsBuiltinPrecisionTests.InverseSqrt(), x);
var v1 = app(new glsBuiltinPrecisionTests.Div(), one, v0);
return v1;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Fract = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Fract, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Fract.prototype.getName = function() {
return 'fract';
};
glsBuiltinPrecisionTests.Fract.prototype.doExpand = function(ctx, args) {
// x - floor(x)
var x = args.a;
var v0 = app(new glsBuiltinPrecisionTests.Floor(), x);
var v1 = app(new glsBuiltinPrecisionTests.Sub(), x, v0);
return v1;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Mod = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Mod, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Mod.prototype.getName = function() {
return 'mod';
};
glsBuiltinPrecisionTests.Mod.prototype.doExpand = function(ctx, args) {
// x - y * floor(x/y)
var x = args.a;
var y = args.b;
var v0 = app(new glsBuiltinPrecisionTests.Div(), x, y);
var v1 = app(new glsBuiltinPrecisionTests.Floor(), v0);
var v2 = app(new glsBuiltinPrecisionTests.Mul(), y, v1);
var v3 = app(new glsBuiltinPrecisionTests.Sub(), x, v2);
return v3;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PrimitiveFunc}
*/
glsBuiltinPrecisionTests.Modf = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float', 'float');
glsBuiltinPrecisionTests.PrimitiveFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Modf, glsBuiltinPrecisionTests.PrimitiveFunc);
glsBuiltinPrecisionTests.Modf.prototype.getName = function() {
return 'modf';
};
glsBuiltinPrecisionTests.Modf.prototype.doApply = function(ctx, iargs, variablenames) {
var intPart;
var func1 = function(x) {
intPart = Math.trunc(x);
return x - intPart;
};
var func2 = function(x) {
return Math.trunc(x);
};
var fracIV = tcuInterval.applyMonotone1p(func1, iargs.a);
var wholeIV = tcuInterval.applyMonotone1p(func2, iargs.a);
if (!iargs.a.isFinite()) {
// Behavior on modf(Inf) not well-defined, allow anything as a fractional part
fracIV.operatorOrAssignBinary(tcuInterval.NAN);
}
ctx.env.m_map[variablenames[1]] = wholeIV;
return fracIV;
};
glsBuiltinPrecisionTests.Modf.prototype.getOutParamIndex = function() {
return 1;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Mix = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float', 'float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Mix, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Mix.prototype.getName = function() {
return 'mix';
};
glsBuiltinPrecisionTests.Mix.prototype.operation1 = function(ctx, args) {
// (x * (constant(1.0f) - a)) + y * a
var x = args.a;
var y = args.b;
var a = args.c;
var one = new glsBuiltinPrecisionTests.Constant(1);
var v0 = app(new glsBuiltinPrecisionTests.Sub(), one, a);
var v1 = app(new glsBuiltinPrecisionTests.Mul(), x, v0);
var v2 = app(new glsBuiltinPrecisionTests.Mul(), y, a);
var v3 = app(new glsBuiltinPrecisionTests.Add(), v1, v2);
return v3;
};
glsBuiltinPrecisionTests.Mix.prototype.operation2 = function(ctx, args) {
// x + (y - x) * a
var x = args.a;
var y = args.b;
var a = args.c;
var v0 = app(new glsBuiltinPrecisionTests.Sub(), y, x);
var v1 = app(new glsBuiltinPrecisionTests.Mul(), a, v0);
var v2 = app(new glsBuiltinPrecisionTests.Add(), x, v1);
return v2;
};
glsBuiltinPrecisionTests.Mix.prototype.doExpand = function(ctx, args){
return app(new glsBuiltinPrecisionTests.Alternatives(this.Sig), this.operation1(ctx, args), this.operation2(ctx, args), new glsBuiltinPrecisionTests.Void(), new glsBuiltinPrecisionTests.Void());
}
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.SmoothStep = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float', 'float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.SmoothStep, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.SmoothStep.prototype.getName = function() {
return 'smoothstep';
};
glsBuiltinPrecisionTests.SmoothStep.prototype.doExpand = function(ctx, args) {
var edge0 = args.a;
var edge1 = args.b;
var x = args.c;
var zero = new glsBuiltinPrecisionTests.Constant(0);
var one = new glsBuiltinPrecisionTests.Constant(1);
//clamp((x - edge0) / (edge1 - edge0), constant(0.0f), constant(1.0f));
var v0 = app(new glsBuiltinPrecisionTests.Sub(), x, edge0);
var v1 = app(new glsBuiltinPrecisionTests.Sub(), edge1, edge0);
var v2 = app(new glsBuiltinPrecisionTests.Div(), v0, v1);
var v3 = app(new glsBuiltinPrecisionTests.Clamp(), v2, zero, one);
var t = glsBuiltinPrecisionTests.bindExpression('float', 't', ctx, v3);
//(t * t * (constant(3.0f) - constant(2.0f) * t))
var two = new glsBuiltinPrecisionTests.Constant(2);
var three = new glsBuiltinPrecisionTests.Constant(3);
var v4 = app(new glsBuiltinPrecisionTests.Mul(), v3, v3);
var v5 = app(new glsBuiltinPrecisionTests.Mul(), two, v3);
var v6 = app(new glsBuiltinPrecisionTests.Sub(), three, v5);
var v7 = app(new glsBuiltinPrecisionTests.Mul(), v4, v6);
return v7;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Pow = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Pow, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Pow.prototype.getName = function() {
return 'pow';
};
glsBuiltinPrecisionTests.Pow.prototype.doExpand = function(ctx, args) {
// exp2(y * log2(x))
var x = args.a;
var y = args.b;
var v0 = app(new glsBuiltinPrecisionTests.Log2(), x);
var v1 = app(new glsBuiltinPrecisionTests.Mul(), y, v0);
var v2 = app(new glsBuiltinPrecisionTests.Exp2(), v1);
return v2;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CFloatFunc1}
*/
glsBuiltinPrecisionTests.ExpFunc = function(name, func) {
glsBuiltinPrecisionTests.CFloatFunc1.call(this, name, func);
};
setParentClass(glsBuiltinPrecisionTests.ExpFunc, glsBuiltinPrecisionTests.CFloatFunc1);
glsBuiltinPrecisionTests.ExpFunc.prototype.getCodomain = function() {
return tcuInterval.withNumbers(0, Infinity);
};
glsBuiltinPrecisionTests.ExpFunc.prototype.precision = function(ctx, ret, x) {
switch (ctx.floatPrecision) {
case gluShaderUtil.precision.PRECISION_HIGHP:
return ctx.format.ulp(ret, 3.0 + 2.0 * Math.abs(x));
case gluShaderUtil.precision.PRECISION_MEDIUMP:
return ctx.format.ulp(ret, 2.0 + 2.0 * Math.abs(x));
case gluShaderUtil.precision.PRECISION_LOWP:
return ctx.format.ulp(ret, 2.0);
default:
throw new Error(!'Impossible');
}
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.ExpFunc}
*/
glsBuiltinPrecisionTests.Exp = function() {
glsBuiltinPrecisionTests.ExpFunc.call(this, 'exp', Math.exp);
};
setParentClass(glsBuiltinPrecisionTests.Exp, glsBuiltinPrecisionTests.ExpFunc);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.ExpFunc}
*/
glsBuiltinPrecisionTests.Exp2 = function() {
/**
* @param {number} x
* @return {number}
*/
var exp2 = function(x) {
return Math.exp(x * Math.LN2);
};
glsBuiltinPrecisionTests.ExpFunc.call(this, 'exp2', exp2);
};
setParentClass(glsBuiltinPrecisionTests.Exp2, glsBuiltinPrecisionTests.ExpFunc);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CFloatFunc1}
*/
glsBuiltinPrecisionTests.LogFunc = function(name, func) {
glsBuiltinPrecisionTests.CFloatFunc1.call(this, name, func);
};
setParentClass(glsBuiltinPrecisionTests.LogFunc, glsBuiltinPrecisionTests.CFloatFunc1);
glsBuiltinPrecisionTests.LogFunc.prototype.precision = function(ctx, ret, x) {
if (x <= 0)
return NaN;
switch (ctx.floatPrecision) {
case gluShaderUtil.precision.PRECISION_HIGHP:
return (0.5 <= x && x <= 2.0) ? deMath.deLdExp(1.0, -21) : ctx.format.ulp(ret, 3.0);
case gluShaderUtil.precision.PRECISION_MEDIUMP:
return (0.5 <= x && x <= 2.0) ? deMath.deLdExp(1.0, -7) : ctx.format.ulp(ret, 2.0);
case gluShaderUtil.precision.PRECISION_LOWP:
return ctx.format.ulp(ret, 2.0);
default:
throw new Error(!'Impossible');
}
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.LogFunc}
*/
glsBuiltinPrecisionTests.Log = function() {
glsBuiltinPrecisionTests.LogFunc.call(this, 'log', Math.log);
};
setParentClass(glsBuiltinPrecisionTests.Log, glsBuiltinPrecisionTests.LogFunc);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.LogFunc}
*/
glsBuiltinPrecisionTests.Log2 = function() {
glsBuiltinPrecisionTests.LogFunc.call(this, 'log2', Math.log2);
};
setParentClass(glsBuiltinPrecisionTests.Log2, glsBuiltinPrecisionTests.LogFunc);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CFloatFunc1}
*/
glsBuiltinPrecisionTests.PreciseFunc1 = function(name, func) {
glsBuiltinPrecisionTests.CFloatFunc1.call(this, name, func);
};
setParentClass(glsBuiltinPrecisionTests.PreciseFunc1, glsBuiltinPrecisionTests.CFloatFunc1);
glsBuiltinPrecisionTests.PreciseFunc1.prototype.precision = function(ctx, ret, x) {
return 0;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PreciseFunc1}
*/
glsBuiltinPrecisionTests.Abs = function() {
glsBuiltinPrecisionTests.PreciseFunc1.call(this, 'abs', Math.abs);
};
setParentClass(glsBuiltinPrecisionTests.Abs, glsBuiltinPrecisionTests.PreciseFunc1);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PreciseFunc1}
*/
glsBuiltinPrecisionTests.Sign = function() {
glsBuiltinPrecisionTests.PreciseFunc1.call(this, 'sign', Math.sign);
};
setParentClass(glsBuiltinPrecisionTests.Sign, glsBuiltinPrecisionTests.PreciseFunc1);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PreciseFunc1}
*/
glsBuiltinPrecisionTests.Floor = function() {
glsBuiltinPrecisionTests.PreciseFunc1.call(this, 'floor', Math.floor);
};
setParentClass(glsBuiltinPrecisionTests.Floor, glsBuiltinPrecisionTests.PreciseFunc1);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PreciseFunc1}
*/
glsBuiltinPrecisionTests.RoundEven = function() {
glsBuiltinPrecisionTests.PreciseFunc1.call(this, 'roundEven', deMath.rint);
};
setParentClass(glsBuiltinPrecisionTests.RoundEven, glsBuiltinPrecisionTests.PreciseFunc1);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PreciseFunc1}
*/
glsBuiltinPrecisionTests.Ceil = function() {
glsBuiltinPrecisionTests.PreciseFunc1.call(this, 'ceil', Math.ceil);
};
setParentClass(glsBuiltinPrecisionTests.Ceil, glsBuiltinPrecisionTests.PreciseFunc1);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PreciseFunc1}
*/
glsBuiltinPrecisionTests.Trunc = function() {
glsBuiltinPrecisionTests.PreciseFunc1.call(this, 'trunc', Math.trunc);
};
setParentClass(glsBuiltinPrecisionTests.Trunc, glsBuiltinPrecisionTests.PreciseFunc1);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CFloatFunc2}
*/
glsBuiltinPrecisionTests.PreciseFunc2 = function(name, func) {
glsBuiltinPrecisionTests.CFloatFunc2.call(this, name, func);
};
setParentClass(glsBuiltinPrecisionTests.PreciseFunc2, glsBuiltinPrecisionTests.CFloatFunc2);
glsBuiltinPrecisionTests.PreciseFunc2.prototype.precision = function(ctx, ret, x, y) {
return 0;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PreciseFunc2}
*/
glsBuiltinPrecisionTests.Min = function() {
glsBuiltinPrecisionTests.PreciseFunc2.call(this, 'min', Math.min);
};
setParentClass(glsBuiltinPrecisionTests.Min, glsBuiltinPrecisionTests.PreciseFunc2);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PreciseFunc2}
*/
glsBuiltinPrecisionTests.Max = function() {
glsBuiltinPrecisionTests.PreciseFunc2.call(this, 'max', Math.max);
};
setParentClass(glsBuiltinPrecisionTests.Max, glsBuiltinPrecisionTests.PreciseFunc2);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.PreciseFunc2}
*/
glsBuiltinPrecisionTests.Step = function() {
/**
* @param {number} edge
* @param {number} x
* return number
*/
var step = function(edge, x) {
return x < edge ? 0.0 : 1.0;
};
glsBuiltinPrecisionTests.PreciseFunc2.call(this, 'step', step);
};
setParentClass(glsBuiltinPrecisionTests.Step, glsBuiltinPrecisionTests.PreciseFunc2);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CFloatFunc1}
*/
glsBuiltinPrecisionTests.TrigFunc = function(name, func, loEx, hiEx) {
glsBuiltinPrecisionTests.CFloatFunc1.call(this, name, func);
this.m_loExtremum = loEx;
this.m_hiExtremum = hiEx;
};
setParentClass(glsBuiltinPrecisionTests.TrigFunc, glsBuiltinPrecisionTests.CFloatFunc1);
glsBuiltinPrecisionTests.TrigFunc.prototype.innerExtrema = function(ctx, angle) {
var lo = angle.lo();
var hi = angle.hi();
var loSlope = this.doGetSlope(lo);
var hiSlope = this.doGetSlope(hi);
// Detect the high and low values the function can take between the
// interval endpoints.
if (angle.length() >= 2.0 * Math.PI) {
// The interval is longer than a full cycle, so it must get all possible values.
return this.m_hiExtremum.operatorOrBinary(this.m_loExtremum);
} else if (loSlope == 1 && hiSlope == -1) {
// The slope can change from positive to negative only at the maximum value.
return this.m_hiExtremum;
} else if (loSlope == -1 && hiSlope == 1) {
// The slope can change from negative to positive only at the maximum value.
return this.m_loExtremum;
} else if (loSlope == hiSlope &&
deMath.deSign(this.applyExact(hi) - this.applyExact(lo)) * loSlope == -1) {
// The slope has changed twice between the endpoints, so both extrema are included.
return this.m_hiExtremum.operatorOrBinary(this.m_loExtremum);
}
return new tcuInterval.Interval();
};
glsBuiltinPrecisionTests.TrigFunc.prototype.getCodomain = function() {
// Ensure that result is always within [-1, 1], or NaN (for +-inf)
var v = tcuInterval.withIntervals(new tcuInterval.Interval(-1), new tcuInterval.Interval(1));
return v.operatorOrBinary(tcuInterval.NAN);
};
glsBuiltinPrecisionTests.TrigFunc.prototype.precision = function(ctx, ret, arg) {
if (ctx.floatPrecision == gluShaderUtil.precision.PRECISION_HIGHP) {
// Use precision from OpenCL fast relaxed math
if (-Math.PI <= arg && arg <= Math.PI) {
return deMath.deLdExp(1.0, -11);
} else {
// "larger otherwise", let's pick |x| * 2^-12 , which is slightly over
// 2^-11 at x == pi.
return deMath.deLdExp(Math.abs(arg), -12);
}
} else if (ctx.floatPrecision == gluShaderUtil.precision.PRECISION_MEDIUMP) {
if (-Math.PI <= arg && arg <= Math.PI) {
// from OpenCL half-float extension specification
return ctx.format.ulp(ret, 2.0);
} else {
// |x| * 2^-10 , slightly larger than 2 ULP at x == pi
return deMath.deLdExp(Math.abs(arg), -10);
}
} else {
// from OpenCL half-float extension specification
return ctx.format.ulp(ret, 2.0);
}
};
/**
* @param {number} angle
* @return number
*/
glsBuiltinPrecisionTests.TrigFunc.prototype.doGetSlope = function(angle) {
throw new Error('Virtual function. Please override.');
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.TrigFunc}
*/
glsBuiltinPrecisionTests.Sin = function() {
glsBuiltinPrecisionTests.TrigFunc.call(this, 'sin', Math.sin, new tcuInterval.Interval(-1), new tcuInterval.Interval(1));
};
setParentClass(glsBuiltinPrecisionTests.Sin, glsBuiltinPrecisionTests.TrigFunc);
glsBuiltinPrecisionTests.Sin.prototype.doGetSlope = function(angle) {
return deMath.deSign(Math.cos(angle));
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.TrigFunc}
*/
glsBuiltinPrecisionTests.Cos = function() {
glsBuiltinPrecisionTests.TrigFunc.call(this, 'cos', Math.cos, new tcuInterval.Interval(-1), new tcuInterval.Interval(1));
};
setParentClass(glsBuiltinPrecisionTests.Cos, glsBuiltinPrecisionTests.TrigFunc);
glsBuiltinPrecisionTests.Cos.prototype.doGetSlope = function(angle) {
return -deMath.deSign(Math.sin(angle));
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Tan = function() {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'float');
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Tan, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Tan.prototype.getName = function() {
return 'tan';
};
glsBuiltinPrecisionTests.Tan.prototype.doExpand = function(ctx, args) {
// sin(x) * (constant(1.0f) / cos(x)
var x = args.a;
var sin = app(new glsBuiltinPrecisionTests.Sin(), x);
var cos = app(new glsBuiltinPrecisionTests.Cos(), x);
var expr = app(new glsBuiltinPrecisionTests.Div(),
new glsBuiltinPrecisionTests.Constant(1),
cos);
expr = new glsBuiltinPrecisionTests.Apply('float', new glsBuiltinPrecisionTests.Mul(),
sin,
expr);
return expr;
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CFloatFunc1}
*/
glsBuiltinPrecisionTests.ASin = function() {
glsBuiltinPrecisionTests.CFloatFunc1.call(this, 'asin', Math.asin);
};
setParentClass(glsBuiltinPrecisionTests.ASin, glsBuiltinPrecisionTests.CFloatFunc1);
glsBuiltinPrecisionTests.ASin.prototype.precision = function(ctx, ret, x) {
if (!deMath.deInBounds32(x, -1.0, 1.0))
return NaN;
if (ctx.floatPrecision == gluShaderUtil.precision.PRECISION_HIGHP) {
// Absolute error of 2^-11
return deMath.deLdExp(1.0, -11);
} else {
// Absolute error of 2^-8
return deMath.deLdExp(1.0, -8);
}
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CFloatFunc1}
*/
glsBuiltinPrecisionTests.ArcTrigFunc = function(name, func, precisionULPs, domain, coddomain) {
glsBuiltinPrecisionTests.CFloatFunc1.call(this, name, func);
this.m_precision = precisionULPs;
this.m_domain = domain;
this.m_codomain = coddomain;
};
setParentClass(glsBuiltinPrecisionTests.ArcTrigFunc, glsBuiltinPrecisionTests.CFloatFunc1);
glsBuiltinPrecisionTests.ArcTrigFunc.prototype.precision = function(ctx, ret, x) {
if (!this.m_domain.contains(new tcuInterval.Interval(x)))
return NaN;
if (ctx.floatPrecision == gluShaderUtil.precision.PRECISION_HIGHP) {
// Use OpenCL's precision
return ctx.format.ulp(ret, this.m_precision);
} else {
// Use OpenCL half-float spec
return ctx.format.ulp(ret, 2.0);
}
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.ArcTrigFunc}
*/
glsBuiltinPrecisionTests.ACos = function() {
glsBuiltinPrecisionTests.ArcTrigFunc.call(this, 'acos', Math.acos, 4096.0,
tcuInterval.withNumbers(-1, 1),
tcuInterval.withNumbers(0, Math.PI));
};
setParentClass(glsBuiltinPrecisionTests.ACos, glsBuiltinPrecisionTests.ArcTrigFunc);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.ArcTrigFunc}
*/
glsBuiltinPrecisionTests.ATan = function() {
glsBuiltinPrecisionTests.ArcTrigFunc.call(this, 'atan', Math.atan, 4096.0,
tcuInterval.unbounded(),
tcuInterval.withNumbers(-Math.PI * 0.5, Math.PI * 0.5));
};
setParentClass(glsBuiltinPrecisionTests.ATan, glsBuiltinPrecisionTests.ArcTrigFunc);
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.CFloatFunc2}
*/
glsBuiltinPrecisionTests.ATan2 = function() {
glsBuiltinPrecisionTests.CFloatFunc2.call(this, 'atan', Math.atan2);
};
setParentClass(glsBuiltinPrecisionTests.ATan2, glsBuiltinPrecisionTests.CFloatFunc2);
glsBuiltinPrecisionTests.ATan2.prototype.innerExtrema = function(ctx, xi, yi) {
var ret = new tcuInterval.Interval();
if (yi.contains(tcuInterval.ZERO)) {
if (xi.contains(tcuInterval.ZERO))
ret.operatorOrAssignBinary(tcuInterval.NAN);
if (xi.intersects(tcuInterval.withNumbers(-Infinity, 0)))
ret.operatorOrAssignBinary(tcuInterval.withNumbers(-Math.PI, Math.PI));
}
if (ctx.format.hasInf() != tcuFloatFormat.YesNoMaybe.YES && (!yi.isFinite() || !xi.isFinite())) {
// Infinities may not be supported, allow anything, including NaN
ret.operatorOrAssignBinary(tcuInterval.NAN);
}
return ret;
};
glsBuiltinPrecisionTests.ATan2.prototype.precision = function(ctx, ret, x, y) {
if (ctx.floatPrecision == gluShaderUtil.precision.PRECISION_HIGHP)
return ctx.format.ulp(ret, 4096.0);
else
return ctx.format.ulp(ret, 2.0);
};
/**
* @constructor
* @param {number} size
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.DeterminantBase = function(size) {
var sig = new glsBuiltinPrecisionTests.Signature('float', 'mat' + size);
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.DeterminantBase, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.DeterminantBase.prototype.getName = function() {
return 'determinant';
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DeterminantBase}
*/
glsBuiltinPrecisionTests.Determinant = function() {
// TODO: Support sizes 3 and 4
this.size = 2;
glsBuiltinPrecisionTests.DeterminantBase.call(this, this.size);
};
setParentClass(glsBuiltinPrecisionTests.Determinant, glsBuiltinPrecisionTests.DeterminantBase);
glsBuiltinPrecisionTests.Determinant.prototype.doExpand = function(ctx, args) {
// mat[0][0] * mat[1][1] - mat[1][0] * mat[0][1]
var elem0_0 = new glsBuiltinPrecisionTests.MatrixVariable(args.a, 0, 0);
var elem0_1 = new glsBuiltinPrecisionTests.MatrixVariable(args.a, 0, 1);
var elem1_0 = new glsBuiltinPrecisionTests.MatrixVariable(args.a, 1, 0);
var elem1_1 = new glsBuiltinPrecisionTests.MatrixVariable(args.a, 1, 1);
var val0 = app(new glsBuiltinPrecisionTests.Mul(), elem0_0, elem1_1);
var val1 = app(new glsBuiltinPrecisionTests.Mul(), elem0_1, elem1_0);
return new glsBuiltinPrecisionTests.Apply('float', new glsBuiltinPrecisionTests.Sub(), val0, val1);
};
/**
* @constructor
* @extends {glsBuiltinPrecisionTests.DerivedFunc}
*/
glsBuiltinPrecisionTests.Inverse = function() {
this.size = 2;
var name = 'mat' + this.size;
var sig = new glsBuiltinPrecisionTests.Signature(name, name);
glsBuiltinPrecisionTests.DerivedFunc.call(this, sig);
};
setParentClass(glsBuiltinPrecisionTests.Inverse, glsBuiltinPrecisionTests.DerivedFunc);
glsBuiltinPrecisionTests.Inverse.prototype.getName = function() {
return 'inverse';
};
glsBuiltinPrecisionTests.Inverse.prototype.doExpand = function(ctx, args) {
var mat = args.a;
var v0 = app(new glsBuiltinPrecisionTests.Determinant(), mat);
var det = glsBuiltinPrecisionTests.bindExpression('float', 'det', ctx, v0);
var elem0_0 = new glsBuiltinPrecisionTests.MatrixVariable(args.a, 0, 0);
var elem0_1 = new glsBuiltinPrecisionTests.MatrixVariable(args.a, 0, 1);
var elem1_0 = new glsBuiltinPrecisionTests.MatrixVariable(args.a, 1, 0);
var elem1_1 = new glsBuiltinPrecisionTests.MatrixVariable(args.a, 1, 1);
var result0_0 = app(new glsBuiltinPrecisionTests.Div(), elem1_1, det);
var result0_1 = app(new glsBuiltinPrecisionTests.Div(), elem0_1, det);
result0_1 = app(new glsBuiltinPrecisionTests.Negate(), result0_1);
var result1_0 = app(new glsBuiltinPrecisionTests.Div(), elem1_0, det);
result1_0 = app(new glsBuiltinPrecisionTests.Negate(), result1_0);
var result1_1 = app(new glsBuiltinPrecisionTests.Div(), elem0_0, det);
var col0 = app(new glsBuiltinPrecisionTests.GenVec(this.size, true), result0_0, result1_0);
var col1 = app(new glsBuiltinPrecisionTests.GenVec(this.size, true), result0_1, result1_1);
var ret = app(new glsBuiltinPrecisionTests.GenMat(this.size, this.size), col0, col1);
return ret;
};
/**
* @param {glsBuiltinPrecisionTests.PrecisionTestContext} ctx
* @param {glsBuiltinPrecisionTests.CaseFactory} factory
* @return {tcuTestCase.DeqpTest}
*/
glsBuiltinPrecisionTests.createFuncGroup = function(ctx, factory) {
/** @type {tcuTestCase.DeqpTest} */ var group = tcuTestCase.newTest(factory.getName(), factory.getDesc());
for (var precNdx in gluShaderUtil.precision) {
/** @type {gluShaderUtil.precision} */ var precision = gluShaderUtil.precision[precNdx];
/** @type {string} */ var precName = gluShaderUtil.getPrecisionName(precision);
/** @type {tcuFloatFormat.FloatFormat} */ var fmt = ctx.formats[precision];
/** @type {tcuFloatFormat.FloatFormat} */ var highpFmt = ctx.formats[gluShaderUtil.precision.PRECISION_HIGHP];
for (var shaderNdx in ctx.shaderTypes) {
/** @type {gluShaderProgram.shaderType} */ var shaderType = ctx.shaderTypes[shaderNdx];
/** @type {string} */ var shaderName = gluShaderProgram.getShaderTypeName(shaderType);
/** @type {string} */ var name = precName + '_' + shaderName;
/** @type {glsBuiltinPrecisionTests.Context} */ var caseCtx = new glsBuiltinPrecisionTests.Context(name, fmt, highpFmt,
precision, shaderType, ctx.numRandoms);
group.addChild(factory.createCase(caseCtx));
}
}
return group;
};
/**
* @param {glsBuiltinPrecisionTests.CaseFactories} cases
* @param {Array<gluShaderProgram.shaderType>} shaderTypes
* @param {tcuTestCase.DeqpTest} dstGroup
*/
glsBuiltinPrecisionTests.addBuiltinPrecisionTests = function(cases, shaderTypes, dstGroup) {
/** @type {tcuFloatFormat.FloatFormat} */ var highp = new tcuFloatFormat.FloatFormat(-126, 127, 23, true,
tcuFloatFormat.YesNoMaybe.MAYBE, // subnormals
tcuFloatFormat.YesNoMaybe.YES, // infinities
tcuFloatFormat.YesNoMaybe.MAYBE); // NaN
/** @type {tcuFloatFormat.FloatFormat} */ var mediump = new tcuFloatFormat.FloatFormat(-13, 13, 9, false);
// A fixed-point format is just a floating point format with a fixed
// exponent and support for subnormals.
/** @type {tcuFloatFormat.FloatFormat} */ var lowp = new tcuFloatFormat.FloatFormat(0, 0, 7, false, tcuFloatFormat.YesNoMaybe.YES);
/** @type {glsBuiltinPrecisionTests.PrecisionTestContext} */ var ctx = new glsBuiltinPrecisionTests.PrecisionTestContext(highp, mediump, lowp,
shaderTypes, 16384);
for (var ndx = 0; ndx < cases.getFactories().length; ++ndx)
dstGroup.addChild(glsBuiltinPrecisionTests.createFuncGroup(ctx, cases.getFactories()[ndx]));
};
/**
* @param {function(new:glsBuiltinPrecisionTests.Func)} F
* @param {glsBuiltinPrecisionTests.CaseFactories} funcs
* @param {string=} name
*/
glsBuiltinPrecisionTests.addScalarFactory = function(F, funcs, name) {
if (name === undefined)
name = (new F()).getName();
funcs.addFactory(new glsBuiltinPrecisionTests.GenFuncCaseFactory(glsBuiltinPrecisionTests.makeVectorizedFuncs(F), name));
};
/**
* @param {function(new:glsBuiltinPrecisionTests.Func)} F
*/
glsBuiltinPrecisionTests.createSimpleFuncCaseFactory = function(F) {
return new glsBuiltinPrecisionTests.SimpleFuncCaseFactory(new F());
};
/**
* @param {number} caseId test case Id
* @return {glsBuiltinPrecisionTests.CaseFactories}
*/
glsBuiltinPrecisionTests.createES3BuiltinCases = function(caseId) {
/** @type {glsBuiltinPrecisionTests.CaseFactories} */ var funcs = new glsBuiltinPrecisionTests.BuiltinFuncs();
switch (caseId) {
case 0: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Add, funcs); break;
case 1: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Sub, funcs); break;
case 2: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Mul, funcs); break;
case 3: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Div, funcs); break;
case 4: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Radians, funcs); break;
case 5: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Degrees, funcs); break;
case 6: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Sin, funcs); break;
case 7: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Cos, funcs); break;
case 8: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Tan, funcs); break;
case 9: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.ASin, funcs); break;
case 10: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.ACos, funcs); break;
case 11: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.ATan, funcs); break;
case 12: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.ATan2, funcs, 'atan2'); break;
case 13: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Sinh, funcs); break;
case 14: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Cosh, funcs); break;
case 15: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Tanh, funcs); break;
case 16: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.ASinh, funcs); break;
case 17: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.ACosh, funcs); break;
case 18: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.ATanh, funcs); break;
case 19: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Pow, funcs); break;
case 20: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Exp, funcs); break;
case 21: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Exp2, funcs); break;
case 22: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Log, funcs); break;
case 23: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Log2, funcs); break;
case 24: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Sqrt, funcs); break;
case 25: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.InverseSqrt, funcs); break;
case 26: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Abs, funcs); break;
case 27: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Sign, funcs); break;
case 28: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Floor, funcs); break;
case 29: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Trunc, funcs); break;
case 30: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Round, funcs); break;
case 31: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.RoundEven, funcs); break;
case 32: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Ceil, funcs); break;
case 33: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Fract, funcs); break;
case 34: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Mod, funcs); break;
case 35: funcs.addFactory(glsBuiltinPrecisionTests.createSimpleFuncCaseFactory(glsBuiltinPrecisionTests.Modf)); break;
case 36: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Min, funcs); break;
case 37: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Max, funcs); break;
case 38: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Mix, funcs); break;
case 39: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Step, funcs); break;
case 40: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.SmoothStep, funcs); break;
case 41: glsBuiltinPrecisionTests.addScalarFactory(glsBuiltinPrecisionTests.Clamp, funcs); break;
case 42: funcs.addFactory(new glsBuiltinPrecisionTests.TemplateFuncCaseFactory(glsBuiltinPrecisionTests.Length)); break;
case 43: funcs.addFactory(new glsBuiltinPrecisionTests.TemplateFuncCaseFactory(glsBuiltinPrecisionTests.Distance)); break;
case 44: funcs.addFactory(new glsBuiltinPrecisionTests.TemplateFuncCaseFactory(glsBuiltinPrecisionTests.Dot)); break;
case 45: funcs.addFactory(glsBuiltinPrecisionTests.createSimpleFuncCaseFactory(glsBuiltinPrecisionTests.Cross)); break;
case 46: funcs.addFactory(new glsBuiltinPrecisionTests.TemplateFuncCaseFactory(glsBuiltinPrecisionTests.Normalize)); break;
case 47: funcs.addFactory(new glsBuiltinPrecisionTests.TemplateFuncCaseFactory(glsBuiltinPrecisionTests.FaceForward)); break;
case 48: funcs.addFactory(new glsBuiltinPrecisionTests.TemplateFuncCaseFactory(glsBuiltinPrecisionTests.Reflect)); break;
case 49: funcs.addFactory(new glsBuiltinPrecisionTests.TemplateFuncCaseFactory(glsBuiltinPrecisionTests.Refract)); break;
case 50: funcs.addFactory(new glsBuiltinPrecisionTests.MatrixFuncCaseFactory(glsBuiltinPrecisionTests.MatrixCompMult)); break;
case 51: funcs.addFactory(new glsBuiltinPrecisionTests.MatrixFuncCaseFactory(glsBuiltinPrecisionTests.OuterProduct)); break;
case 52: funcs.addFactory(new glsBuiltinPrecisionTests.MatrixFuncCaseFactory(glsBuiltinPrecisionTests.Transpose)); break;
case 53: funcs.addFactory(new glsBuiltinPrecisionTests.SquareMatrixFuncCaseFactory(glsBuiltinPrecisionTests.Determinant)); break;
case 54: funcs.addFactory(new glsBuiltinPrecisionTests.SquareMatrixFuncCaseFactory(glsBuiltinPrecisionTests.Inverse)); break;
default: break;
}
return funcs;
};
});