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