public ILanguageValue Evaluate(GMacValueMultivector value1) { return(ValuePrimitive <MathematicaScalar> .Create( value1.GMacRootAst.ScalarType, value1.SymbolicMultivector.EMagnitude() )); }
public ILanguageValue Evaluate(GMacValueMultivector value1, GMacValueMultivector value2) { return(GMacValueMultivector.Create( value1.ValueMultivectorType, value1.MultivectorCoefficients.EuclideanHip(value2.MultivectorCoefficients) )); }
public ILanguageValue Evaluate(GMacValueMultivector value1) { return(ValuePrimitive <MathematicaScalar> .Create( value1.GMacRootAst.ScalarType, value1.MultivectorCoefficients.EuclideanMagnitude() )); }
/// <summary> /// Evaluate a cast to multivector value operation /// </summary> /// <param name="expr"></param> /// <returns></returns> private ILanguageValue EvaluateBasicUnaryCastToMultivector(BasicUnary expr) { var value1 = expr.Operand.AcceptVisitor(this); var mvType = (GMacFrameMultivector)expr.Operator; if (value1.ExpressionType.IsNumber()) { var scalarValue = ((ValuePrimitive <MathematicaScalar>)value1).Value; return(GMacValueMultivector.Create( mvType, GaSymMultivector.CreateScalar( mvType.ParentFrame.GaSpaceDimension, scalarValue ) )); } if (value1.ExpressionType.IsFrameMultivector() && value1.ExpressionType.GetFrame().VSpaceDimension == mvType.ParentFrame.VSpaceDimension) { var mvValue = (GMacValueMultivector)value1; return(GMacValueMultivector.Create( mvType, GaSymMultivector.CreateCopy(mvValue.SymbolicMultivector) )); } throw new InvalidOperationException("Invalid cast operation"); }
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) )); }
public ILanguageValue Evaluate(GMacValueMultivector value1) { return(GMacValueMultivector.Create( value1.ValueMultivectorType, value1.SymbolicMultivector.GradeInv() )); }
/// <summary> /// Convert this binding pattern into a multivector value /// </summary> /// <param name="basisBladeToVarName"></param> /// <returns></returns> public AstValueMultivector ToValue(Func <AstFrameBasisBlade, string> basisBladeToVarName) { var frameInfo = new AstFrame(BaseFrameMultivector.AssociatedFrameMultivector.ParentFrame); var mv = GaSymMultivector.CreateZero( BaseFrameMultivector.AssociatedFrameMultivector.ParentFrame.GaSpaceDimension ); foreach (var pair in _patternDictionary) { mv.AddFactor( pair.Key, pair.Value.IsConstant ? pair.Value.ConstantSymbolicScalar : MathematicaScalar.Create(SymbolicUtils.Cas, basisBladeToVarName(frameInfo.BasisBlade(pair.Key))) ); } return (new AstValueMultivector( GMacValueMultivector.Create( BaseFrameMultivector.AssociatedFrameMultivector, mv ) )); }
public ILanguageValue Evaluate(GMacValueMultivector value1, ValuePrimitive <MathematicaScalar> value2) { return(GMacValueMultivector.Create( value1.ValueMultivectorType, value1.MultivectorCoefficients * value2.Value )); }
public ILanguageValue Evaluate(GMacValueMultivector value1, GMacValueMultivector value2) { return(GMacValueMultivector.Create( value1.ValueMultivectorType, value1.MultivectorCoefficients.OuterProduct(value2.MultivectorCoefficients) )); }
public void Visit(GMacValueMultivector value) { Log.Append(value.ValueMultivectorType.SymbolAccessName); Log.Append("("); var flag = false; foreach (var pair in value.SymbolicMultivector.NonZeroExprTerms) { if (flag) { Log.Append(", "); } else { flag = true; } Log.Append("#"); Log.Append(value.MultivectorFrame.BasisBladeName(pair.Key)); Log.Append("#"); Log.Append(" = "); Log.Append("'"); Log.Append(pair.Value.ToString()); Log.Append("'"); } Log.Append(")"); }
public ILanguageValue Evaluate(GMacValueMultivector value1, GMacValueMultivector value2) { return(GMacValueMultivector.Create( value1.ValueMultivectorType, value1.SymbolicFrame.Cp[value1.SymbolicMultivector, value2.SymbolicMultivector] )); }
public ILanguageValue Evaluate(GMacValueMultivector value1, GMacValueMultivector value2) { return(GMacValueMultivector.Create( value1.ValueMultivectorType, value1.SymbolicMultivector.Op(value2.SymbolicMultivector) )); }
public void Visit(GMacValueMultivector value) { Log.Append(value.ValueMultivectorType.SymbolAccessName); Log.Append("("); var flag = false; foreach (var pair in value.MultivectorCoefficients) { if (flag) { Log.Append(", "); } else { flag = true; } Log.Append("#"); Log.Append(value.MultivectorFrame.BasisBladeName(pair.Key)); Log.Append("#"); Log.Append(" = "); Log.Append("'"); Log.Append(pair.Value.ExpressionText); Log.Append("'"); } Log.Append(")"); }
public ILanguageValue Evaluate(GMacValueMultivector value1) { return(GMacValueMultivector.Create( value1.ValueMultivectorType, value1.MultivectorCoefficients.CliffConj() )); }
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 ILanguageValue Evaluate(GMacValueMultivector value1, GMacValueMultivector value2) { var scalar = value1.SymbolicMultivector.ESp(value2.SymbolicMultivector); return(ValuePrimitive <MathematicaScalar> .Create( value1.CoefficientType, scalar[0].ToMathematicaScalar() )); }
public ILanguageValue Evaluate(GMacValueMultivector value1, GMacValueMultivector value2) { return(GMacValueMultivector.Create( value1.ValueMultivectorType, value1.SymbolicFrame.Fdp( value1.MultivectorCoefficients, value2.MultivectorCoefficients ) )); }
/// <summary> /// Create the default constant I for this frame (the unit pseudoscalar) /// </summary> /// <returns></returns> public GMacConstant DefineDefaultConstants_I(GMacFrame frame) { var finalExpr = GMacValueMultivector.CreateBasisBlade(frame.MultivectorType, frame.MaxBasisBladeId); var constant = frame.DefineFrameConstant("I", finalExpr); constant.AddCodeLocation(Context.GetCodeLocation(frame.ParseNode)); return(constant); }
/// <summary> /// Evaluate a multivector transform operation /// </summary> /// <param name="expr"></param> /// <returns></returns> private GMacValueMultivector EvaluateBasicUnaryMultivectorTransform(BasicUnary expr) { var value1 = (GMacValueMultivector)expr.Operand.AcceptVisitor(this); var transform = (GMacMultivectorTransform)expr.Operator; return(GMacValueMultivector.Create( transform.TargetFrame.MultivectorType, transform.AssociatedSymbolicTransform[value1.SymbolicMultivector] )); }
internal static SimpleTreeBranchDictionaryByIndex <Expr> ToSimpleExprTree(this GMacValueMultivector value) { var scalarTypeName = value.CoefficientType.SymbolAccessName; var tree = new SimpleTreeBranchDictionaryByIndex <Expr>(); foreach (var pair in value.SymbolicMultivector.NonZeroExprTerms) { tree.Add(pair.Key, "#E" + pair.Key + "#", scalarTypeName, pair.Value); } return(tree); }
/// <summary> /// Convert this basis blade into a multivector value with unity coefficient of its single term /// </summary> /// <returns></returns> public AstValueMultivector ToMultivectorValue() { return(new AstValueMultivector( GMacValueMultivector.Create( AssociatedFrame.MultivectorType, GaSymMultivector.CreateBasisBlade( AssociatedFrame.GaSpaceDimension, BasisBladeId ) ) )); }
public TreeNode Visit(GMacValueMultivector value) { var node = new TreeNode("<MULTIVECTOR_VALUE> " + value.ValueMultivectorType.TypeSignature) { Tag = value }; foreach (var pair in value.SymbolicMultivector.Terms) { node.Nodes.Add(Visit(value.ValueMultivectorType, pair.Key, pair.Value)); } return(node); }
private static ILanguageExpressionAtomic AtomicExpressionToMultivectorAtomicExpression(this CommandBlock commandBlock, GMacFrameMultivector mvType, ILanguageExpressionAtomic oldExpr) { if (oldExpr.ExpressionType.IsSameType(mvType)) { return(oldExpr); } if (!oldExpr.ExpressionType.IsNumber()) { throw new InvalidCastException("Cannot convert atomic expression of type " + oldExpr.ExpressionType.TypeSignature + " to a expression of type " + mvType.TypeSignature); } var valuePrimitive = oldExpr as ValuePrimitive <int>; if (valuePrimitive != null) { return(GMacValueMultivector.CreateScalar( mvType, MathematicaScalar.Create(SymbolicUtils.Cas, valuePrimitive.Value) )); } var primitive = oldExpr as ValuePrimitive <MathematicaScalar>; if (primitive != null) { return(GMacValueMultivector.CreateScalar( mvType, primitive.Value )); } //This should be a value access of type integer or scalar if (!(oldExpr is LanguageValueAccess)) { throw new InvalidCastException( "Cannot convert atomic expression " + oldExpr + " of type " + oldExpr.ExpressionType.TypeSignature + " to a atomic expression of type" + mvType.TypeSignature ); } //Create a cast operation var newRhsExpr = BasicUnary.Create(mvType, mvType, oldExpr); //The new expresssion is not atomic. Create a local variable to hold value and return the local variable //as a direct value access object return(NonAtomicExpressionToValueAccess(commandBlock, newRhsExpr)); }
/// <summary> /// Convert this binding pattern into a multivector value /// </summary> /// <param name="varNameTemplate"></param> /// <returns></returns> public AstValueMultivector ToValue(StringSequenceTemplate varNameTemplate) { var mv = GaMultivector.CreateZero(BaseFrameMultivector.AssociatedFrameMultivector.ParentFrame.GaSpaceDimension); foreach (var pair in _patternDictionary) { mv[pair.Key] = pair.Value.ToMathematicaScalar(varNameTemplate); } return(new AstValueMultivector( GMacValueMultivector.Create( BaseFrameMultivector.AssociatedFrameMultivector, mv ) )); }
/// <summary> /// Set the values associated with a composite multivector local variable or output parameter's low-level items /// </summary> /// <param name="valueAccess"></param> /// <param name="mvValue"></param> public void WriteLhsMultivectorValue(LanguageValueAccess valueAccess, GMacValueMultivector mvValue) { var valueAccessList = valueAccess.ExpandAll(); if (valueAccess.IsLocalVariable) { foreach (var childValueAccess in valueAccessList) { var id = ((ValueAccessStepByKey <int>)childValueAccess.LastAccessStep).AccessKey; if (mvValue.SymbolicMultivector.ContainsBasisBlade(id)) { DefineTemp(childValueAccess, ProcessRhsValue(mvValue[id])); } } return; } if (!valueAccess.IsOutputParameter) { throw new InvalidOperationException( "Cannot assign a value to a macro input parameter after its definition"); } foreach (var childValueAccess in valueAccessList) { var id = ((ValueAccessStepByKey <int>)childValueAccess.LastAccessStep).AccessKey; var hlName = childValueAccess.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(mvValue[id]), _llVarEvaluationOrder++); } } }
/// <summary> /// Construct the composite value of a multivector value access from the table items. /// If no low-level items are found this method returns a zero multivector value /// </summary> /// <param name="valueAccess"></param> /// <returns></returns> public GMacValueMultivector ReadRhsMultivectorValue(LanguageValueAccess valueAccess) { var mv = GMacValueMultivector.CreateZero((GMacFrameMultivector)valueAccess.ExpressionType); var valueAccessList = valueAccess.ExpandAll(); foreach (var childValueAccess in valueAccessList) { var scalarValue = ReadRHSPrimitiveValue_ExistingOnly(childValueAccess); if (ReferenceEquals(scalarValue, null)) { continue; } var id = ((ValueAccessStepByKey <int>)childValueAccess.LastAccessStep).AccessKey; mv.SymbolicMultivector.SetTermCoef(id, scalarValue.Value); } return(mv); }
public ILanguageValue Evaluate(GMacValueMultivector value1) { return(value1); }
internal AstValueMultivector(GMacValueMultivector value) { AssociatedMultivectorValue = value; }
internal static AstValueMultivector ToAstValueMultivector(this GMacValueMultivector expr) { return(new AstValueMultivector(expr)); }