Lines Matching defs:ctx
672 //! Execute the statement, modifying the environment of `ctx`
673 void execute (EvalContext& ctx) const { this->doExecute(ctx); }
680 virtual void doExecute (EvalContext& ctx) const = 0;
758 void doExecute (EvalContext& ctx) const
761 ctx.env.bind(*m_variable, m_value->evaluate(ctx));
763 ctx.env.lookup(*m_variable) = m_value->evaluate(ctx);
820 void doExecute (EvalContext& ctx) const
823 m_statements[ndx]->execute(ctx);
866 IVal evaluate (const EvalContext& ctx) const;
869 virtual IVal doEvaluate (const EvalContext& ctx) const = 0;
874 typename Traits<T>::IVal Expr<T>::evaluate (const EvalContext& ctx) const
881 EvalContext newCtx (ctx.format, ctx.floatPrecision,
882 ctx.env, ctx.callDepth + 1);
887 std::cerr << string(ctx.callDepth, ' ');
893 return this->doEvaluate(ctx);
1042 IVal doEvaluate (const EvalContext& ctx) const
1044 return ctx.env.lookup<T>(*this);
1058 VariableP<T> bindExpression (const string& name, ExpandContext& ctx, const ExprP<T>& expr)
1060 VariableP<T> var = ctx.genSym<T>(name);
1061 ctx.addStatement(variableDeclaration(var, expr));
1228 IRet apply (const EvalContext& ctx,
1234 return this->applyArgs(ctx, IArgs(arg0, arg1, arg2, arg3));
1236 IRet applyArgs (const EvalContext& ctx,
1239 return this->doApply(ctx, args);
1317 IVal doEvaluate (const EvalContext& ctx) const
1319 return m_func.apply(ctx,
1320 m_args.a->evaluate(ctx), m_args.b->evaluate(ctx),
1321 m_args.c->evaluate(ctx), m_args.d->evaluate(ctx));
1399 typename F::IRet call (const EvalContext& ctx,
1405 return instance<F>().apply(ctx, arg0, arg1, arg2, arg3);
1436 IVal doEvaluate (const EvalContext& ctx) const
1442 return this->m_func.apply(ctx,
1443 ctx.env.lookup(var0), ctx.env.lookup(var1),
1444 ctx.env.lookup(var2), ctx.env.lookup(var3));
1500 IRet doApply (const EvalContext& ctx,
1515 EvalContext funCtx(ctx.format, ctx.floatPrecision, funEnv, ctx.callDepth);
1543 virtual ExprP<Ret> doExpand (ExpandContext& ctx, const ArgExprs& args_) const = 0;
1564 ExpandContext ctx (symCounter);
1572 m_ret = this->doExpand(ctx, args);
1573 m_body = ctx.getStatements();
1700 Interval doApply (const EvalContext& ctx, const IArgs& iargs) const
1702 return this->applyMonotone(ctx, iargs.a);
1705 Interval applyMonotone (const EvalContext& ctx, const Interval& iarg0) const
1711 point = this->applyPoint(ctx, arg0)));
1713 ret |= innerExtrema(ctx, iarg0);
1716 return ctx.format.convert(ret);
1724 virtual Interval applyPoint (const EvalContext& ctx, double arg0) const
1727 const double prec = this->precision(ctx, exact, arg0);
1728 const double wprec = this->warningPrecision(ctx, exact, arg0);
1744 virtual double precision (const EvalContext& ctx, double, double) const = 0;
1746 virtual double warningPrecision (const EvalContext& ctx, double exact, double arg0) const
1748 return precision(ctx, exact, arg0);
1771 Interval doApply (const EvalContext& ctx, const IArgs& iargs) const
1773 return this->applyMonotone(ctx, iargs.a, iargs.b);
1776 Interval applyMonotone (const EvalContext& ctx,
1784 point = this->applyPoint(ctx, x, y)));
1785 reti |= innerExtrema(ctx, xi, yi);
1788 return ctx.format.convert(reti);
1798 virtual Interval applyPoint (const EvalContext& ctx,
1803 const double prec = this->precision(ctx, exact, x, y);
1818 virtual double precision (const EvalContext& ctx,
1853 Interval applyPoint (const EvalContext& ctx,
1861 return ctx.format.roundOut(exact, !deIsInf(x) && !deIsInf(y));
1873 Interval doApply (const EvalContext& ctx, const IArgs& iargs) const
1875 return this->applyMonotone(ctx, iargs.a, iargs.b, iargs.c);
1878 Interval applyMonotone (const EvalContext& ctx,
1886 point = this->applyPoint(ctx, x, y, z)));
1887 return ctx.format.convert(reti);
1890 virtual Interval applyPoint (const EvalContext& ctx,
1896 const double prec = this->precision(ctx, exact, x, y, z);
1905 virtual double precision (const EvalContext& ctx,
1926 Interval doApply (const EvalContext& ctx,
1930 if (iargs.a.isOrdinary(ctx.format.getMaxValue()) && iargs.b.isOrdinary(ctx.format.getMaxValue()))
1936 return ctx.format.convert(ctx.format.roundOut(ret, true));
1938 return this->applyMonotone(ctx, iargs.a, iargs.b);
1951 Interval doApply (const EvalContext& ctx, const IArgs& iargs) const
1957 if (a.isOrdinary(ctx.format.getMaxValue()) && b.isOrdinary(ctx.format.getMaxValue()))
1970 return ctx.format.convert(ctx.format.roundOut(ret, true));
1977 return ctx.format.convert(ctx.format.roundOut(ret, true));
1980 return this->applyMonotone(ctx, iargs.a, iargs.b);
2002 Interval doApply (const EvalContext& ctx, const IArgs& iargs) const
2005 if (iargs.a.isOrdinary(ctx.format.getMaxValue()) && iargs.b.isOrdinary(ctx.format.getMaxValue()))
2012 return ctx.format.convert(ctx.format.roundOut(ret, true));
2017 return this->applyMonotone(ctx, iargs.a, iargs.b);
2064 Interval applyPoint (const EvalContext& ctx, double x, double y) const
2066 Interval ret = FloatFunc2::applyPoint(ctx, x, y);
2070 const Interval dst = ctx.format.convert(ret);
2071 if (dst.contains(-TCU_INFINITY)) ret |= -ctx.format.getMaxValue();
2072 if (dst.contains(+TCU_INFINITY)) ret |= +ctx.format.getMaxValue();
2078 double precision (const EvalContext& ctx, double ret, double, double den) const
2080 const FloatFormat& fmt = ctx.format;
2105 double precision (const EvalContext& ctx, double ret, double x) const
2107 return x <= 0 ? TCU_NAN : ctx.format.ulp(ret, 2.0);
2122 double precision (const EvalContext& ctx, double ret, double x) const
2124 switch (ctx.floatPrecision)
2127 return ctx.format.ulp(ret, 3.0 + 2.0 * deAbs(x));
2129 return ctx.format.ulp(ret, 2.0 + 2.0 * deAbs(x));
2131 return ctx.format.ulp(ret, 2.0);
2157 double precision (const EvalContext& ctx, double ret, double x) const
2162 switch (ctx.floatPrecision)
2165 return (0.5 <= x && x <= 2.0) ? deLdExp(1.0, -21) : ctx.format.ulp(ret, 3.0);
2167 return (0.5 <= x && x <= 2.0) ? deLdExp(1.0, -7) : ctx.format.ulp(ret, 2.0);
2169 return ctx.format.ulp(ret, 2.0);
2179 double warningPrecision(const EvalContext& ctx, double ret, double x) const
2181 if (ctx.floatPrecision == glu::PRECISION_HIGHP && x > 0)
2183 return (0.5 <= x && x <= 2.0) ? deLdExp(1.0, -21) : ctx.format.ulp(ret, 4.0);
2187 return precision(ctx, ret, x);
2336 double precision (const EvalContext& ctx, double ret, double arg) const
2338 if (ctx.floatPrecision == glu::PRECISION_HIGHP)
2352 else if (ctx.floatPrecision == glu::PRECISION_MEDIUMP)
2357 return ctx.format.ulp(ret, 2.0);
2367 DE_ASSERT(ctx.floatPrecision == glu::PRECISION_LOWP);
2370 return ctx.format.ulp(ret, 2.0);
2410 double precision (const EvalContext& ctx, double, double x) const
2415 if (ctx.floatPrecision == glu::PRECISION_HIGHP)
2443 double precision (const EvalContext& ctx, double ret, double x) const
2448 if (ctx.floatPrecision == glu::PRECISION_HIGHP)
2451 return ctx.format.ulp(ret, m_precision);
2456 return ctx.format.ulp(ret, 2.0);
2490 Interval innerExtrema (const EvalContext& ctx,
2504 if (!yi.isFinite(ctx.format.getMaxValue()) || !xi.isFinite(ctx.format.getMaxValue()))
2513 double precision (const EvalContext& ctx, double ret, double, double) const
2515 if (ctx.floatPrecision == glu::PRECISION_HIGHP)
2516 return ctx.format.ulp(ret, 4096.0);
2518 return ctx.format.ulp(ret, 2.0);
2827 IRet doApply (const EvalContext& ctx, const IArgs& iargs) const
2834 ret[col][row] = this->doGetScalarFunc().apply(ctx,
2883 IRet doApply (const EvalContext& ctx, const IArgs& iargs) const
2890 ret[col][row] = this->doGetScalarFunc().apply(ctx, iargs.a[col][row], iargs.b);
3145 static ExprP<Ret> apply (ExpandContext& ctx,
3149 const ExprP<float> dotNI = bindExpression("dotNI", ctx, dot(n, i));
3187 ExprP<Ret> doExpand (ExpandContext& ctx, const ArgExprs& args) const
3192 return ApplyReflect<Size, Ret, Arg0, Arg1>::apply(ctx, i, n);
3215 ExprP<Ret> doExpand (ExpandContext& ctx, const ArgExprs& args) const
3220 const ExprP<float> dotNI = bindExpression("dotNI", ctx, dot(n, i));
3221 const ExprP<float> k1 = bindExpression("k1", ctx, constant(1.0f) - eta * eta *
3224 const ExprP<float> k2 = bindExpression("k2", ctx,
3227 const ExprP<float> k = bindExpression("k", ctx, alternatives(k1, k2));
3323 IRet doApply (const EvalContext& ctx, const IArgs& iargs) const
3333 if (!iargs.a.isFinite(ctx.format.getMaxValue()))
3349 int compare(const EvalContext& ctx, double x, double y)
3351 if (ctx.format.hasSubnormal() != tcu::YES)
3353 const int minExp = ctx.format.getMinExp();
3354 const int fractionBits = ctx.format.getFractionBits();
3385 Interval applyPoint(const EvalContext& ctx, double x, double y) const
3387 const int cmp = compare(ctx, x, y) * m_sign;
3417 Interval applyPoint(const EvalContext& ctx, double x, double minVal, double maxVal) const
3422 const int cmpMin = compare(ctx, x, minVal);
3423 const int cmpMax = compare(ctx, x, maxVal);
3424 const int cmpMinMax = compare(ctx, minVal, maxVal);
3478 ExprP<Ret> doExpand (ExpandContext& ctx, const ArgExprs& args) const
3485 const ExprP<float> t = bindExpression("t", ctx, tExpr);
3557 Interval doApply (const EvalContext& ctx, const IArgs& iargs) const
3559 Interval ret = call<Exp2>(ctx, iargs.b);
3566 return call<Mul>(ctx, iargs.a, ret);
3622 IRet doApply (const EvalContext& ctx, const IArgs& iargs) const
3635 element = call<Add>(ctx, element,
3636 call<Mul>(ctx, left[ndx][row], right[col][ndx]));
3658 IRet doApply (const EvalContext& ctx, const IArgs& iargs) const
3669 element = call<Add>(ctx, element, call<Mul>(ctx, left[row], right[col][row]));
3690 IRet doApply (const EvalContext& ctx, const IArgs& iargs) const
3695 return call<VecMatMul<Cols, Rows> >(ctx, right,
3696 call<Transpose<Rows, Cols> >(ctx, left));
3715 IRet doApply (const EvalContext& ctx, const IArgs& iargs) const
3722 ret[col][row] = call<Mul>(ctx, iargs.a[row], iargs.b[col]);
3782 ExprP<Ret> doExpand (ExpandContext& ctx, const ArgExprs& args) const
3800 minors[ndx] = bindExpression("minor", ctx,
3829 ExprP<Ret> doExpand (ExpandContext& ctx, const ArgExprs& args) const
3832 ExprP<float> det = bindExpression("det", ctx, determinant(mat));
3849 ExprP<Ret> doExpand (ExpandContext& ctx, const ArgExprs& args) const
3852 ExprP<Mat2> invA = bindExpression("invA", ctx,
3856 ExprP<Vec2> matB = bindExpression("matB", ctx, vec2(mat[2][0], mat[2][1]));
3857 ExprP<Vec2> matC = bindExpression("matC", ctx, vec2(mat[0][2], mat[1][2]));
3858 ExprP<float> matD = bindExpression("matD", ctx, mat[2][2]);
3860 ExprP<float> schur = bindExpression("schur", ctx,
3869 ExprP<Mat2> blockA = bindExpression("blockA", ctx, t5);
3870 ExprP<Vec2> blockB = bindExpression("blockB", ctx,
3872 ExprP<Vec2> blockC = bindExpression("blockC", ctx,
3888 ExprP<Ret> doExpand (ExpandContext& ctx,
3892 ExprP<Mat2> invA = bindExpression("invA", ctx,
3895 ExprP<Mat2> matB = bindExpression("matB", ctx,
3898 ExprP<Mat2> matC = bindExpression("matC", ctx,
3901 ExprP<Mat2> matD = bindExpression("matD", ctx,
3904 ExprP<Mat2> schur = bindExpression("schur", ctx,
3906 ExprP<Mat2> blockA = bindExpression("blockA", ctx,
3908 ExprP<Mat2> blockB = bindExpression("blockB", ctx,
3910 ExprP<Mat2> blockC = bindExpression("blockC", ctx,
4010 IRet doApply (const EvalContext& ctx, const IArgs& iargs) const
4017 m_func.apply(ctx, iargs.a[ndx], iargs.b[ndx], iargs.c[ndx], iargs.d[ndx]);
4063 IRet doApply (const EvalContext& ctx,
4070 ret[ndx] = func.apply(ctx, iargs.a[ndx], iargs.b, iargs.c[ndx], iargs.d[ndx]);
4776 EvalContext ctx (fmt, m_ctx.precision, env);
4777 stmt.execute(ctx);
5214 virtual MovePtr<TestNode> createCase (const Context& ctx) const = 0;
5245 MovePtr<TestNode> createCase (const Context& ctx) const
5247 TestCaseGroup* group = new TestCaseGroup(ctx.testContext,
5248 ctx.name.c_str(), ctx.name.c_str());
5250 group->addChild(createFuncCase(ctx, "scalar", m_funcs.func));
5251 group->addChild(createFuncCase(ctx, "vec2", m_funcs.func2));
5252 group->addChild(createFuncCase(ctx, "vec3", m_funcs.func3));
5253 group->addChild(createFuncCase(ctx, "vec4", m_funcs.func4));
5277 MovePtr<TestNode> createCase (const Context& ctx) const
5279 TestCaseGroup* group = new TestCaseGroup(ctx.testContext,
5280 ctx.name.c_str(), ctx.name.c_str());
5281 group->addChild(createFuncCase(ctx, "scalar", instance<GenF<1> >()));
5282 group->addChild(createFuncCase(ctx, "vec2", instance<GenF<2> >()));
5283 group->addChild(createFuncCase(ctx, "vec3", instance<GenF<3> >()));
5284 group->addChild(createFuncCase(ctx, "vec4", instance<GenF<4> >()));
5296 MovePtr<TestNode> createCase (const Context& ctx) const
5298 TestCaseGroup* group = new TestCaseGroup(ctx.testContext,
5299 ctx.name.c_str(), ctx.name.c_str());
5300 group->addChild(createFuncCase(ctx, "mat2", instance<GenF<2> >()));
5303 group->addChild(createFuncCase(ctx, "mat3", instance<GenF<3> >()));
5304 group->addChild(createFuncCase(ctx, "mat4", instance<GenF<4> >()));
5317 MovePtr<TestNode> createCase (const Context& ctx) const
5319 TestCaseGroup* const group = new TestCaseGroup(ctx.testContext,
5320 ctx.name.c_str(), ctx.name.c_str());
5322 this->addCase<2, 2>(ctx, group);
5323 this->addCase<3, 2>(ctx, group);
5324 this->addCase<4, 2>(ctx, group);
5325 this->addCase<2, 3>(ctx, group);
5326 this->addCase<3, 3>(ctx, group);
5327 this->addCase<4, 3>(ctx, group);
5328 this->addCase<2, 4>(ctx, group);
5329 this->addCase<3, 4>(ctx, group);
5330 this->addCase<4, 4>(ctx, group);
5339 void addCase (const Context& ctx, TestCaseGroup* group) const
5343 group->addChild(createFuncCase(ctx, name, instance<GenF<Rows, Cols> >()));
5353 MovePtr<TestNode> createCase (const Context& ctx) const
5355 return MovePtr<TestNode>(createFuncCase(ctx, ctx.name.c_str(), m_func));
5517 TestCaseGroup* createFuncGroup (const PrecisionTestContext& ctx,
5520 TestCaseGroup* const group = new TestCaseGroup(ctx.testCtx,
5528 const FloatFormat& fmt = *de::getSizedArrayElement<glu::PRECISION_LAST>(ctx.formats, precNdx);
5529 const FloatFormat& highpFmt = *de::getSizedArrayElement<glu::PRECISION_LAST>(ctx.formats,
5532 for (size_t shaderNdx = 0; shaderNdx < ctx.shaderTypes.size(); ++shaderNdx)
5534 const ShaderType shaderType = ctx.shaderTypes[shaderNdx];
5537 const Context caseCtx (name, ctx.testCtx, ctx.renderCtx, fmt, highpFmt,
5538 precision, shaderType, ctx.numRandoms);
5565 const PrecisionTestContext ctx (testCtx, renderCtx, highp, mediump, lowp,
5569 dstGroup.addChild(createFuncGroup(ctx, *cases.getFactories()[ndx]));