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