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));
}
