public GaSymMapBilinearHash SetBasisBladesMap(int id1, int id2, IGaSymMultivector value)
{
Debug.Assert(ReferenceEquals(value, null) || value.VSpaceDimension == TargetVSpaceDimension);
_basisBladesMaps[id1, id2] = value.Compactify(true);
return(this);
}
public Expr this[IGaSymMultivector mv1]
=> _factorsList.Count == 0
? Expr.INT_ZERO
: Mfs.SumExpr(
_factorsList
.Select(term => Mfs.Times[term.Item2, mv1[term.Item1]])
.ToArray()
);
public GaSymMapUnilinearArray SetBasisBladeMap(int basisBladeId, IGaSymMultivector targetMv)
{
Debug.Assert(ReferenceEquals(targetMv, null) || targetMv.VSpaceDimension == TargetVSpaceDimension);
_basisBladeMaps[basisBladeId] = targetMv.Compactify(true);
return(this);
}
public static GaSymMultivectorHash ToHashMultivector(this IGaSymMultivector mv)
{
var sparseMv = GaSymMultivectorHash.CreateZero(mv.GaSpaceDimension);
foreach (var term in mv.NonZeroTerms)
{
sparseMv.Add(term.Key, term.Value);
}
return(sparseMv);
}
public static GaSymMultivector Op(this IGaSymMultivector mv1, IGaSymMultivector mv2)
{
if (mv1.GaSpaceDimension != mv2.GaSpaceDimension)
{
throw new GMacSymbolicException("Multivector size mismatch");
}
return(GaSymMultivector
.CreateZeroTemp(mv1.GaSpaceDimension)
.AddFactors(mv1.ToMultivector().GetBiTermsForOp(mv2.ToMultivector()))
.ToMultivector());
}
public GaSymMapUnilinearCoefSums SetBasisBladeMap(int basisBladeId, IGaSymMultivector targetMv)
{
if (ReferenceEquals(targetMv, null))
{
return(this);
}
foreach (var term in targetMv.NonZeroExprTerms)
{
SetFactor(term.Key, basisBladeId, term.Value);
}
return(this);
}
public static IGaSymMultivector Compactify(this IGaSymMultivector mv, bool returnZeroMvAsNull = false)
{
if (DisableCompactifyMultivectors)
{
return(mv);
}
if (ReferenceEquals(mv, null))
{
return(null);
}
//Make sure this is not a temp multivector
if (mv.IsTemp)
{
mv = mv.ToMultivector();
}
//If it's zero return null or a zero term depending on returnZeroMvAsNull
if (mv.IsZero())
{
return(returnZeroMvAsNull
? null
: GaSymMultivectorTerm.CreateZero(mv.GaSpaceDimension));
}
//If it's a non-zero term return it as is
var termMv = mv as GaSymMultivectorTerm;
if (!ReferenceEquals(termMv, null))
{
return(termMv);
}
//It's a full multivector
var fullMv = (GaSymMultivector)mv;
//If it's not a term return it after simplification
if (!mv.IsTerm())
{
fullMv.Simplify();
return(fullMv);
}
//It's a full multivector containing a single term
var term = mv.NonZeroExprTerms.FirstOrDefault();
return(GaSymMultivectorTerm.CreateTerm(mv.GaSpaceDimension, term.Key, term.Value));
}
public GaSymMapUnilinearTree SetBasisBladeMap(int basisBladeId, IGaSymMultivector targetMv)
{
Debug.Assert(ReferenceEquals(targetMv, null) || targetMv.VSpaceDimension == TargetVSpaceDimension);
targetMv = targetMv.Compactify(true);
if (ReferenceEquals(targetMv, null))
{
return(this);
}
_basisBladeMaps.SetLeafValue((ulong)basisBladeId, targetMv);
return(this);
}
public static IGaSymMultivectorTemp ToTempMultivector(this IGaSymMultivector mv)
{
if (ReferenceEquals(mv, null))
{
return(null);
}
var tempMv = GaSymMultivector.CreateZeroTemp(mv.GaSpaceDimension);
foreach (var term in mv.NonZeroExprTerms)
{
tempMv.SetTermCoef(term.Key, term.Value);
}
return(tempMv);
}
public Expr this[IGaSymMultivector mv1, IGaSymMultivector mv2]
{
get
{
if (_factorsList.Count == 0)
{
return(Expr.INT_ZERO);
}
var termsExprArray =
_factorsList
.Select(factor => Mfs.ProductExpr(
mv1[factor.Item1],
mv2[factor.Item2],
factor.Item3
)).ToArray();
return(termsExprArray.Length == 1
? termsExprArray[0]
: Mfs.SumExpr(termsExprArray));
}
}
public static bool IsNullOrEqualZero(this IGaSymMultivector mv)
{
return(ReferenceEquals(mv, null) || mv.IsEqualZero());
}
public GaSymMapBilinearCoefSums SetBasisBladesMap(int domainBasisBladeId1, int domainBasisBladeId2, IGaSymMultivector targetMv)
{
Debug.Assert(targetMv.VSpaceDimension == TargetVSpaceDimension);
foreach (var term in targetMv.NonZeroExprTerms)
{
SetFactor(term.Key, domainBasisBladeId1, domainBasisBladeId2, term.Value);
}
return(this);
}
