@Override public FloatConstantExpr clone() { return new FloatConstantExpr(value); }
private boolean isFloatValue(Expr expr, List<String> values) { if (!(expr instanceof FloatConstantExpr)) { return false; } return values.contains(((FloatConstantExpr) expr).getValue()); }
private void findFoldFpBinaryOpportunities(IAstNode parent, Expr child, Expr lhs, Expr rhs, BinaryOperator<Float> op) { if (isFpConstant(lhs) && isFpConstant(rhs)) { addReplaceWithExpr(parent, child, new FloatConstantExpr( op.apply(Float.valueOf(((FloatConstantExpr) lhs).getValue()), Float.valueOf(((FloatConstantExpr) rhs).getValue())).toString())); } }
private void findFoldFpScalarVectorBinaryOpportunities(IAstNode parent, Expr child, Expr lhs, Expr rhs, BinaryOperator<Float> op) { if (isFpConstant(lhs) && isFpVectorConstant(rhs)) { final TypeConstructorExpr typeConstructorExpr = (TypeConstructorExpr) rhs; addReplaceWithExpr(parent, child, new TypeConstructorExpr(typeConstructorExpr.getTypename(), typeConstructorExpr.getArgs() .stream() .map(item -> (FloatConstantExpr) item) .map(item -> new FloatConstantExpr(op.apply( Float.valueOf(((FloatConstantExpr) lhs).getValue()), Float.valueOf(item.getValue())).toString())) .collect(Collectors.toList()))); } if (isFpConstant(rhs) && isFpVectorConstant(lhs)) { final TypeConstructorExpr typeConstructorExpr = (TypeConstructorExpr) lhs; addReplaceWithExpr(parent, child, new TypeConstructorExpr(typeConstructorExpr.getTypename(), typeConstructorExpr.getArgs() .stream() .map(item -> (FloatConstantExpr) item) .map(item -> new FloatConstantExpr(op.apply( Float.valueOf(item.getValue()), Float.valueOf(((FloatConstantExpr) rhs).getValue())).toString())) .collect(Collectors.toList()))); } }
private Expr makeZeroFloat() { return new FloatConstantExpr("0.0"); }
@Override public void visitFloatConstantExpr(FloatConstantExpr floatConstantExpr) { out.append(floatConstantExpr.getValue()); }
private Expr makeOneFloat() { return new FloatConstantExpr("1.0"); }
@Override public void visitFloatConstantExpr(FloatConstantExpr floatConstantExpr) { if (!literalToUniformIndex.containsKey(floatConstantExpr.getValue())) { literalToUniformIndex.put(floatConstantExpr.getValue(), uniformIndex); uniformIndex++; } parentMap.getParent(floatConstantExpr).replaceChild(floatConstantExpr, new ArrayIndexExpr(new VariableIdentifierExpr(Constants.FLOAT_CONST), new IntConstantExpr(Integer.toString( literalToUniformIndex.get(floatConstantExpr.getValue()))))); }
public static Expr getBasicTypeLiteralExpr(BasicType baseType, List<Number> args) { List<Expr> argExprs; if (baseType.getElementType() == BasicType.FLOAT) { argExprs = args.stream().map(item -> new FloatConstantExpr(item.toString())) .collect(Collectors.toList()); } else if (baseType.getElementType() == BasicType.UINT) { argExprs = args.stream().map(item -> new UIntConstantExpr(item.toString() + "u")) .collect(Collectors.toList()); } else { argExprs = args.stream().map(item -> new IntConstantExpr(item.toString())) .collect(Collectors.toList()); } if (argExprs.size() == 1) { return argExprs.get(0); } return new TypeConstructorExpr(baseType.toString(), argExprs); }
private FloatConstantExpr randomFloatLiteral(IRandom generator) { final int maxDigitsEitherSide = 5; StringBuilder sb = new StringBuilder(); sb.append(generator.nextBoolean() ? "-" : ""); int digitsBefore = Math.max(1, generator.nextInt(maxDigitsEitherSide)); for (int i = 0; i < digitsBefore; i++) { int candidate; while (true) { candidate = generator.nextInt(10); if (candidate == 0 && i == 0 && digitsBefore > 1) { continue; } break; } sb.append(String.valueOf(candidate)); } sb.append("."); for (int i = 0; i < digitsBefore; i++) { sb.append(String.valueOf(generator.nextInt(10))); } return new FloatConstantExpr(sb.toString()); }
@Override public Expr getCanonicalConstant() { if (this == FLOAT) { return new FloatConstantExpr("1.0"); } if (this == INT) { return new IntConstantExpr("1"); } if (this == UINT) { return new UIntConstantExpr("1u"); } if (this == BOOL) { return BoolConstantExpr.TRUE; } return new TypeConstructorExpr(toString().toString(), getElementType().getCanonicalConstant()); }
private Expr makeRegularIntegerValuedLiteral(BasicType type, String integerPart) { assert type.getElementType() != BasicType.BOOL; if (type == BasicType.FLOAT) { return new FloatConstantExpr(integerPart + ".0"); } if (type == BasicType.INT) { return new IntConstantExpr(integerPart); } if (type == BasicType.UINT) { return new UIntConstantExpr(integerPart + "u"); } List<Expr> args = new ArrayList<>(); for (int i = 0; i < type.getNumElements(); i++) { assert type.getElementType() != type; args.add(makeRegularIntegerValuedLiteral(type.getElementType(), integerPart)); } return new TypeConstructorExpr(type.toString(), args); }
@Override public Expr visitPrimary_expression(Primary_expressionContext ctx) { if (ctx.variable_identifier() != null) { return new VariableIdentifierExpr(ctx.variable_identifier().getText()); } if (ctx.INTCONSTANT() != null) { return new IntConstantExpr(ctx.INTCONSTANT().getText()); } if (ctx.UINTCONSTANT() != null) { return new UIntConstantExpr(ctx.UINTCONSTANT().getText()); } if (ctx.FLOATCONSTANT() != null) { return new FloatConstantExpr(ctx.FLOATCONSTANT().getText()); } if (ctx.BOOLCONSTANT() != null) { if (ctx.BOOLCONSTANT().getText().equals("true")) { return BoolConstantExpr.TRUE; } assert (ctx.BOOLCONSTANT().getText().equals("false")); return BoolConstantExpr.FALSE; } assert ctx.LPAREN() != null; return new ParenExpr(visitExpression(ctx.expression())); }