public override IGaNumMultivectorTemp MapToTemp(GaNumMultivector mv1, GaNumMultivector mv2)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension || mv2.GaSpaceDimension != DomainGaSpaceDimension2)
{
throw new GMacNumericException("Multivector size mismatch");
}
return
(GaNumMultivector
.CreateZeroTemp(TargetGaSpaceDimension)
.AddFactors(
mv1.GetBiTermsForEHip(mv2),
OrthonormalMetric
));
}
public IEnumerable <GaNumMultivector> EvenVersorProduct(GaNumMultivector evenVersor, IEnumerable <int> basisBladeIDs)
{
var evenVersorReverse = evenVersor.Reverse();
var evenVersorNorm2Inverse = 1.0d / Sp[evenVersor, evenVersorReverse][0];
var evenVersorInverse = evenVersorReverse * evenVersorNorm2Inverse;
return(basisBladeIDs.Select(id =>
{
var mv = GaNumMultivector.CreateBasisBlade(GaSpaceDimension, id);
return
Gp[Gp[evenVersor, mv], evenVersorInverse]
.GetKVectorPart(id.BasisBladeGrade());
}));
}
public override IGaNumMultivectorTemp MapToTemp(GaNumMultivector mv1)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension)
{
throw new GMacNumericException("Multivector size mismatch");
}
var resultMv = _mappingsList[0][mv1];
for (var i = 1; i < _mappingsList.Count - 1; i++)
{
resultMv = _mappingsList[i][resultMv];
}
return(_mappingsList[_mappingsList.Count - 1].MapToTemp(resultMv));
}
public override IGaNumMultivector this[int id1, int id2]
{
get
{
var resultMv = GaNumMultivector.CreateZeroTemp(TargetGaSpaceDimension);
foreach (var term in _termsList)
{
resultMv.AddFactors(
term.Coef,
term.LinearMap[id1, id2]
);
}
return(resultMv.ToMultivector());
}
}
public override IGaNumMultivector this[int domainBasisBladeId]
{
get
{
var resultMv = GaNumMultivector.CreateZeroTemp(TargetGaSpaceDimension);
foreach (var terms in _coefSumsTable.Values)
{
resultMv.AddFactor(
terms.TargetBasisBladeId,
terms[domainBasisBladeId]
);
}
return(resultMv.ToMultivector());
}
}
public GaNumMultivector GetNumMultivectorByGrades(int gaSpaceDim, params int[] grades)
{
var mv = GaNumMultivector.CreateZero(gaSpaceDim);
var basisBladeIDs =
GMacMathUtils.BasisBladeIDsOfGrades(
mv.VSpaceDimension,
grades
);
foreach (var basisBladeId in basisBladeIDs)
{
mv.SetTermCoef(basisBladeId, GetScalar());
}
return(mv);
}
public static IGaNumMultivectorTemp MapToTemp(this GMacBinaryTree <IGaNumMapUnilinear> mappingTree, GaNumMultivector mv1, GaNumMultivector mv2, int targetGaSpaceDimension)
{
if (mv1.GaSpaceDimension != mappingTree.TreeDepth.ToGaSpaceDimension())
{
throw new GMacNumericException("Multivector size mismatch");
}
var resultMv = GaNumMultivector.CreateZeroTemp(targetGaSpaceDimension);
var nodeStack1 = mappingTree.CreateNodesStack();
var nodeStack2 = mv1.TermsTree.CreateNodesStack();
while (nodeStack1.Count > 0)
{
var node1 = nodeStack1.Pop();
var node2 = nodeStack2.Pop();
if (node1.IsLeafNode && !ReferenceEquals(node1.Value, null))
{
var leafScalar = node2.Value;
var leafMv = node1.Value.MapToTemp(mv2);
resultMv.AddFactors(
leafScalar,
leafMv
);
continue;
}
if (node1.HasChildNode0 && node2.HasChildNode0)
{
nodeStack1.Push(node1.ChildNode0);
nodeStack2.Push(node2.ChildNode0);
}
if (node1.HasChildNode1 && node2.HasChildNode1)
{
nodeStack1.Push(node1.ChildNode1);
nodeStack2.Push(node2.ChildNode1);
}
}
return(resultMv);
}
public static Dictionary <int, GaNumMultivector> ToOutermorphismDictionary(this Matrix linearVectorMapsMatrix)
{
var domainGaSpaceDim =
linearVectorMapsMatrix.ColumnCount.ToGaSpaceDimension();
var targetGaSpaceDim =
linearVectorMapsMatrix.RowCount.ToGaSpaceDimension();
var omMapDict = new Dictionary <int, GaNumMultivector>();
//Add unit scalar as the image of the 0-basis blade
omMapDict.Add(0, GaNumMultivector.CreateUnitScalar(targetGaSpaceDim));
for (var id = 1; id <= domainGaSpaceDim - 1; id++)
{
GaNumMultivector basisBladeImage;
if (id.IsValidBasisVectorId())
{
//Add images of vector basis blades
basisBladeImage =
GaNumMultivector.CreateVectorFromColumn(
linearVectorMapsMatrix,
id.BasisBladeIndex()
);
}
else
{
//Add images of a higher dimensional basis blade using the outer product
//of the images of two lower dimensional basis blades
int id1, id2;
id.SplitBySmallestBasicPattern(out id1, out id2);
basisBladeImage =
omMapDict[id1].Op(omMapDict[id2]);
}
if (!basisBladeImage.IsZero())
{
omMapDict.Add(id, basisBladeImage);
}
}
return(omMapDict);
}
public static Dictionary <int, GaNumMultivector> ToOutermorphismDictionary(this Dictionary <int, IGaNumMultivector> linearVectorMaps, int domainVSpaceDim, int targetVSpaceDim)
{
var domainGaSpaceDim =
domainVSpaceDim.ToGaSpaceDimension();
var targetGaSpaceDim =
targetVSpaceDim.ToGaSpaceDimension();
var omMapDict = new Dictionary <int, GaNumMultivector>();
//Add unit scalar as the image of the 0-basis blade
omMapDict.Add(0, GaNumMultivector.CreateUnitScalar(targetGaSpaceDim));
for (var id = 1; id <= domainGaSpaceDim - 1; id++)
{
GaNumMultivector basisBladeImage;
if (id.IsValidBasisVectorId())
{
//Add images of vector basis blades
IGaNumMultivector mv;
linearVectorMaps.TryGetValue(id.BasisBladeIndex(), out mv);
basisBladeImage = mv?.GetVectorPart()
?? GaNumMultivector.CreateZero(targetGaSpaceDim);
}
else
{
//Add images of a higher dimensional basis blade using the outer product
//of the images of two lower dimensional basis blades
int id1, id2;
id.SplitBySmallestBasicPattern(out id1, out id2);
basisBladeImage =
omMapDict[id1].Op(omMapDict[id2]);
}
if (!basisBladeImage.IsZero())
{
omMapDict.Add(id, basisBladeImage);
}
}
return(omMapDict);
}
public GaNumMultivector ToMultivector()
{
var mv = GaNumMultivector.CreateZero(GaSpaceDimension);
var id = 0;
foreach (var coef in _termsArray)
{
if (!coef.IsNearZero())
{
mv.SetTermCoef(id, coef);
}
id++;
}
return(mv);
}
public static Dictionary <int, GaNumMultivector> ToOutermorphismDictionary(this IEnumerable <IGaNumMultivector> linearVectorMaps)
{
var linearVectorMapsArray = linearVectorMaps.ToArray();
var domainGaSpaceDim =
linearVectorMapsArray.Length.ToGaSpaceDimension();
var targetGaSpaceDim =
linearVectorMapsArray[0].GaSpaceDimension;
var omMapDict = new Dictionary <int, GaNumMultivector>();
//Add unit scalar as the image of the 0-basis blade
omMapDict.Add(0, GaNumMultivector.CreateUnitScalar(targetGaSpaceDim));
for (var id = 1; id <= domainGaSpaceDim - 1; id++)
{
GaNumMultivector basisBladeImage;
if (id.IsValidBasisVectorId())
{
//Add images of vector basis blades
basisBladeImage =
linearVectorMapsArray[id.BasisBladeIndex()].GetVectorPart();
}
else
{
//Add images of a higher dimensional basis blade using the outer product
//of the images of two lower dimensional basis blades
int id1, id2;
id.SplitBySmallestBasicPattern(out id1, out id2);
basisBladeImage =
omMapDict[id1].Op(omMapDict[id2]);
}
if (!basisBladeImage.IsZero())
{
omMapDict.Add(id, basisBladeImage);
}
}
return(omMapDict);
}
public override IGaNumMultivectorTemp MapToTemp(GaNumMultivector mv1, GaNumMultivector mv2, GaNumMultivector mv3)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension || mv2.GaSpaceDimension != DomainGaSpaceDimension || mv3.GaSpaceDimension != DomainGaSpaceDimension)
{
throw new GMacNumericException("Multivector size mismatch");
}
var tempMv = GaNumMultivector.CreateZeroTemp(TargetGaSpaceDimension);
foreach (var term1 in mv1.NonZeroTerms)
{
var id1 = term1.Key;
var coef1 = term1.Value;
foreach (var term2 in mv2.NonZeroTerms)
{
var id2 = term2.Key;
var coef2 = term2.Value;
foreach (var term3 in mv3.NonZeroTerms)
{
var id3 = term3.Key;
var coef3 = term3.Value;
IGaNumMultivector basisBladeMv;
if (!_basisBladesMaps.TryGetValue(id1, id2, id3, out basisBladeMv) ||
basisBladeMv == null)
{
continue;
}
foreach (var basisBladeMvTerm in basisBladeMv.NonZeroTerms)
{
tempMv.AddFactor(
basisBladeMvTerm.Key,
basisBladeMvTerm.Value * coef1 * coef2 * coef3
);
}
}
}
}
return(tempMv);
}
/// <summary>
/// Odd Versor Product of a list of basis blades given by their IDs
/// </summary>
/// <param name="oddVersor"></param>
/// <param name="basisBladeIDs"></param>
/// <returns></returns>
public IEnumerable <GaNumMultivector> OddVersorProduct(GaNumMultivector oddVersor, IEnumerable <int> basisBladeIDs)
{
var oddVersorReverse = oddVersor.Reverse();
var oddVersorNorm2Inverse = 1.0d / Sp[oddVersor, oddVersorReverse][0];
var oddVersorInverse = oddVersorReverse * oddVersorNorm2Inverse;
return(basisBladeIDs.Select(id =>
{
var mv = GaNumMultivector.CreateTerm(
GaSpaceDimension,
id,
id.BasisBladeIdHasNegativeGradeInv() ? -1.0d : 1.0d
);
return
Gp[Gp[oddVersor, mv], oddVersorInverse]
.GetKVectorPart(id.BasisBladeGrade());
}));
}
/// <summary>
/// Create a derived frame system where the derived frame is the reciprocal of the base frame
/// </summary>
/// <param name="baseFrame"></param>
/// <returns></returns>
public static GaNumMetricNonOrthogonal CreateReciprocalCbmFrameSystem(GaNumFrame baseFrame)
{
if (baseFrame.IsOrthogonal)
{
var cbmat = baseFrame.Ipm.Inverse();
var b2DOm = baseFrame.Ipm.ToOutermorphismTree();
var d2BOm = (cbmat as Matrix).ToOutermorphismTree();
var derivedFrame = CreateOrthogonal(cbmat.Diagonal());
return(new GaNumMetricNonOrthogonal(baseFrame, derivedFrame, d2BOm, b2DOm));
}
var cbmArray = new double[baseFrame.VSpaceDimension, baseFrame.VSpaceDimension];
var mv2 = baseFrame.CreateInverseUnitPseudoScalar();
for (var i = 0; i < baseFrame.VSpaceDimension; i++)
{
var id = (1 << i) ^ baseFrame.MaxBasisBladeId;
var mv1 = GaNumMultivector.CreateTerm(baseFrame.GaSpaceDimension, id, 1.0d);
var mv = baseFrame.Lcp[mv1, mv2];
foreach (var term in mv.NonZeroTerms)
{
var j = term.Key.BasisBladeIndex();
if ((i & 1) == 1)
{
cbmArray[i, j] = term.Value;
}
else
{
cbmArray[i, j] = -term.Value;
}
}
}
var cbm = DenseMatrix.OfArray(cbmArray);
return(CreateDerivedCbmFrameSystem(baseFrame, cbm));
}
public override IGaNumMultivectorTemp MapToTemp(GaNumMultivector mv1)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension)
{
throw new GMacNumericException("Multivector size mismatch");
}
var tempMv = GaNumMultivector.CreateZeroTemp(TargetGaSpaceDimension);
foreach (var terms in _coefSumsTable.Values)
{
tempMv.AddFactor(
terms.TargetBasisBladeId,
terms[mv1]
);
}
return(tempMv);
}
public override IGaNumMultivectorTemp MapToTemp(GaNumMultivector mv1)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension)
{
throw new GMacNumericException("Multivector size mismatch");
}
var tempMv = GaNumMultivector.CreateZeroTemp(TargetGaSpaceDimension);
foreach (var term in _mappingsList)
{
tempMv.AddFactors(
term.Coef,
term.LinearMap[mv1]
);
}
return(tempMv);
}
public virtual GaNumMapUnilinear Adjoint()
{
var exprArray = this.ToScalarsArray();
var resultMap = GaNumMapUnilinearTree.Create(
TargetVSpaceDimension,
DomainVSpaceDimension
);
for (var id = 0; id < TargetGaSpaceDimension; id++)
{
var mv = GaNumMultivector.CreateFromRow(exprArray, id);
if (!mv.IsNullOrZero())
{
resultMap.SetBasisBladeMap(id, mv);
}
}
return(resultMap);
}
public static GaNumMapUnilinearCoefSums ToCoefSumsMap(this Matrix linearMapMatrix)
{
Debug.Assert(linearMapMatrix.RowCount.IsValidGaSpaceDimension() && linearMapMatrix.ColumnCount.IsValidGaSpaceDimension());
var resultMap = GaNumMapUnilinearCoefSums.Create(
linearMapMatrix.ColumnCount.ToVSpaceDimension(),
linearMapMatrix.RowCount.ToVSpaceDimension()
);
for (var id = 0; id < linearMapMatrix.ColumnCount; id++)
{
var mv = GaNumMultivector.CreateFromColumn(linearMapMatrix, id);
if (!mv.IsNullOrZero())
{
resultMap.SetBasisBladeMap(id, mv);
}
}
return(resultMap);
}
public static IGaNumMultivectorTemp MapToTemp(this Matrix mappingMatrix, GaNumMultivector mv1)
{
if (mv1.GaSpaceDimension != mappingMatrix.ColumnCount)
{
throw new GMacNumericException("Multivector size mismatch");
}
var tempMv = GaNumMultivector.CreateZeroTemp(mappingMatrix.RowCount);
foreach (var term in mv1.NonZeroTerms)
{
var id = term.Key;
var coef = term.Value;
for (var row = 0; row < mappingMatrix.RowCount; row++)
{
tempMv.AddFactor(id, mappingMatrix[row, id] * coef);
}
}
return(tempMv);
}
public override IGaNumMultivector this[int id1]
{
get
{
var resultMv = GaNumMultivector.CreateZeroTemp(TargetGaSpaceDimension);
foreach (var term in _mappingsList)
{
var mv = term.LinearMap[id1];
foreach (var mvTerm in mv.NonZeroTerms)
{
resultMv.AddFactor(
mvTerm.Key,
mvTerm.Value * term.Coef
);
}
}
return(resultMv.ToMultivector());
}
}
public override IGaNumMultivectorTemp MapToTemp(GaNumMultivector mv1)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension)
{
throw new GMacNumericException("Multivector size mismatch");
}
var tempMv = GaNumMultivector.CreateZeroTemp(TargetGaSpaceDimension);
foreach (var term1 in mv1.NonZeroTerms)
{
var basisBladeMv = _basisBladeMaps[term1.Key];
if (ReferenceEquals(basisBladeMv, null))
{
continue;
}
tempMv.AddFactors(term1.Value, basisBladeMv);
}
return(tempMv);
}
public override IGaNumMultivectorTemp MapToTemp(GaNumMultivector mv1)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension)
{
throw new GMacNumericException("Multivector size mismatch");
}
var tempMv = GaNumMultivector.CreateZeroTemp(TargetGaSpaceDimension);
var nodeStack1 = BasisBladesMapTree.CreateNodesStack();
var nodeStack2 = mv1.TermsTree.CreateNodesStack();
while (nodeStack1.Count > 0)
{
var node1 = nodeStack1.Pop();
var node2 = nodeStack2.Pop();
if (node1.IsLeafNode)
{
tempMv.AddFactors(node2.Value, node1.Value);
continue;
}
if (node1.HasChildNode0 && node2.HasChildNode0)
{
nodeStack1.Push(node1.ChildNode0);
nodeStack2.Push(node2.ChildNode0);
}
if (node1.HasChildNode1 && node2.HasChildNode1)
{
nodeStack1.Push(node1.ChildNode1);
nodeStack2.Push(node2.ChildNode1);
}
}
return(tempMv);
}
public override IGaNumMultivectorTemp MapToTemp(GaNumMultivector mv1, GaNumMultivector mv2)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension || mv2.GaSpaceDimension != DomainGaSpaceDimension)
{
throw new GMacNumericException("Multivector size mismatch");
}
var tempMv = GaNumMultivector.CreateZeroTemp(TargetGaSpaceDimension);
foreach (var biTerm in mv1.GetBiTermsForEGp(mv2))
{
IGaNumMultivector basisBladeMv;
_basisBladesMaps.TryGetValue(biTerm.Id1, biTerm.Id2, out basisBladeMv);
if (ReferenceEquals(basisBladeMv, null))
{
continue;
}
tempMv.AddFactors(biTerm.ValuesProduct, basisBladeMv);
}
return(tempMv);
}
public override GaNumMultivector BasisBladeSignature(int id)
{
return(GaNumMultivector.CreateScalar(GaSpaceDimension, OrthogonalMetric[id]));
}
public string Execute()
{
var randGen = new GMacRandomGenerator(10);
var textComposer = new LinearComposer();
var numFrame = GaNumFrame.CreateConformal(5);
var symFrame = GaSymFrame.CreateConformal(5);
var numMv1 = randGen.GetNumMultivectorFull(numFrame.GaSpaceDimension);
var numMv2 = randGen.GetNumMultivectorFull(numFrame.GaSpaceDimension);
var symMv1 = numMv1.ToSymbolic();
var symMv2 = numMv2.ToSymbolic();
var symMvGp = symFrame.Gp[symMv1, symMv2];
//textComposer.AppendLineAtNewLine("Symbolic Multivector 1: ").AppendLine(symMv1);
//textComposer.AppendLineAtNewLine("Numeric Multivector 1: ").AppendLine(numMv1);
//textComposer.AppendLineAtNewLine("Symbolic Multivector 2: ").AppendLine(symMv2);
//textComposer.AppendLineAtNewLine("Numeric Multivector 2: ").AppendLine(numMv2);
//textComposer.AppendLineAtNewLine("Symbolic Gp: ").AppendLine(symMvGp);
//textComposer.AppendLineAtNewLine("Numeric GP: ").AppendLine(numMvGp);
numFrame.SetProductsImplementation(GaBilinearProductImplementation.Computed);
GaNumMultivector.ResetAddFactorsCallCount();
var numMvGp = numFrame.Gp[numMv1, numMv2];
var callsCount = GaNumMultivector.AddFactorsCallCount;
var diff = symMvGp.ToNumeric() - numMvGp;
diff.Simplify();
GaNumMultivector.ResetAddFactorsCallCount();
textComposer
.AppendLineAtNewLine("Difference, Computed Tree: ")
.AppendLine(callsCount)
.AppendLine(diff);
numFrame.SetProductsImplementation(GaBilinearProductImplementation.LookupArray);
GaNumMultivector.ResetAddFactorsCallCount();
numMvGp = numFrame.Gp[numMv1, numMv2];
callsCount = GaNumMultivector.AddFactorsCallCount;
//var factorsCount = ((GaNumMapBilinearArray) numFrame.Gp).FactorsCount;
diff = symMvGp.ToNumeric() - numMvGp;
diff.Simplify();
GaNumMultivector.ResetAddFactorsCallCount();
textComposer
.AppendLineAtNewLine("Difference, Lookup Array: ")
.AppendLine(callsCount)
//.AppendLine(factorsCount)
.AppendLine(diff);
numFrame.SetProductsImplementation(GaBilinearProductImplementation.LookupHash);
GaNumMultivector.ResetAddFactorsCallCount();
numMvGp = numFrame.Gp[numMv1, numMv2];
callsCount = GaNumMultivector.AddFactorsCallCount;
//factorsCount = ((GaNumMapBilinearHash)numFrame.Gp).FactorsCount;
diff = symMvGp.ToNumeric() - numMvGp;
diff.Simplify();
GaNumMultivector.ResetAddFactorsCallCount();
textComposer
.AppendLineAtNewLine("Difference, Lookup Hash: ")
.AppendLine(callsCount)
//.AppendLine(factorsCount)
.AppendLine(diff);
numFrame.SetProductsImplementation(GaBilinearProductImplementation.LookupTree);
GaNumMultivector.ResetAddFactorsCallCount();
numMvGp = numFrame.Gp[numMv1, numMv2];
callsCount = GaNumMultivector.AddFactorsCallCount;
//factorsCount = ((GaNumMapBilinearTree)numFrame.Gp).FactorsCount;
diff = symMvGp.ToNumeric() - numMvGp;
diff.Simplify();
GaNumMultivector.ResetAddFactorsCallCount();
textComposer
.AppendLineAtNewLine("Difference, Lookup Tree: ")
.AppendLine(callsCount)
//.AppendLine(factorsCount)
.AppendLine(diff);
numFrame.SetProductsImplementation(GaBilinearProductImplementation.LookupCoefSums);
GaNumMultivector.ResetAddFactorsCallCount();
numMvGp = numFrame.Gp[numMv1, numMv2];
callsCount = GaNumMultivector.AddFactorsCallCount;
//factorsCount = ((GaNumMapBilinearCoefSums)numFrame.Gp).FactorsCount;
diff = symMvGp.ToNumeric() - numMvGp;
diff.Simplify();
GaNumMultivector.ResetAddFactorsCallCount();
textComposer
.AppendLineAtNewLine("Difference, Lookup CoefSums: ")
.AppendLine(callsCount)
//.AppendLine(factorsCount)
.AppendLine(diff);
return(textComposer.ToString());
}
public virtual GaNumMultivector this[GaNumMultivector mv1, GaNumMultivector mv2, GaNumMultivector mv3] => MapToTemp(mv1, mv2, mv3).ToMultivector();
public override IGaNumMultivectorTemp MapToTemp(GaNumMultivector mv1, GaNumMultivector mv2)
{
if (mv1.GaSpaceDimension != DomainGaSpaceDimension || mv2.GaSpaceDimension != DomainGaSpaceDimension)
{
throw new GMacNumericException("Multivector size mismatch");
}
var tempMv = GaNumMultivector.CreateZeroTemp(TargetGaSpaceDimension);
var mvNodeStack1 = mv1.TermsTree.CreateNodesStack();
var mvNodeStack2 = mv2.TermsTree.CreateNodesStack();
var idStack1 = mv1.TermsTree.CreateNodeIDsStack();
var idStack2 = mv2.TermsTree.CreateNodeIDsStack();
while (mvNodeStack1.Count > 0)
{
var mvNode1 = mvNodeStack1.Pop();
var mvNode2 = mvNodeStack2.Pop();
var id1 = idStack1.Pop();
var id2 = idStack2.Pop();
if (mvNode1.IsLeafNode)
{
var basisBladeMv = _basisBladesMaps[id1, id2];
if (!ReferenceEquals(basisBladeMv, null))
{
tempMv.AddFactors(mvNode1.Value * mvNode2.Value, basisBladeMv);
}
continue;
}
if (mvNode1.HasChildNode0)
{
if (mvNode2.HasChildNode0)
{
mvNodeStack1.Push(mvNode1.ChildNode0);
mvNodeStack2.Push(mvNode2.ChildNode0);
idStack1.Push(id1);
idStack2.Push(id2);
}
if (mvNode2.HasChildNode1)
{
mvNodeStack1.Push(mvNode1.ChildNode0);
mvNodeStack2.Push(mvNode2.ChildNode1);
idStack1.Push(id1);
idStack2.Push(id2 | mvNode2.ChildNode1.BitMask);
}
}
if (mvNode1.HasChildNode1)
{
if (mvNode2.HasChildNode0)
{
mvNodeStack1.Push(mvNode1.ChildNode1);
mvNodeStack2.Push(mvNode2.ChildNode0);
idStack1.Push(id1 | mvNode1.ChildNode1.BitMask);
idStack2.Push(id2);
}
if (mvNode2.HasChildNode1)
{
mvNodeStack1.Push(mvNode1.ChildNode1);
mvNodeStack2.Push(mvNode2.ChildNode1);
idStack1.Push(id1 | mvNode1.ChildNode1.BitMask);
idStack2.Push(id2 | mvNode2.ChildNode1.BitMask);
}
}
}
//foreach (var biTerm in mv1.GetBiTermsForEGp(mv2))
//{
// var basisBladeMv = _basisBladesMaps[biTerm.Id1, biTerm.Id2];
// if (ReferenceEquals(basisBladeMv, null))
// continue;
// tempMv.AddFactors(biTerm.ValuesProduct, basisBladeMv);
//}
return(tempMv);
}
public static double EMagnitude2(this GaNumMultivector mv)
{
return(ESp(mv, mv.Reverse())[0]);
}
public static double EMagnitude(this GaNumMultivector mv)
{
return(Math.Sqrt(ESp(mv, mv.Reverse())[0]));
}
public abstract IGaNumMultivectorTemp MapToTemp(GaNumMultivector mv1, GaNumMultivector mv2, GaNumMultivector mv3);
