/// <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 override IGaSymMultivectorTemp MapToTemp(GaSymMultivector mv1)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension)
{
throw new GMacSymbolicException("Multivector size mismatch");
}
var tempMultivector = GaSymMultivector.CreateZeroTemp(TargetGaSpaceDimension);
foreach (var term1 in mv1.NonZeroExprTerms)
{
var id1 = term1.Key;
var coef1 = term1.Value;
IGaSymMultivector basisBladeMv;
_basisBladeMaps.TryGetValue(id1, out basisBladeMv);
if (ReferenceEquals(basisBladeMv, null))
{
continue;
}
foreach (var basisBladeMvTerm in basisBladeMv.NonZeroExprTerms)
{
tempMultivector.AddFactor(
basisBladeMvTerm.Key,
Mfs.Times[basisBladeMvTerm.Value, coef1]
);
}
}
return(tempMultivector);
}
public static IGaSymMultivectorTemp MapToTemp(this ISymbolicMatrix mappingMatrix, GaSymMultivector mv1)
{
if (mv1.GaSpaceDimension != mappingMatrix.ColumnCount)
{
throw new GMacSymbolicException("Multivector size mismatch");
}
var tempMv = GaSymMultivector.CreateZeroTemp(mappingMatrix.RowCount);
foreach (var term in mv1.NonZeroExprTerms)
{
var id = term.Key;
var coef = term.Value;
for (var row = 0; row < mappingMatrix.RowCount; row++)
{
tempMv.AddFactor(
id,
Mfs.Times[coef, mappingMatrix[row, id].Expression]
);
}
}
return(tempMv);
}
/// <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 GaSymMultivector GetSymIntegerBlade(int gaSpaceDim, int grade)
{
var vSpaceDim = gaSpaceDim.ToVSpaceDimension();
if (grade < 0 || grade > vSpaceDim)
{
return(GaSymMultivector.CreateZero(gaSpaceDim));
}
if (grade <= 1 || grade >= vSpaceDim - 1)
{
return(GetSymIntegerKVector(gaSpaceDim, grade));
}
var mv = GetSymIntegerVector(gaSpaceDim);
grade--;
while (grade > 0)
{
var v = GetSymIntegerVector(gaSpaceDim);
var mv1 = mv.Op(v);
if (mv1.IsZero())
{
continue;
}
mv = mv1;
grade--;
}
return(mv);
}
internal static GaTreeMultivector Gp(this IReadOnlyList <MathematicaScalar> metricScalarsList, GaTreeMultivector mv1, GaTreeMultivector mv2)
{
if (mv1.GaSpaceDimension != mv2.GaSpaceDimension)
{
throw new GMacSymbolicException("Multivector size mismatch");
}
var resultMv = GaSymMultivector.CreateZeroTemp(mv1.GaSpaceDimension);
var indexList = Enumerable.Range(0, mv1.GaSpaceDimension).Reverse().ToList();
for (var k = 0; k < mv1.GaSpaceDimension; k++)
{
var coefId = k.ReverseBits(mv1.VSpaceDimension);
var signList = GpSign(mv1.VSpaceDimension, coefId);
foreach (var index in indexList)
{
var id1 = index.ReverseBits(mv1.VSpaceDimension);
var id2 = id1 ^ coefId;
resultMv.AddFactor(
coefId,
signList[mv1.GaSpaceDimension - index - 1],
Mfs.Times[metricScalarsList[id1 & id2].Expression, mv1[id1], mv2[id2]]
);
}
}
return(resultMv.ToTreeMultivector());
}
public IEnumerable <GaSymMultivector> GetSymIntegerLidVectors(int gaSpaceDim, int count, int minValue, int maxValue)
{
var vSpaceDim = gaSpaceDim.ToVSpaceDimension();
if (count < 1 || count > vSpaceDim)
{
yield break;
}
var mv = GaSymMultivector.CreateScalar(gaSpaceDim, Expr.INT_ONE);
while (count > 0)
{
var v = GetSymIntegerVector(gaSpaceDim, minValue, maxValue);
var mv1 = mv.Op(v);
if (mv1.IsZero())
{
continue;
}
mv = mv1;
count--;
yield return(v);
}
}
protected void ValidateEqual(string msg, GaSymMultivector mv1, GaSymMultivector mv2)
{
ReportComposer.AppendLineAtNewLine();
ReportComposer.AppendAtNewLine(msg);
var diff = mv2 - mv1;
if (diff.IsNearNumericZero(NumericEpsilon))
{
ReportComposer.AppendLine("... << Validated >>");
if (ShowValidatedResults)
{
ReportComposer
.IncreaseIndentation();
ReportComposer
.AppendLineAtNewLine("Result: ")
.IncreaseIndentation()
.AppendLine(mv1.ToString())
.DecreaseIndentation()
.AppendLine();
ReportComposer
.DecreaseIndentation();
}
return;
}
ReportComposer.AppendLine("... << Invalid >>");
ReportComposer
.IncreaseIndentation();
ReportComposer
.AppendLineAtNewLine("First Value: ")
.IncreaseIndentation()
.AppendLine(mv1.ToString())
.DecreaseIndentation()
.AppendLine();
ReportComposer
.AppendLineAtNewLine("Second Value: ")
.IncreaseIndentation()
.AppendLine(mv2.ToString())
.DecreaseIndentation()
.AppendLine();
ReportComposer
.AppendLineAtNewLine("Difference: ")
.IncreaseIndentation()
.AppendLine(diff.ToString())
.DecreaseIndentation()
.AppendLine();
ReportComposer
.DecreaseIndentation();
}
public override GaSymMultivector BasisBladeSignature(int id)
{
var basisBlade = GaSymMultivector.CreateBasisBlade(GaSpaceDimension, id);
var sig = Gp[basisBlade, basisBlade];
return(id.BasisBladeIdHasNegativeReverse() ? -sig : sig);
}
public GaSymMultivector GetSymTerm(int gaSpaceDim, int basisBladeId, double minValue, double maxValue)
{
var mv = GaSymMultivector.CreateZero(gaSpaceDim);
mv.SetTermCoef(basisBladeId, GetSymbolicScalar(minValue, maxValue));
return(mv);
}
public GaSymMultivector GetSymTerm(int gaSpaceDim, string baseCoefName)
{
//Randomly select the number of terms in the multivector
var basisBladeId = GetInteger(gaSpaceDim - 1);
//Generate the multivector's symbolic coefficients
return(GaSymMultivector.CreateSymbolicTerm(gaSpaceDim, baseCoefName, basisBladeId));
}
public override IEnumerable <Tuple <int, IGaSymMultivector> > BasisBladeMaps()
{
return(Enumerable.Range(0, TargetGaSpaceDimension)
.Select(id => new Tuple <int, IGaSymMultivector>(
id,
GaSymMultivector.CreateBasisBlade(TargetGaSpaceDimension, id)
)));
}
public static GaSymMultivectorHash operator /(GaSymMultivectorHash mv1, MathematicaScalar s)
{
var sInv = SymbolicUtils.Constants.One / s;
return(GaSymMultivector
.CreateZeroTemp(mv1.GaSpaceDimension)
.AddFactors(sInv.Expression, mv1)
.ToHashMultivector());
}
public override IGaSymMultivectorTemp MapToTemp(GaSymMultivector mv1)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension)
{
throw new GMacSymbolicException("Multivector size mismatch");
}
return(mv1.ToTempMultivector());
}
public override IGaSymMultivectorTemp MapToTemp(int id1, int id2)
{
IGaSymMultivector mv;
_basisBladesMaps.TryGetLeafValue((ulong)id1, (ulong)id2, out mv);
return(mv?.ToTempMultivector()
?? GaSymMultivector.CreateZeroTemp(TargetGaSpaceDimension));
}
public static GaSymMultivectorHash operator *(MathematicaScalar s, GaSymMultivectorHash mv1)
{
return(s.IsNullOrZero()
? CreateZero(mv1.GaSpaceDimension)
: GaSymMultivector
.CreateZeroTemp(mv1.GaSpaceDimension)
.AddFactors(s.Expression, mv1)
.ToHashMultivector());
}
public override GaSymMultivector BasisBladeSignature(int id)
{
if (id >= 0 && id < GaSpaceDimension)
{
return(GaSymMultivector.CreateScalar(GaSpaceDimension, CasConstants.One));
}
throw new IndexOutOfRangeException();
}
public override IGaSymMultivectorTemp MapToTemp(int id1, int id2)
{
IGaSymMultivector resultMv;
_basisBladesMaps.TryGetValue(id1, id2, out resultMv);
return(resultMv?.ToTempMultivector()
?? GaSymMultivector.CreateZeroTemp(TargetGaSpaceDimension));
}
public override IGaSymMultivectorTemp MapToTemp(GaSymMultivector mv1, GaSymMultivector mv2)
{
var baseMv1 = NonOrthogonalMetric.DerivedToBaseCba[mv1];
var baseMv2 = NonOrthogonalMetric.DerivedToBaseCba[mv2];
var baseMv = BaseProductMap[baseMv1, baseMv2];
return(NonOrthogonalMetric.BaseToDerivedCba.MapToTemp(baseMv));
}
/// <summary>
/// Odd Versor Product
/// </summary>
/// <param name="oddVersor"></param>
/// <param name="mv"></param>
/// <returns></returns>
public GaSymMultivector OddVersorProduct(GaSymMultivector oddVersor, GaSymMultivector mv)
{
var oddVersorReverse = oddVersor.Reverse();
var oddVersorNorm2Inverse =
SymbolicUtils.Constants.One / Sp[oddVersor, oddVersorReverse][0]
.ToMathematicaScalar();
var oddVersorInverse = oddVersorReverse * oddVersorNorm2Inverse;
return(Gp[Gp[oddVersor, mv.GradeInv()], oddVersorInverse]);
}
public GaSymMultivector GetSymTerm(int gaSpaceDim, int grade, int index, double minValue, double maxValue)
{
var mv = GaSymMultivector.CreateZero(gaSpaceDim);
var basisBladeId = GMacMathUtils.BasisBladeId(grade, index);
mv.SetTermCoef(basisBladeId, GetSymbolicScalar(minValue, maxValue));
return(mv);
}
/// <summary>
/// Even Versor Product
/// </summary>
/// <param name="evenVersor"></param>
/// <param name="mv"></param>
/// <returns></returns>
public GaSymMultivector EvenVersorProduct(GaSymMultivector evenVersor, GaSymMultivector mv)
{
var evenVersorReverse = evenVersor.Reverse();
var evenVersorNorm2Inverse =
SymbolicUtils.Constants.One / Sp[evenVersor, evenVersorReverse][0]
.ToMathematicaScalar();
var evenVersorInverse = evenVersorReverse * evenVersorNorm2Inverse;
return(Gp[Gp[evenVersor, mv], evenVersorInverse]);
}
public override IGaSymMultivectorTemp MapToTemp(GaSymMultivector mv1, GaSymMultivector mv2)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension || mv2.GaSpaceDimension != DomainGaSpaceDimension2)
throw new GMacSymbolicException("Multivector size mismatch");
return
GaSymMultivector
.CreateZeroTemp(TargetGaSpaceDimension)
.AddFactors(mv1.GetBiTermsForGp(mv2, OrthogonalMetric));
}
public GaSymMultivector GetSymKVector(int gaSpaceDim, int grade, double maxValue)
{
var mv = GaSymMultivector.CreateZero(gaSpaceDim);
foreach (var basisBladeId in GMacMathUtils.BasisBladeIDsOfGrade(mv.VSpaceDimension, grade))
{
mv.SetTermCoef(basisBladeId, GetSymbolicScalar(maxValue));
}
return(mv);
}
public GaSymMultivector GetSymMultivectorByTerms(int gaSpaceDim, IEnumerable <int> basisBladeIDs)
{
var mv = GaSymMultivector.CreateZero(gaSpaceDim);
foreach (var basisBladeId in basisBladeIDs)
{
mv.SetTermCoef(basisBladeId, GetSymbolicScalar());
}
return(mv);
}
public GaSymMultivector ToMultivector()
{
var mv = GaSymMultivector.CreateZero(GaSpaceDimension);
foreach (var term in NonZeroExprTerms)
{
mv.SetTermCoef(term.Key, term.Value);
}
return(mv);
}
public GaSymMultivector GetSymIntegerKVector(int gaSpaceDim, int grade, int minValue, int maxValue)
{
var mv = GaSymMultivector.CreateZero(gaSpaceDim);
foreach (var basisBladeId in GMacMathUtils.BasisBladeIDsOfGrade(mv.VSpaceDimension, grade))
{
mv.SetTermCoef(basisBladeId, GetIntegerExpr(minValue, maxValue));
}
return(mv);
}
public override IGaSymMultivector this[int id1, int id2, int id3]
{
get
{
IGaSymMultivector basisBladeMv;
return
(!_basisBladesMaps.TryGetValue(id1, id2, id3, out basisBladeMv) || ReferenceEquals(basisBladeMv, null)
? GaSymMultivector.CreateZero(TargetGaSpaceDimension)
: basisBladeMv);
}
}
public GaSymMultivector GetSymMultivector(int gaSpaceDim, string baseCoefName)
{
//Randomly select the number of terms in the multivector
var termsCount = GetInteger(gaSpaceDim - 1);
//Randomly select the terms basis blades in the multivectors
var basisBladeIDs = GetRangePermutation(gaSpaceDim - 1).Take(termsCount);
//Generate the multivector's symbolic coefficients
return(GaSymMultivector.CreateSymbolic(gaSpaceDim, baseCoefName, basisBladeIDs));
}
public MathematicaScalar Magnitude2(GaSymMultivector mv)
{
return
(mv
.GetKVectorParts()
.Select(pair => Sp[pair.Value, pair.Value.Reverse()])
.Aggregate(
CasConstants.Zero,
(current, mv1) => current + mv1[0].ToMathematicaScalar().Abs()
));
}
