framework/randomshaders/rsgBinaryOps.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Random Shader Generator
   3  * ----------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Binary ops.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "rsgBinaryOps.hpp"
  25 #include "rsgVariableManager.hpp"
  26 #include "rsgUtils.hpp"
  27 #include "deMath.h"
  28
  29 using std::vector;
  30
  31 namespace rsg
  32 {
  33
  34 // CustomAbsOp and CustomBinaryOp are used to resolve float comparision corner case.
  35 // This error happened when two floats with the same value were compared
  36 // without using epsilon. If result of this comparisment influenced the
  37 // output color then result and reference images could differ.
  38 class CustomAbsOp : public Expression
  39 {
  40 public:
  41                                                                 CustomAbsOp             (void);
  42         virtual                                         ~CustomAbsOp    (void);
  43
  44         void                                            setChild                                (Expression* expression);
  45         Expression*                                     createNextChild                 (GeneratorState& state);
  46         void                                            tokenize                                (GeneratorState& state, TokenStream& str) const;
  47
  48         void                                            evaluate                                (ExecutionContext& execCtx);
  49         ExecConstValueAccess            getValue                                (void) const { return m_value.getValue(m_type); }
  50
  51 private:
  52         std::string                                     m_function;
  53         VariableType                            m_type;
  54         ExecValueStorage                        m_value;
  55         Expression*                                     m_child;
  56 };
  57
  58 CustomAbsOp::CustomAbsOp (void)
  59         : m_function            ("abs")
  60         , m_type                        (VariableType::TYPE_FLOAT, 1)
  61         , m_child                       (DE_NULL)
  62 {
  63         m_value.setStorage(m_type);
  64 }
  65
  66 CustomAbsOp::~CustomAbsOp (void)
  67 {
  68         delete m_child;
  69 }
  70
  71 void CustomAbsOp::setChild(Expression* expression)
  72 {
  73         m_child = expression;
  74 }
  75
  76 Expression* CustomAbsOp::createNextChild (GeneratorState&)
  77 {
  78         DE_ASSERT(0);
  79         return DE_NULL;
  80 }
  81
  82 void CustomAbsOp::tokenize (GeneratorState& state, TokenStream& str) const
  83 {
  84         str << Token(m_function.c_str()) << Token::LEFT_PAREN;
  85         m_child->tokenize(state, str);
  86         str << Token::RIGHT_PAREN;
  87 }
  88
  89 void CustomAbsOp::evaluate (ExecutionContext& execCtx)
  90 {
  91         m_child->evaluate(execCtx);
  92
  93         ExecConstValueAccess    srcValue        = m_child->getValue();
  94         ExecValueAccess                 dstValue        = m_value.getValue(m_type);
  95
  96         for (int elemNdx = 0; elemNdx < m_type.getNumElements(); elemNdx++)
  97         {
  98                 ExecConstValueAccess    srcComp         = srcValue.component(elemNdx);
  99                 ExecValueAccess                 dstComp         = dstValue.component(elemNdx);
 100
 101                 for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 102                         dstComp.asFloat(compNdx) = deFloatAbs(srcComp.asFloat(compNdx));
 103         }
 104 }
 105
 106 typedef BinaryOp<5, ASSOCIATIVITY_LEFT> CustomBinaryBase;
 107
 108 // CustomBinaryOp and CustomAbsOp are used to resolve float comparision corner case.
 109 // CustomBinaryOp supports addition and substraction as only those functionalities
 110 // were needed.
 111 template <typename ComputeValue>
 112 class CustomBinaryOp: public CustomBinaryBase
 113 {
 114 public:
 115                                                                 CustomBinaryOp          ();
 116         virtual                                         ~CustomBinaryOp         (void) {}
 117
 118         void                                            setLeftValue            (Expression* expression);
 119         void                                            setRightValue           (Expression* expression);
 120
 121         void                                            evaluate                        (ExecValueAccess dst, ExecConstValueAccess a, ExecConstValueAccess b);
 122 };
 123
 124 template <typename ComputeValue>
 125 CustomBinaryOp<ComputeValue>::CustomBinaryOp ()
 126         : CustomBinaryBase(Token::PLUS)
 127 {
 128         // By default add operation is assumed, for every other operation
 129         // separate constructor specialization should be implemented
 130         m_type = VariableType(VariableType::TYPE_FLOAT, 1);
 131         m_value.setStorage(m_type);
 132 }
 133
 134 template <>
 135 CustomBinaryOp<EvaluateSub>::CustomBinaryOp ()
 136         : CustomBinaryBase(Token::MINUS)
 137 {
 138         // Specialization for substraction
 139         m_type = VariableType(VariableType::TYPE_FLOAT, 1);
 140         m_leftValueRange =      ValueRange(m_type);
 141         m_rightValueRange = ValueRange(m_type);
 142         m_value.setStorage(m_type);
 143 }
 144
 145 template <>
 146 CustomBinaryOp<EvaluateLessThan>::CustomBinaryOp ()
 147         : CustomBinaryBase(Token::CMP_LT)
 148 {
 149         // Specialization for less_then comparision
 150         m_type = VariableType(VariableType::TYPE_BOOL, 1);
 151         VariableType floatType = VariableType(VariableType::TYPE_FLOAT, 1);
 152         m_leftValueRange =      ValueRange(floatType);
 153         m_rightValueRange = ValueRange(floatType);
 154         m_value.setStorage(m_type);
 155 }
 156
 157 template <typename ComputeValue>
 158 void CustomBinaryOp<ComputeValue>::setLeftValue(Expression* expression)
 159 {
 160         m_leftValueExpr = expression;
 161 }
 162
 163 template <typename ComputeValue>
 164 void CustomBinaryOp<ComputeValue>::setRightValue(Expression* expression)
 165 {
 166         m_rightValueExpr = expression;
 167 }
 168
 169 template <typename ComputeValue>
 170 void CustomBinaryOp<ComputeValue>::evaluate(ExecValueAccess dst, ExecConstValueAccess a, ExecConstValueAccess b)
 171 {
 172         DE_ASSERT(dst.getType() == a.getType());
 173         DE_ASSERT(dst.getType() == b.getType());
 174         DE_ASSERT(dst.getType().getBaseType() == VariableType::TYPE_FLOAT);
 175
 176         for (int elemNdx = 0; elemNdx < dst.getType().getNumElements(); elemNdx++)
 177         {
 178                 for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 179                         dst.component(elemNdx).asFloat(compNdx) = ComputeValue()(a.component(elemNdx).asFloat(compNdx),b.component(elemNdx).asFloat(compNdx));
 180         }
 181 }
 182
 183 template <>
 184 void CustomBinaryOp<EvaluateLessThan>::evaluate(ExecValueAccess dst, ExecConstValueAccess a, ExecConstValueAccess b)
 185 {
 186         DE_ASSERT(a.getType() == b.getType());
 187         DE_ASSERT(dst.getType().getBaseType() == VariableType::TYPE_BOOL);
 188
 189         for (int elemNdx = 0; elemNdx < dst.getType().getNumElements(); elemNdx++)
 190         {
 191                 for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 192                         dst.component(elemNdx).asBool(compNdx) = EvaluateLessThan()(a.component(elemNdx).asFloat(compNdx),b.component(elemNdx).asFloat(compNdx));
 193         }
 194 }
 195
 196 template <int Precedence, Associativity Assoc>
 197 BinaryOp<Precedence, Assoc>::BinaryOp (Token::Type operatorToken)
 198         : m_operator            (operatorToken)
 199         , m_leftValueRange      (m_type)
 200         , m_rightValueRange     (m_type)
 201         , m_leftValueExpr       (DE_NULL)
 202         , m_rightValueExpr      (DE_NULL)
 203 {
 204 }
 205
 206 template <int Precedence, Associativity Assoc>
 207 BinaryOp<Precedence, Assoc>::~BinaryOp (void)
 208 {
 209         delete m_leftValueExpr;
 210         delete m_rightValueExpr;
 211 }
 212
 213 template <int Precedence, Associativity Assoc>
 214 Expression* BinaryOp<Precedence, Assoc>::createNextChild (GeneratorState& state)
 215 {
 216         int leftPrec    = Assoc == ASSOCIATIVITY_LEFT ? Precedence : Precedence-1;
 217         int rightPrec   = Assoc == ASSOCIATIVITY_LEFT ? Precedence-1 : Precedence;
 218
 219         if (m_rightValueExpr == DE_NULL)
 220         {
 221                 state.pushPrecedence(rightPrec);
 222                 m_rightValueExpr = Expression::createRandom(state, m_rightValueRange.asAccess());
 223                 state.popPrecedence();
 224                 return m_rightValueExpr;
 225         }
 226         else if (m_leftValueExpr == DE_NULL)
 227         {
 228                 state.pushPrecedence(leftPrec);
 229                 m_leftValueExpr = Expression::createRandom(state, m_leftValueRange.asAccess());
 230                 state.popPrecedence();
 231                 return m_leftValueExpr;
 232         }
 233         else
 234         {
 235                 // Check for corrner cases
 236                 switch (m_operator)
 237                 {
 238                 case Token::CMP_LE:
 239                 {
 240                         // When comparing two floats epsilon should be included
 241                         // to eliminate the risk that we get different results
 242                         // because of precission error
 243                         VariableType floatType(VariableType::TYPE_FLOAT, 1);
 244                         if (m_rightValueRange.getType() == floatType)
 245                         {
 246                                 FloatLiteral* epsilonLiteral = new FloatLiteral(0.001f);
 247
 248                                 typedef CustomBinaryOp<EvaluateAdd> CustomAddOp;
 249                                 CustomAddOp* addOperation = new CustomAddOp();
 250                                 addOperation->setLeftValue(m_rightValueExpr);
 251                                 addOperation->setRightValue(epsilonLiteral);
 252
 253                                 // add epsilon to right-hand side
 254                                 m_rightValueExpr = addOperation;
 255                         }
 256                         break;
 257                 }
 258                 case Token::CMP_GE:
 259                 {
 260                         // When comparing two floats epsilon should be included
 261                         // to eliminate the risk that we get different results
 262                         // because of precission error
 263                         VariableType floatType(VariableType::TYPE_FLOAT, 1);
 264                         if (m_leftValueRange.getType() == floatType)
 265                         {
 266                                 FloatLiteral* epsilonLiteral = new FloatLiteral(0.001f);
 267
 268                                 typedef CustomBinaryOp<EvaluateAdd> CustomAddOp;
 269                                 CustomAddOp* addOperation = new CustomAddOp();
 270                                 addOperation->setLeftValue(m_leftValueExpr);
 271                                 addOperation->setRightValue(epsilonLiteral);
 272
 273                                 // add epsilon to left-hand side
 274                                 m_leftValueExpr = addOperation;
 275                         }
 276                         break;
 277                 }
 278                 case Token::CMP_EQ:
 279                 {
 280                         // When comparing two floats epsilon should be included
 281                         // to eliminate the risk that we get different results
 282                         // because of precission error
 283                         VariableType floatType(VariableType::TYPE_FLOAT, 1);
 284                         if (m_leftValueRange.getType() == floatType)
 285                         {
 286                                 VariableType boolType(VariableType::TYPE_BOOL, 1);
 287                                 const ValueRange boolRange(boolType);
 288
 289                                 ParenOp* parenRight = new ParenOp(state, boolRange);
 290                                 parenRight->setChild(m_rightValueExpr);
 291
 292                                 typedef CustomBinaryOp<EvaluateSub> CustomSubOp;
 293                                 CustomSubOp* subOperation = new CustomSubOp();
 294                                 subOperation->setLeftValue(m_leftValueExpr);
 295                                 subOperation->setRightValue(parenRight);
 296
 297                                 CustomAbsOp* absOperation = new CustomAbsOp();
 298                                 absOperation->setChild(subOperation);
 299                                 FloatLiteral* epsilonLiteral = new FloatLiteral(0.001f);
 300
 301                                 typedef CustomBinaryOp<EvaluateLessThan> CustomLessThanOp;
 302                                 CustomLessThanOp* lessOperation = new CustomLessThanOp();
 303                                 lessOperation->setLeftValue(absOperation);
 304                                 lessOperation->setRightValue(epsilonLiteral);
 305
 306                                 ParenOp* parenOperation = new ParenOp(state, boolRange);
 307                                 parenOperation->setChild(lessOperation);
 308                                 BoolLiteral* trueLiteral = new BoolLiteral(true);
 309
 310                                 // EQ operation cant be removed so it is replaced with:
 311                                 // ((abs(lhs-rhs) < epsilon) == true).
 312                                 m_leftValueExpr = parenOperation;
 313                                 m_rightValueExpr = trueLiteral;
 314                         }
 315                         break;
 316                 }
 317                 default:
 318                         break;
 319                 }
 320
 321                 return DE_NULL;
 322         }
 323 }
 324
 325 template <int Precedence, Associativity Assoc>
 326 float BinaryOp<Precedence, Assoc>::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 327 {
 328         if (state.getPrecedence() < Precedence)
 329                 return 0.0f;
 330
 331         int availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
 332
 333         if (valueRange.getType().isVoid())
 334                 return availableLevels >= 2 ? unusedValueWeight : 0.0f;
 335
 336         if (availableLevels < getConservativeValueExprDepth(state, valueRange) + 1)
 337                 return 0.0f;
 338
 339         return 1.0f;
 340 }
 341
 342 template <int Precedence, Associativity Assoc>
 343 void BinaryOp<Precedence, Assoc>::tokenize (GeneratorState& state, TokenStream& str) const
 344 {
 345         m_leftValueExpr->tokenize(state, str);
 346         str << m_operator;
 347         m_rightValueExpr->tokenize(state, str);
 348 }
 349
 350 template <int Precedence, Associativity Assoc>
 351 void BinaryOp<Precedence, Assoc>::evaluate (ExecutionContext& execCtx)
 352 {
 353         m_leftValueExpr->evaluate(execCtx);
 354         m_rightValueExpr->evaluate(execCtx);
 355
 356         ExecConstValueAccess    leftVal         = m_leftValueExpr->getValue();
 357         ExecConstValueAccess    rightVal        = m_rightValueExpr->getValue();
 358         ExecValueAccess                 dst                     = m_value.getValue(m_type);
 359
 360         evaluate(dst, leftVal, rightVal);
 361 }
 362
 363 template <int Precedence, bool Float, bool Int, bool Bool, class ComputeValueRange, class EvaluateComp>
 364 BinaryVecOp<Precedence, Float, Int, Bool, ComputeValueRange, EvaluateComp>::BinaryVecOp (GeneratorState& state, Token::Type operatorToken, ConstValueRangeAccess inValueRange)
 365         : BinaryOp<Precedence, ASSOCIATIVITY_LEFT>(operatorToken)
 366 {
 367         ValueRange valueRange = inValueRange;
 368
 369         if (valueRange.getType().isVoid())
 370         {
 371                 int                                                     availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
 372                 vector<VariableType::Type>      baseTypes;
 373
 374                 if (Float)      baseTypes.push_back(VariableType::TYPE_FLOAT);
 375                 if (Int)        baseTypes.push_back(VariableType::TYPE_INT);
 376                 if (Bool)       baseTypes.push_back(VariableType::TYPE_BOOL);
 377
 378                 VariableType::Type      baseType        = state.getRandom().choose<VariableType::Type>(baseTypes.begin(), baseTypes.end());
 379                 int                                     numElements     = state.getRandom().getInt(1, availableLevels >= 3 ? 4 : 1);
 380
 381                 valueRange = ValueRange(VariableType(baseType, numElements));
 382                 computeRandomValueRange(state, valueRange.asAccess());
 383         }
 384
 385         // Choose type, allocate storage for execution
 386         this->m_type = valueRange.getType();
 387         this->m_value.setStorage(this->m_type);
 388
 389         // Initialize storage for value ranges
 390         this->m_rightValueRange = ValueRange(this->m_type);
 391         this->m_leftValueRange  = ValueRange(this->m_type);
 392
 393         VariableType::Type baseType = this->m_type.getBaseType();
 394
 395         // Compute range for b that satisfies requested value range
 396         for (int elemNdx = 0; elemNdx < this->m_type.getNumElements(); elemNdx++)
 397         {
 398                 ConstValueRangeAccess   dst             = valueRange.asAccess().component(elemNdx);
 399                 ValueRangeAccess                a               = this->m_leftValueRange.asAccess().component(elemNdx); // \todo [2011-03-25 pyry] Commutative: randomize inputs
 400                 ValueRangeAccess                b               = this->m_rightValueRange.asAccess().component(elemNdx);
 401
 402                 // Just pass undefined ranges
 403                 if ((baseType == VariableType::TYPE_FLOAT || baseType == VariableType::TYPE_INT) && isUndefinedValueRange(dst))
 404                 {
 405                         a.getMin() = dst.getMin().value();
 406                         b.getMin() = dst.getMin().value();
 407                         a.getMax() = dst.getMax().value();
 408                         b.getMax() = dst.getMax().value();
 409                         continue;
 410                 }
 411
 412                 if (baseType == VariableType::TYPE_FLOAT)
 413                         ComputeValueRange()(state.getRandom(), dst.getMin().asFloat(), dst.getMax().asFloat(),
 414                                                                 a.getMin().asFloat(), a.getMax().asFloat(),
 415                                                                 b.getMin().asFloat(), b.getMax().asFloat());
 416                 else if (baseType == VariableType::TYPE_INT)
 417                         ComputeValueRange()(state.getRandom(), dst.getMin().asInt(), dst.getMax().asInt(),
 418                                                                 a.getMin().asInt(), a.getMax().asInt(),
 419                                                                 b.getMin().asInt(), b.getMax().asInt());
 420                 else
 421                 {
 422                         DE_ASSERT(baseType == VariableType::TYPE_BOOL);
 423                         ComputeValueRange()(state.getRandom(), dst.getMin().asBool(), dst.getMax().asBool(),
 424                                                                 a.getMin().asBool(), a.getMax().asBool(),
 425                                                                 b.getMin().asBool(), b.getMax().asBool());
 426                 }
 427         }
 428 }
 429
 430 template <int Precedence, bool Float, bool Int, bool Bool, class ComputeValueRange, class EvaluateComp>
 431 BinaryVecOp<Precedence, Float, Int, Bool, ComputeValueRange, EvaluateComp>::~BinaryVecOp (void)
 432 {
 433 }
 434
 435 template <int Precedence, bool Float, bool Int, bool Bool, class ComputeValueRange, class EvaluateComp>
 436 void BinaryVecOp<Precedence, Float, Int, Bool, ComputeValueRange, EvaluateComp>::evaluate (ExecValueAccess dst, ExecConstValueAccess a, ExecConstValueAccess b)
 437 {
 438         DE_ASSERT(dst.getType() == a.getType());
 439         DE_ASSERT(dst.getType() == b.getType());
 440         switch (dst.getType().getBaseType())
 441         {
 442                 case VariableType::TYPE_FLOAT:
 443                         for (int elemNdx = 0; elemNdx < dst.getType().getNumElements(); elemNdx++)
 444                         {
 445                                 for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 446                                         dst.component(elemNdx).asFloat(compNdx) = EvaluateComp()(a.component(elemNdx).asFloat(compNdx), b.component(elemNdx).asFloat(compNdx));
 447                         }
 448                         break;
 449
 450                 case VariableType::TYPE_INT:
 451                         for (int elemNdx = 0; elemNdx < dst.getType().getNumElements(); elemNdx++)
 452                         {
 453                                 for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 454                                         dst.component(elemNdx).asInt(compNdx) = EvaluateComp()(a.component(elemNdx).asInt(compNdx), b.component(elemNdx).asInt(compNdx));
 455                         }
 456                         break;
 457
 458                 default:
 459                         DE_ASSERT(DE_FALSE); // Invalid type for multiplication
 460         }
 461 }
 462
 463 void ComputeMulRange::operator() (de::Random& rnd, float dstMin, float dstMax, float& aMin, float& aMax, float& bMin, float& bMax) const
 464 {
 465         const float minScale     = 0.25f;
 466         const float maxScale     = 2.0f;
 467         const float subRangeStep = 0.25f;
 468         const float scaleStep    = 0.25f;
 469
 470         float scale             = getQuantizedFloat(rnd, minScale, maxScale, scaleStep);
 471         float scaledMin = dstMin/scale;
 472         float scaledMax = dstMax/scale;
 473
 474         // Quantize scaled value range if possible
 475         if (!quantizeFloatRange(scaledMin, scaledMax))
 476         {
 477                 // Fall back to 1.0 as a scale
 478                 scale           = 1.0f;
 479                 scaledMin       = dstMin;
 480                 scaledMax       = dstMax;
 481         }
 482
 483         float subRangeLen = getQuantizedFloat(rnd, 0.0f, scaledMax-scaledMin, subRangeStep);
 484         aMin = scaledMin + getQuantizedFloat(rnd, 0.0f, (scaledMax-scaledMin)-subRangeLen, subRangeStep);
 485         aMax = aMin + subRangeLen;
 486
 487         // Find scale range
 488         bMin = scale;
 489         bMax = scale;
 490         for (int i = 0; i < 5; i++)
 491         {
 492                 if (de::inBounds(aMin*(scale-(float)i*scaleStep), dstMin, dstMax) &&
 493                         de::inBounds(aMax*(scale-(float)i*scaleStep), dstMin, dstMax))
 494                         bMin = scale-(float)i*scaleStep;
 495
 496                 if (de::inBounds(aMin*(scale+(float)i*scaleStep), dstMin, dstMax) &&
 497                         de::inBounds(aMax*(scale+(float)i*scaleStep), dstMin, dstMax))
 498                         bMax = scale+(float)i*scaleStep;
 499         }
 500
 501         // Negative scale?
 502         if (rnd.getBool())
 503         {
 504                 std::swap(aMin, aMax);
 505                 std::swap(bMin, bMax);
 506                 aMin    *= -1.0f;
 507                 aMax    *= -1.0f;
 508                 bMin    *= -1.0f;
 509                 bMax    *= -1.0f;
 510         }
 511
 512 #if defined(DE_DEBUG)
 513         const float eps = 0.001f;
 514         DE_ASSERT(aMin <= aMax && bMin <= bMax);
 515         DE_ASSERT(de::inRange(aMin*bMin, dstMin-eps, dstMax+eps));
 516         DE_ASSERT(de::inRange(aMin*bMax, dstMin-eps, dstMax+eps));
 517         DE_ASSERT(de::inRange(aMax*bMin, dstMin-eps, dstMax+eps));
 518         DE_ASSERT(de::inRange(aMax*bMax, dstMin-eps, dstMax+eps));
 519 #endif
 520 }
 521
 522 void ComputeMulRange::operator() (de::Random& rnd, int dstMin, int dstMax, int& aMin, int& aMax, int& bMin, int& bMax) const
 523 {
 524         DE_UNREF(rnd);
 525         aMin    = dstMin;
 526         aMax    = dstMax;
 527         bMin    = 1;
 528         bMax    = 1;
 529 }
 530
 531 MulOp::MulOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 532         : MulBase(state, Token::MUL, valueRange)
 533 {
 534 }
 535
 536 float MulOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 537 {
 538         if (valueRange.getType().isVoid() ||
 539                 valueRange.getType().isFloatOrVec() ||
 540                 valueRange.getType().isIntOrVec())
 541                 return MulBase::getWeight(state, valueRange);
 542         else
 543                 return 0.0f;
 544 }
 545
 546 template <typename T>
 547 void ComputeAddRange::operator() (de::Random& random, T dstMin, T dstMax, T& aMin, T& aMax, T& bMin, T& bMax) const
 548 {
 549         struct GetRandom
 550         {
 551                 int             operator() (de::Random& rnd, int min, int max) const            { return rnd.getInt(min, max); }
 552                 float   operator() (de::Random& rnd, float min, float max) const        { return getQuantizedFloat(rnd, min, max, 0.5f); }
 553         };
 554
 555         T rangeLen              = dstMax-dstMin;
 556         T subRangeLen   = GetRandom()(random, T(0), rangeLen);
 557         T aOffset               = GetRandom()(random, T(-8), T(8));
 558
 559         aMin                    = dstMin+aOffset;
 560         aMax                    = aMin+subRangeLen;
 561
 562         bMin                    = -aOffset;
 563         bMax                    = -aOffset+(rangeLen-subRangeLen);
 564
 565 #if defined(DE_DEBUG)
 566         T eps = T(0.001);
 567         DE_ASSERT(aMin <= aMax && bMin <= bMax);
 568         DE_ASSERT(de::inRange(aMin+bMin, dstMin-eps, dstMax+eps));
 569         DE_ASSERT(de::inRange(aMin+bMax, dstMin-eps, dstMax+eps));
 570         DE_ASSERT(de::inRange(aMax+bMin, dstMin-eps, dstMax+eps));
 571         DE_ASSERT(de::inRange(aMax+bMax, dstMin-eps, dstMax+eps));
 572 #endif
 573 }
 574
 575 template <>
 576 void ComputeAddRange::operator()<bool> (de::Random&, bool, bool, bool&, bool&, bool&, bool&) const
 577 {
 578         DE_ASSERT(DE_FALSE);
 579 }
 580
 581 AddOp::AddOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 582         : AddBase(state, Token::PLUS, valueRange)
 583 {
 584 }
 585
 586 float AddOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 587 {
 588         if (valueRange.getType().isVoid() ||
 589                 valueRange.getType().isFloatOrVec() ||
 590                 valueRange.getType().isIntOrVec())
 591                 return AddBase::getWeight(state, valueRange);
 592         else
 593                 return 0.0f;
 594 }
 595
 596 template <typename T>
 597 void ComputeSubRange::operator() (de::Random& random, T dstMin, T dstMax, T& aMin, T& aMax, T& bMin, T& bMax) const
 598 {
 599         struct GetRandom
 600         {
 601                 int             operator() (de::Random& rnd, int min, int max) const            { return rnd.getInt(min, max); }
 602                 float   operator() (de::Random& rnd, float min, float max) const        { return getQuantizedFloat(rnd, min, max, 0.5f); }
 603         };
 604
 605         T rangeLen              = dstMax-dstMin;
 606         T subRangeLen   = GetRandom()(random, T(0), rangeLen);
 607         T aOffset               = GetRandom()(random, T(-8), T(8));
 608
 609         aMin                    = dstMin+aOffset;
 610         aMax                    = aMin+subRangeLen;
 611
 612         bMin                    = aOffset-(rangeLen-subRangeLen);
 613         bMax                    = aOffset;
 614
 615 #if defined(DE_DEBUG)
 616         T eps = T(0.001);
 617         DE_ASSERT(aMin <= aMax && bMin <= bMax);
 618         DE_ASSERT(de::inRange(aMin-bMin, dstMin-eps, dstMax+eps));
 619         DE_ASSERT(de::inRange(aMin-bMax, dstMin-eps, dstMax+eps));
 620         DE_ASSERT(de::inRange(aMax-bMin, dstMin-eps, dstMax+eps));
 621         DE_ASSERT(de::inRange(aMax-bMax, dstMin-eps, dstMax+eps));
 622 #endif
 623 }
 624
 625 template <>
 626 void ComputeSubRange::operator()<bool> (de::Random&, bool, bool, bool&, bool&, bool&, bool&) const
 627 {
 628         DE_ASSERT(DE_FALSE);
 629 }
 630
 631 SubOp::SubOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 632         : SubBase(state, Token::MINUS, valueRange)
 633 {
 634 }
 635
 636 float SubOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 637 {
 638         if (valueRange.getType().isVoid() ||
 639                 valueRange.getType().isFloatOrVec() ||
 640                 valueRange.getType().isIntOrVec())
 641                 return SubBase::getWeight(state, valueRange);
 642         else
 643                 return 0.0f;
 644 }
 645
 646 template <class ComputeValueRange, class EvaluateComp>
 647 RelationalOp<ComputeValueRange, EvaluateComp>::RelationalOp (GeneratorState& state, Token::Type operatorToken, ConstValueRangeAccess inValueRange)
 648         : BinaryOp<7, ASSOCIATIVITY_LEFT>(operatorToken)
 649 {
 650         ValueRange valueRange = inValueRange;
 651
 652         if (valueRange.getType().isVoid())
 653         {
 654                 valueRange = ValueRange(VariableType(VariableType::TYPE_BOOL, 1));
 655                 computeRandomValueRange(state, valueRange.asAccess());
 656         }
 657
 658         // Choose type, allocate storage for execution
 659         this->m_type = valueRange.getType();
 660         this->m_value.setStorage(this->m_type);
 661
 662         // Choose random input type
 663         VariableType::Type inBaseTypes[]        = { VariableType::TYPE_FLOAT, VariableType::TYPE_INT };
 664         VariableType::Type inBaseType           = state.getRandom().choose<VariableType::Type>(&inBaseTypes[0], &inBaseTypes[DE_LENGTH_OF_ARRAY(inBaseTypes)]);
 665
 666         // Initialize storage for input value ranges
 667         this->m_rightValueRange = ValueRange(VariableType(inBaseType, 1));
 668         this->m_leftValueRange  = ValueRange(VariableType(inBaseType, 1));
 669
 670         // Compute range for b that satisfies requested value range
 671         {
 672                 bool                                    dstMin  = valueRange.getMin().asBool();
 673                 bool                                    dstMax  = valueRange.getMax().asBool();
 674                 ValueRangeAccess                a               = this->m_leftValueRange.asAccess();
 675                 ValueRangeAccess                b               = this->m_rightValueRange.asAccess();
 676
 677                 if (inBaseType == VariableType::TYPE_FLOAT)
 678                         ComputeValueRange()(state.getRandom(), dstMin, dstMax,
 679                                                                 a.getMin().asFloat(), a.getMax().asFloat(),
 680                                                                 b.getMin().asFloat(), b.getMax().asFloat());
 681                 else if (inBaseType == VariableType::TYPE_INT)
 682                         ComputeValueRange()(state.getRandom(), dstMin, dstMax,
 683                                                                 a.getMin().asInt(), a.getMax().asInt(),
 684                                                                 b.getMin().asInt(), b.getMax().asInt());
 685         }
 686 }
 687
 688 template <class ComputeValueRange, class EvaluateComp>
 689 RelationalOp<ComputeValueRange, EvaluateComp>::~RelationalOp (void)
 690 {
 691 }
 692
 693 template <class ComputeValueRange, class EvaluateComp>
 694 void RelationalOp<ComputeValueRange, EvaluateComp>::evaluate (ExecValueAccess dst, ExecConstValueAccess a, ExecConstValueAccess b)
 695 {
 696         DE_ASSERT(a.getType() == b.getType());
 697         switch (a.getType().getBaseType())
 698         {
 699                 case VariableType::TYPE_FLOAT:
 700                         for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 701                                 dst.asBool(compNdx) = EvaluateComp()(a.asFloat(compNdx), b.asFloat(compNdx));
 702                         break;
 703
 704                 case VariableType::TYPE_INT:
 705                         for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 706                                 dst.asBool(compNdx) = EvaluateComp()(a.asInt(compNdx), b.asInt(compNdx));
 707                         break;
 708
 709                 default:
 710                         DE_ASSERT(DE_FALSE);
 711         }
 712 }
 713
 714 template <class ComputeValueRange, class EvaluateComp>
 715 float RelationalOp<ComputeValueRange, EvaluateComp>::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 716 {
 717         if (!state.getProgramParameters().useComparisonOps)
 718                 return 0.0f;
 719
 720         if (valueRange.getType().isVoid() ||
 721                 (valueRange.getType().getBaseType() == VariableType::TYPE_BOOL && valueRange.getType().getNumElements() == 1))
 722                 return BinaryOp<7, ASSOCIATIVITY_LEFT>::getWeight(state, valueRange);
 723         else
 724                 return 0.0f;
 725 }
 726
 727 namespace
 728 {
 729
 730 template <typename T>   T               getStep (void);
 731 template <> inline              float   getStep (void) { return 0.25f;  }
 732 template <> inline              int             getStep (void) { return 1;              }
 733
 734 } // anonymous
 735
 736 template <typename T>
 737 void ComputeLessThanRange::operator () (de::Random& rnd, bool dstMin, bool dstMax, T& aMin, T& aMax, T& bMin, T& bMax) const
 738 {
 739         struct GetRandom
 740         {
 741                 int             operator() (de::Random& random, int min, int max) const         { return random.getInt(min, max); }
 742                 float   operator() (de::Random& random, float min, float max) const     { return getQuantizedFloat(random, min, max, getStep<float>()); }
 743         };
 744
 745         // One random range
 746         T       rLen    = GetRandom()(rnd, T(0), T(8));
 747         T       rMin    = GetRandom()(rnd, T(-4), T(4));
 748         T       rMax    = rMin+rLen;
 749
 750         if (dstMin == false && dstMax == true)
 751         {
 752                 // Both values are possible, use same range for both inputs
 753                 aMin    = rMin;
 754                 aMax    = rMax;
 755                 bMin    = rMin;
 756                 bMax    = rMax;
 757         }
 758         else if (dstMin == true && dstMax == true)
 759         {
 760                 // Compute range that is less than rMin..rMax
 761                 T aLen = GetRandom()(rnd, T(0), T(8)-rLen);
 762
 763                 aMax    = rMin - getStep<T>();
 764                 aMin    = aMax - aLen;
 765
 766                 bMin    = rMin;
 767                 bMax    = rMax;
 768         }
 769         else
 770         {
 771                 // Compute range that is greater than or equal to rMin..rMax
 772                 T aLen = GetRandom()(rnd, T(0), T(8)-rLen);
 773
 774                 aMin    = rMax;
 775                 aMax    = aMin + aLen;
 776
 777                 bMin    = rMin;
 778                 bMax    = rMax;
 779         }
 780 }
 781
 782 LessThanOp::LessThanOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 783         : LessThanBase(state, Token::CMP_LT, valueRange)
 784 {
 785 }
 786
 787 float LessThanOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 788 {
 789         return LessThanBase::getWeight(state, valueRange);
 790 }
 791
 792 template <typename T>
 793 void ComputeLessOrEqualRange::operator () (de::Random& rnd, bool dstMin, bool dstMax, T& aMin, T& aMax, T& bMin, T& bMax) const
 794 {
 795         struct GetRandom
 796         {
 797                 int             operator() (de::Random& random, int min, int max) const         { return random.getInt(min, max); }
 798                 float   operator() (de::Random& random, float min, float max) const     { return getQuantizedFloat(random, min, max, getStep<float>()); }
 799         };
 800
 801         // One random range
 802         T       rLen    = GetRandom()(rnd, T(0), T(8));
 803         T       rMin    = GetRandom()(rnd, T(-4), T(4));
 804         T       rMax    = rMin+rLen;
 805
 806         if (dstMin == false && dstMax == true)
 807         {
 808                 // Both values are possible, use same range for both inputs
 809                 aMin    = rMin;
 810                 aMax    = rMax;
 811                 bMin    = rMin;
 812                 bMax    = rMax;
 813         }
 814         else if (dstMin == true && dstMax == true)
 815         {
 816                 // Compute range that is less than or equal to rMin..rMax
 817                 T aLen = GetRandom()(rnd, T(0), T(8)-rLen);
 818
 819                 aMax    = rMin;
 820                 aMin    = aMax - aLen;
 821
 822                 bMin    = rMin;
 823                 bMax    = rMax;
 824         }
 825         else
 826         {
 827                 // Compute range that is greater than rMin..rMax
 828                 T aLen = GetRandom()(rnd, T(0), T(8)-rLen);
 829
 830                 aMin    = rMax + getStep<T>();
 831                 aMax    = aMin + aLen;
 832
 833                 bMin    = rMin;
 834                 bMax    = rMax;
 835         }
 836 }
 837
 838 LessOrEqualOp::LessOrEqualOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 839         : LessOrEqualBase(state, Token::CMP_LE, valueRange)
 840 {
 841 }
 842
 843 float LessOrEqualOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 844 {
 845         return LessOrEqualBase::getWeight(state, valueRange);
 846 }
 847
 848 GreaterThanOp::GreaterThanOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 849         : GreaterThanBase(state, Token::CMP_GT, valueRange)
 850 {
 851 }
 852
 853 float GreaterThanOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 854 {
 855         return GreaterThanBase::getWeight(state, valueRange);
 856 }
 857
 858 GreaterOrEqualOp::GreaterOrEqualOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 859         : GreaterOrEqualBase(state, Token::CMP_GE, valueRange)
 860 {
 861 }
 862
 863 float GreaterOrEqualOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 864 {
 865         return GreaterOrEqualBase::getWeight(state, valueRange);
 866 }
 867
 868 namespace
 869 {
 870
 871 template <bool IsEqual, typename T>
 872 void computeEqualityValueRange (de::Random& rnd, bool dstMin, bool dstMax, T& aMin, T& aMax, T& bMin, T& bMax)
 873 {
 874         if (dstMin == false && dstMax == true)
 875                 ComputeLessThanRange()(rnd, false, true, aMin, aMax, bMin, bMax);
 876         else if (IsEqual && dstMin == false)
 877                 ComputeLessThanRange()(rnd, true, true, aMin, aMax, bMin, bMax);
 878         else if (!IsEqual && dstMin == true)
 879                 ComputeLessThanRange()(rnd, true, true, aMin, aMax, bMin, bMax);
 880         else
 881         {
 882                 // Must have exactly same values.
 883                 struct GetRandom
 884                 {
 885                         int             operator() (de::Random& random, int min, int max) const         { return random.getInt(min, max); }
 886                         float   operator() (de::Random& random, float min, float max) const     { return getQuantizedFloat(random, min, max, 0.5f); }
 887                 };
 888
 889                 T val = GetRandom()(rnd, T(-1), T(1));
 890
 891                 aMin    = val;
 892                 aMax    = val;
 893                 bMin    = val;
 894                 bMax    = val;
 895         }
 896 }
 897
 898 template <>
 899 void computeEqualityValueRange<true, bool> (de::Random& rnd, bool dstMin, bool dstMax, bool& aMin, bool& aMax, bool& bMin, bool& bMax)
 900 {
 901         if (dstMin == false && dstMax == true)
 902         {
 903                 aMin    = false;
 904                 aMax    = true;
 905                 bMin    = false;
 906                 bMax    = true;
 907         }
 908         else if (dstMin == false)
 909         {
 910                 DE_ASSERT(dstMax == false);
 911                 bool val = rnd.getBool();
 912
 913                 aMin    = val;
 914                 aMax    = val;
 915                 bMin    = !val;
 916                 bMax    = !val;
 917         }
 918         else
 919         {
 920                 DE_ASSERT(dstMin == true && dstMax == true);
 921                 bool val = rnd.getBool();
 922
 923                 aMin    = val;
 924                 aMax    = val;
 925                 bMin    = val;
 926                 bMax    = val;
 927         }
 928 }
 929
 930 template <>
 931 void computeEqualityValueRange<false, bool> (de::Random& rnd, bool dstMin, bool dstMax, bool& aMin, bool& aMax, bool& bMin, bool& bMax)
 932 {
 933         if (dstMin == false && dstMax == true)
 934                 computeEqualityValueRange<true>(rnd, dstMin, dstMax, aMin, aMax, bMin, bMax);
 935         else
 936                 computeEqualityValueRange<true>(rnd, !dstMin, !dstMax, aMin, aMax, bMin, bMax);
 937 }
 938
 939 } // anonymous
 940
 941 template <bool IsEqual>
 942 EqualityComparisonOp<IsEqual>::EqualityComparisonOp (GeneratorState& state, ConstValueRangeAccess inValueRange)
 943         : BinaryOp<8, ASSOCIATIVITY_LEFT>(IsEqual ? Token::CMP_EQ : Token::CMP_NE)
 944 {
 945         ValueRange valueRange = inValueRange;
 946
 947         if (valueRange.getType().isVoid())
 948         {
 949                 valueRange = ValueRange(VariableType(VariableType::TYPE_BOOL, 1));
 950                 computeRandomValueRange(state, valueRange.asAccess());
 951         }
 952
 953         // Choose type, allocate storage for execution
 954         this->m_type = valueRange.getType();
 955         this->m_value.setStorage(this->m_type);
 956
 957         // Choose random input type
 958         VariableType::Type inBaseTypes[]        = { VariableType::TYPE_FLOAT, VariableType::TYPE_INT };
 959         VariableType::Type inBaseType           = state.getRandom().choose<VariableType::Type>(&inBaseTypes[0], &inBaseTypes[DE_LENGTH_OF_ARRAY(inBaseTypes)]);
 960         int                                     availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
 961         int                                     numElements             = state.getRandom().getInt(1, availableLevels >= 3 ? 4 : 1);
 962
 963         // Initialize storage for input value ranges
 964         this->m_rightValueRange = ValueRange(VariableType(inBaseType, numElements));
 965         this->m_leftValueRange  = ValueRange(VariableType(inBaseType, numElements));
 966
 967         // Compute range for b that satisfies requested value range
 968         for (int elementNdx = 0; elementNdx < numElements; elementNdx++)
 969         {
 970                 bool                                    dstMin  = valueRange.getMin().asBool();
 971                 bool                                    dstMax  = valueRange.getMax().asBool();
 972
 973                 ValueRangeAccess                a               = this->m_leftValueRange.asAccess().component(elementNdx);
 974                 ValueRangeAccess                b               = this->m_rightValueRange.asAccess().component(elementNdx);
 975
 976                 if (inBaseType == VariableType::TYPE_FLOAT)
 977                         computeEqualityValueRange<IsEqual>(state.getRandom(), dstMin, dstMax,
 978                                                                                            a.getMin().asFloat(), a.getMax().asFloat(),
 979                                                                                            b.getMin().asFloat(), b.getMax().asFloat());
 980                 else if (inBaseType == VariableType::TYPE_INT)
 981                         computeEqualityValueRange<IsEqual>(state.getRandom(), dstMin, dstMax,
 982                                                                                            a.getMin().asInt(), a.getMax().asInt(),
 983                                                                                            b.getMin().asInt(), b.getMax().asInt());
 984                 else
 985                 {
 986                         DE_ASSERT(inBaseType == VariableType::TYPE_BOOL);
 987                         computeEqualityValueRange<IsEqual>(state.getRandom(), dstMin, dstMax,
 988                                                                                            a.getMin().asBool(), a.getMax().asBool(),
 989                                                                                            b.getMin().asBool(), b.getMax().asBool());
 990                 }
 991         }
 992 }
 993
 994 template <bool IsEqual>
 995 float EqualityComparisonOp<IsEqual>::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 996 {
 997         if (!state.getProgramParameters().useComparisonOps)
 998                 return 0.0f;
 999
1000         // \todo [2011-06-13 pyry] Weight down cases that would force constant inputs.
1001
1002         if (valueRange.getType().isVoid() ||
1003                 (valueRange.getType().getBaseType() == VariableType::TYPE_BOOL && valueRange.getType().getNumElements() == 1))
1004                 return BinaryOp<8, ASSOCIATIVITY_LEFT>::getWeight(state, valueRange);
1005         else
1006                 return 0.0f;
1007 }
1008
1009 namespace
1010 {
1011
1012 template <bool IsEqual>
1013 struct EqualityCompare
1014 {
1015         template <typename T>
1016         static bool compare (T a, T b);
1017         static bool combine (bool a, bool b);
1018 };
1019
1020 template <>
1021 template <typename T>
1022 inline bool EqualityCompare<true>::compare      (T a, T b)                      { return a == b; }
1023
1024 template <>
1025 inline bool EqualityCompare<true>::combine      (bool a, bool b)        { return a && b; }
1026
1027 template <>
1028 template <typename T>
1029 inline bool EqualityCompare<false>::compare     (T a, T b)                      { return a != b; }
1030
1031 template <>
1032 inline bool EqualityCompare<false>::combine     (bool a, bool b)        { return a || b; }
1033
1034 } // anonymous
1035
1036 template <bool IsEqual>
1037 void EqualityComparisonOp<IsEqual>::evaluate (ExecValueAccess dst, ExecConstValueAccess a, ExecConstValueAccess b)
1038 {
1039         DE_ASSERT(a.getType() == b.getType());
1040
1041
1042         switch (a.getType().getBaseType())
1043         {
1044                 case VariableType::TYPE_FLOAT:
1045                         for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
1046                         {
1047                                 bool result = IsEqual ? true : false;
1048
1049                                 for (int elemNdx = 0; elemNdx < a.getType().getNumElements(); elemNdx++)
1050                                         result = EqualityCompare<IsEqual>::combine(result, EqualityCompare<IsEqual>::compare(a.component(elemNdx).asFloat(compNdx), b.component(elemNdx).asFloat(compNdx)));
1051
1052                                 dst.asBool(compNdx) = result;
1053                         }
1054                         break;
1055
1056                 case VariableType::TYPE_INT:
1057                         for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
1058                         {
1059                                 bool result = IsEqual ? true : false;
1060
1061                                 for (int elemNdx = 0; elemNdx < a.getType().getNumElements(); elemNdx++)
1062                                         result = EqualityCompare<IsEqual>::combine(result, EqualityCompare<IsEqual>::compare(a.component(elemNdx).asInt(compNdx), b.component(elemNdx).asInt(compNdx)));
1063
1064                                 dst.asBool(compNdx) = result;
1065                         }
1066                         break;
1067
1068                 case VariableType::TYPE_BOOL:
1069                         for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
1070                         {
1071                                 bool result = IsEqual ? true : false;
1072
1073                                 for (int elemNdx = 0; elemNdx < a.getType().getNumElements(); elemNdx++)
1074                                         result = EqualityCompare<IsEqual>::combine(result, EqualityCompare<IsEqual>::compare(a.component(elemNdx).asBool(compNdx), b.component(elemNdx).asBool(compNdx)));
1075
1076                                 dst.asBool(compNdx) = result;
1077                         }
1078                         break;
1079
1080                 default:
1081                         DE_ASSERT(DE_FALSE);
1082         }
1083 }
1084
1085 EqualOp::EqualOp (GeneratorState& state, ConstValueRangeAccess valueRange)
1086         : EqualityComparisonOp<true>(state, valueRange)
1087 {
1088 }
1089
1090 float EqualOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1091 {
1092         return EqualityComparisonOp<true>::getWeight(state, valueRange);
1093 }
1094
1095 NotEqualOp::NotEqualOp (GeneratorState& state, ConstValueRangeAccess valueRange)
1096         : EqualityComparisonOp<false>(state, valueRange)
1097 {
1098 }
1099
1100 float NotEqualOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1101 {
1102         return EqualityComparisonOp<false>::getWeight(state, valueRange);
1103 }
1104
1105 } // rsg