public ILanguageValue Evaluate(GMacValueMultivector value1) { return(ValuePrimitive <MathematicaScalar> .Create( value1.GMacRootAst.ScalarType, value1.SymbolicMultivector.EMagnitude() )); }
public ILanguageValue Evaluate(ValuePrimitive <MathematicaScalar> value1, ValuePrimitive <MathematicaScalar> value2) { return(ValuePrimitive <MathematicaScalar> .Create( value1.ValuePrimitiveType, SymbolicUtils.Constants.Zero )); }
public ILanguageValue Evaluate(GMacValueMultivector value1, ValuePrimitive <MathematicaScalar> value2) { return(GMacValueMultivector.Create( value1.ValueMultivectorType, value1.MultivectorCoefficients * value2.Value )); }
///Translate a constant number (Int32 or Double) private ILanguageExpression translate_Constant_Number(ParseTreeNode node) { var numberText = node.FindTokenAndGetText(); Int32 intNumber; if (Int32.TryParse(numberText, out intNumber)) { return(ValuePrimitive <MathematicaScalar> .Create( GMacRootAst.ScalarType, MathematicaScalar.Create(SymbolicUtils.Cas, intNumber) )); } Double doubleNumber; if (Double.TryParse(numberText, out doubleNumber)) { return(ValuePrimitive <MathematicaScalar> .Create( GMacRootAst.ScalarType, MathematicaScalar.Create(SymbolicUtils.Cas, doubleNumber) )); } return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Constant number not recognized", node)); }
public ILanguageValue Evaluate(ValuePrimitive <MathematicaScalar> value1, ValuePrimitive <MathematicaScalar> value2) { return(ValuePrimitive <MathematicaScalar> .Create( value1.ValuePrimitiveType, value1.Value *value2.Value )); }
private ValuePrimitive <MathematicaScalar> GetRandomValue(ILanguageType valueType) { Expr valueExpr; if (valueType.IsInteger()) { valueExpr = new Expr(_randomSource.Next(1, 10)); } else if (valueType.IsBoolean()) { valueExpr = new Expr(_randomSource.Next(0, 1) != 0); } else if (valueType.IsScalar()) { valueExpr = new Expr(_randomSource.NextDouble() * 10.0 - 5.0); } //value_expr = new Expr(new Expr(ExpressionType.Symbol, "Rational"), _RandomSource.Next(1, 10), _RandomSource.Next(1, 10)); else { throw new InvalidOperationException(); } return (ValuePrimitive <MathematicaScalar> .Create( (TypePrimitive)valueType, MathematicaScalar.Create(SymbolicUtils.Cas, valueExpr) )); }
public ILanguageValue Evaluate(ValuePrimitive <MathematicaScalar> value1, GMacValueMultivector value2) { return(GMacValueMultivector.Create( value2.ValueMultivectorType, value2.SymbolicMultivector * value1.Value )); }
public ILanguageValue Evaluate(GMacValueMultivector value1) { return(ValuePrimitive <MathematicaScalar> .Create( value1.GMacRootAst.ScalarType, value1.SymbolicFrame.Norm2(value1.MultivectorCoefficients) )); }
/// <summary> /// Finds the value of a primitive value access if exists; else returns the default primitive value /// </summary> /// <param name="valueAccess"></param> /// <returns></returns> public ValuePrimitive <MathematicaScalar> ReadRhsPrimitiveValue(LanguageValueAccess valueAccess) { //Try to read the value from the existing table low-level entries var result = ReadRHSPrimitiveValue_ExistingOnly(valueAccess); //If an entry is found just return the value if (ReferenceEquals(result, null) == false) { return(result); } //If an entry is not found create and return a default value if (valueAccess.ExpressionType.IsBoolean()) { ValuePrimitive <MathematicaScalar> .Create( (TypePrimitive)valueAccess.ExpressionType, MathematicaScalar.Create(SymbolicUtils.Cas, "False") ); } return (ValuePrimitive <MathematicaScalar> .Create( (TypePrimitive)valueAccess.ExpressionType, SymbolicUtils.Constants.Zero )); }
public ILanguageValue Evaluate(ValuePrimitive <MathematicaScalar> value1) { return(ValuePrimitive <MathematicaScalar> .Create( value1.ValuePrimitiveType, value1.Value.Abs() )); }
public ILanguageValue Evaluate(ValuePrimitive <int> value1, ValuePrimitive <int> value2) { return(ValuePrimitive <int> .Create( value1.ValuePrimitiveType, value1.Value *value2.Value )); }
public ILanguageValue Evaluate(ValuePrimitive <int> value1) { return(ValuePrimitive <int> .Create( value1.ValuePrimitiveType, Math.Abs(value1.Value) )); }
public ILanguageValue Evaluate(GMacValueMultivector value1) { return(ValuePrimitive <MathematicaScalar> .Create( value1.GMacRootAst.ScalarType, value1.MultivectorCoefficients.EuclideanMagnitude() )); }
/// <summary> /// Set the value associated with a primitive local variable or output parameter's low-level item /// </summary> /// <param name="valueAccess"></param> /// <param name="value"></param> public void WriteLhsPrimitiveValue(LanguageValueAccess valueAccess, ValuePrimitive <MathematicaScalar> value) { //For a local variable define a new low-level temp with the given value (perhaps after sub-expression refactoring) //Note: Before low-level code generation the macro code must be in SSA form if (valueAccess.IsLocalVariable) { DefineTemp(valueAccess, ProcessRhsValue(value)); return; } //For output parameters if (!valueAccess.IsOutputParameter) { throw new InvalidOperationException( "Cannot assign a value to a macro input parameter after its definition"); } var hlName = valueAccess.GetName(); LlDataItem llDataItem; //If the low-level output parameter is not defined it's value is ignored if (_hlDictionary.TryGetValue(hlName, out llDataItem)) { llDataItem.SetAssignedRhsValue(ProcessRhsValue(value), _llVarEvaluationOrder++); } }
public ILanguageValue Evaluate(GMacValueMultivector value1, GMacValueMultivector value2) { var scalar = value1.SymbolicFrame.Sp( value1.MultivectorCoefficients, value2.MultivectorCoefficients ); return(ValuePrimitive <MathematicaScalar> .Create(value1.CoefficientType, scalar[0])); }
public TreeNode Visit(ValuePrimitive <int> value) { var node = new TreeNode("<INT_VALUE> " + value) { Tag = value }; return(node); }
public TreeNode Visit(ValuePrimitive <double> value) { var node = new TreeNode("<DOUBLE_VALUE> " + value) { Tag = value }; return(node); }
public ILanguageValue Evaluate(GMacValueMultivector value1, GMacValueMultivector value2) { var scalar = value1.SymbolicMultivector.ESp(value2.SymbolicMultivector); return(ValuePrimitive <MathematicaScalar> .Create( value1.CoefficientType, scalar[0].ToMathematicaScalar() )); }
public TreeNode Visit(ValuePrimitive <bool> value) { var node = new TreeNode("<BOOL_VALUE> " + value) { Tag = value }; return(node); }
public TreeNode Visit(ValuePrimitive <MathematicaScalar> value) { var node = new TreeNode("<SCALAR_VALUE> " + value) { Tag = value }; return(node); }
internal ValuePrimitive <MathematicaScalar> this[int id] { get { return(ValuePrimitive <MathematicaScalar> .Create(CoefficientType, MultivectorCoefficients[id])); } set { MultivectorCoefficients[id] = value.Value; } }
/// <summary> /// Convert this basis blade into a multivector term value with unity coefficient /// </summary> public AstValueMultivectorTerm ToMultivectorTermValue() { return(new AstValueMultivectorTerm( AssociatedFrame.MultivectorType, BasisBladeId, ValuePrimitive <MathematicaScalar> .Create( AssociatedFrame.GMacRootAst.ScalarType, SymbolicUtils.Constants.One ) )); }
/// <summary> /// Create a symbolic value from this pattern. If the pattern is a constant its internal /// expression is returned, else a symbolic expression with a single variable is created and returned /// </summary> /// <param name="varNameTemplate"></param> /// <returns></returns> public AstValueScalar ToValue(StringSequenceTemplate varNameTemplate) { return (IsConstant ? ConstantValue : new AstValueScalar( ValuePrimitive <MathematicaScalar> .Create( GMacType.AssociatedPrimitiveType, MathematicaScalar.Create(SymbolicUtils.Cas, varNameTemplate.GenerateNextString()) ) )); }
/// <summary> /// Change the assigned value and evaluation order for an output item only /// </summary> /// <param name="assignedValue"></param> /// <param name="evaluationOrder"></param> public void SetAssignedRhsValue(ValuePrimitive <MathematicaScalar> assignedValue, int evaluationOrder) { if (IsOutput) { AssignedRhsValue = assignedValue; EvaluationOrder = evaluationOrder; } else { throw new InvalidOperationException("Only output macro parameters can be assigned value after their creation"); } }
public override ILanguageValue CreateDefaultValue(ILanguageType langType) { if (ReferenceEquals(langType, null)) { throw new ArgumentNullException(); } if (langType.IsSameType(BooleanType)) { return(ValuePrimitive <bool> .Create((TypePrimitive)langType, false)); } if (langType.IsSameType(IntegerType)) { return(ValuePrimitive <int> .Create((TypePrimitive)langType, 0)); } if (langType.IsSameType(ScalarType)) { return(ValuePrimitive <MathematicaScalar> .Create((TypePrimitive)langType, SymbolicUtils.Constants.Zero)); } var typeStructure = langType as GMacStructure; if (typeStructure != null) { var structure = typeStructure; var valueSparse = ValueStructureSparse.Create(structure); //This code is not required for a sparse structure value //foreach (var data_member in structure.DataMembers) // value_sparse[data_member.ObjectName] = this.CreateDefaultValue(data_member.SymbolType); return(valueSparse); } if (!(langType is GMacFrameMultivector)) { throw new InvalidOperationException("GMac type not recognized!"); } var mvType = (GMacFrameMultivector)langType; var value = GMacValueMultivector.CreateZero(mvType); //This code is not required for a sparse multivector value //for (int id = 0; id < mv_type.ParentFrame.GASpaceDimension; id++) // value[id] = SymbolicUtils.Constants.Zero; return(value); }
/// <summary> /// Low level processing requires the use of MathematicaScalar primitive values only. This method preforms /// the required conversion of primitive values of other forms. /// </summary> /// <param name="value"></param> /// <returns></returns> public static ValuePrimitive <MathematicaScalar> ToScalarValue(this ILanguageValuePrimitive value) { var primitive1 = value as ValuePrimitive <MathematicaScalar>; if (primitive1 != null) { return(primitive1); } //Convert into equivalent Mathematica scalar value var primitive2 = value as ValuePrimitive <int>; if (primitive2 != null) { return(ValuePrimitive <MathematicaScalar> .Create( (TypePrimitive)value.ExpressionType, MathematicaScalar.Create(SymbolicUtils.Cas, primitive2.Value) )); } //Convert into equivalent Mathematica scalar value var primitive3 = value as ValuePrimitive <bool>; if (primitive3 != null) { return(ValuePrimitive <MathematicaScalar> .Create( (TypePrimitive)value.ExpressionType, MathematicaScalar.Create(SymbolicUtils.Cas, primitive3.Value ? "True" : "False") )); } //if (value is ValuePrimitive<double>) //{ //return ValuePrimitive<MathematicaScalar>.Create( // (TypePrimitive)value.ExpressionType, // MathematicaScalar.Create(SymbolicUtils.CAS, ((ValuePrimitive<double>)value).Value) // ); //} //if (value is ValuePrimitive<float>) //{ //return ValuePrimitive<MathematicaScalar>.Create( // (TypePrimitive)value.ExpressionType, // MathematicaScalar.Create(SymbolicUtils.CAS, ((ValuePrimitive<float>)value).Value) // ); //} //This should never happen throw new InvalidOperationException(); }
internal ValuePrimitive <MathematicaScalar> this[int id] { get { return(ValuePrimitive <MathematicaScalar> .Create( CoefficientType, SymbolicMultivector[id].ToMathematicaScalar() )); } set { SymbolicMultivector.SetTermCoef(id, value.Value); } }
//Methods for processing high-level RHS expressions into values with suitable composition for low-level code generation #region High-Level Expression Evaluation and Processing Methods /// <summary> /// Evaluate a cast to a scalar value operation /// </summary> /// <param name="expr"></param> /// <returns></returns> private ILanguageValue EvaluateBasicUnaryCastToScalar(BasicUnary expr) { var value1 = expr.Operand.AcceptVisitor(this); if (value1.ExpressionType.IsInteger()) { return(ValuePrimitive <MathematicaScalar> .Create( (TypePrimitive)expr.ExpressionType, ((ValuePrimitive <MathematicaScalar>)value1).Value )); } throw new InvalidOperationException("Invalid cast operation"); }
/// <summary> /// Finds the value of a primitive value access if exists; else returns null /// </summary> /// <param name="valueAccess"></param> /// <returns></returns> private ValuePrimitive <MathematicaScalar> ReadRHSPrimitiveValue_ExistingOnly(LanguageValueAccess valueAccess) { var hlName = valueAccess.GetName(); LlDataItem dataInfo; if (_hlDictionary.TryGetValue(hlName, out dataInfo)) { return(ValuePrimitive <MathematicaScalar> .Create( (TypePrimitive)valueAccess.ExpressionType, dataInfo.RhsUsableSymbolicScalar )); } return(null); }
public ILanguageExpression Generate_SymbolicExpression(MathematicaScalar casExpr, OperandsByName operands) { var exprType = ScalarType; //var expr_type = this.VerifyType_SymbolicExpression(cas_expr, operands) as TypePrimitive; if (operands.OperandsDictionary.Count == 0) { return(ValuePrimitive <MathematicaScalar> .Create(exprType, casExpr)); } var basicExpr = BasicPolyadic.Create(exprType, GMacParametricSymbolicExpression.Create(casExpr)); basicExpr.Operands = operands; return(basicExpr); }