public static GaSymOutermorphism Create(ISymbolicMatrix vectorsMappingMatrix, GaUnilinearMapImplementation multivectorsMappingKind)
{
if (multivectorsMappingKind == GaUnilinearMapImplementation.Identity)
{
var vSpaceDim = vectorsMappingMatrix.ColumnCount;
return(new GaSymOutermorphism(
MathematicaMatrix.CreateIdentity(SymbolicUtils.Cas, vSpaceDim),
GaSymMapUnilinearIdentity.Create(vSpaceDim),
GaUnilinearMapImplementation.Identity
));
}
var mvMappingDictionaryDict = vectorsMappingMatrix.ToOutermorphismDictionary();
GaSymMapUnilinear multivectorsMap;
switch (multivectorsMappingKind)
{
case GaUnilinearMapImplementation.Array:
multivectorsMap = mvMappingDictionaryDict.ToArrayMap(
vectorsMappingMatrix.ColumnCount,
vectorsMappingMatrix.RowCount
);
break;
case GaUnilinearMapImplementation.Hash:
multivectorsMap = mvMappingDictionaryDict.ToHashMap(
vectorsMappingMatrix.ColumnCount,
vectorsMappingMatrix.RowCount
);
break;
case GaUnilinearMapImplementation.Matrix:
multivectorsMap = mvMappingDictionaryDict.ToMatrixMap(
vectorsMappingMatrix.ColumnCount,
vectorsMappingMatrix.RowCount
);
break;
case GaUnilinearMapImplementation.CoefSums:
multivectorsMap = mvMappingDictionaryDict.ToCoefSumsMap(
vectorsMappingMatrix.ColumnCount,
vectorsMappingMatrix.RowCount
);
break;
default:
multivectorsMap = mvMappingDictionaryDict.ToTreeMap(
vectorsMappingMatrix.ColumnCount,
vectorsMappingMatrix.RowCount
);
break;
}
return(new GaSymOutermorphism(
vectorsMappingMatrix,
multivectorsMap,
multivectorsMappingKind
));
}
protected virtual void ComputeMappingMatrix()
{
var matrixItems = new Expr[TargetGaSpaceDimension, DomainGaSpaceDimension];
for (var col = 0; col < DomainGaSpaceDimension; col++)
{
var mv = this[col];
if (mv.IsNullOrZero())
{
for (var row = 0; row < TargetGaSpaceDimension; row++)
{
matrixItems[row, col] = Expr.INT_ZERO;
}
continue;
}
for (var row = 0; row < TargetGaSpaceDimension; row++)
{
var scalar = mv[row];
matrixItems[row, col] =
scalar.IsNullOrZero()
? Expr.INT_ZERO
: scalar;
}
}
InternalMappingMatrix =
MathematicaMatrix.CreateFullMatrix(SymbolicUtils.Cas, matrixItems);
}
private GaSymOutermorphism(ISymbolicMatrix vectorsMappingMatrix, GaSymMapUnilinear multivectorsMap, GaUnilinearMapImplementation multivectorsMappingKind)
{
_multivectorsMap = multivectorsMap;
VectorsMappingMatrix = vectorsMappingMatrix;
MultivectorsMappingKind = multivectorsMappingKind;
}
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);
}
public static GaOuterMorphismFull Create(ISymbolicMatrix vectorTransformMatrix)
{
var domainGaSpaceDim = FrameUtils.GaSpaceDimension(vectorTransformMatrix.Columns);
var codomainGaSpaceDim = FrameUtils.GaSpaceDimension(vectorTransformMatrix.Rows);
var transformedBasisBlades = new GaMultivector[domainGaSpaceDim];
transformedBasisBlades[0] = GaMultivector.CreateScalar(codomainGaSpaceDim, MathematicaScalar.Create(vectorTransformMatrix.CasInterface, 1));
for (var id = 1; id <= domainGaSpaceDim - 1; id++)
{
if (id.IsValidBasisVectorId())
{
transformedBasisBlades[id] = CreateFromMatrixColumn(vectorTransformMatrix, id.BasisBladeIndex());
}
else
{
int id1, id2;
id.SplitBySmallestBasicPattern(out id1, out id2);
transformedBasisBlades[id] = transformedBasisBlades[id1].OuterProduct(transformedBasisBlades[id2]);
}
}
return(new GaOuterMorphismFull(transformedBasisBlades));
}
public static GaSymMultivector CreateFromColumn(ISymbolicMatrix matrix, int col)
{
Debug.Assert(matrix.RowCount.IsValidGaSpaceDimension());
var mv = new GaSymMultivector(matrix.RowCount);
for (var index = 0; index < matrix.RowCount; index++)
{
mv.SetTermCoef(index, matrix[index, col]);
}
return(mv);
}
public static GaSymMultivector CreateVectorFromColumn(ISymbolicMatrix matrix, int col)
{
var gaSpaceDim = matrix.RowCount.ToGaSpaceDimension();
var mv = new GaSymMultivector(gaSpaceDim);
for (var row = 0; row < matrix.RowCount; row++)
{
mv.SetTermCoef(1, row, matrix[row, col]);
}
return(mv);
}
public static GaSymMultivector CreateVectorFromRow(ISymbolicMatrix matrix, int row)
{
var gaSpaceDim = matrix.ColumnCount.ToGaSpaceDimension();
var mv = new GaSymMultivector(gaSpaceDim);
for (var col = 0; col < matrix.ColumnCount; col++)
{
mv.SetTermCoef(1, col, matrix[row, col]);
}
return(mv);
}
private static GaMultivector CreateFromMatrixColumn(ISymbolicMatrix matrix, int col)
{
var gaSpaceDim = FrameUtils.GaSpaceDimension(matrix.Rows);
var mv = GaMultivector.CreateZero(gaSpaceDim);
for (var index = 0; index < matrix.Rows; index++)
{
mv[1, index] = matrix[index, col];
}
return(mv);
}
public GaLinearTransformMatrix(ISymbolicMatrix matrix)
{
if (matrix.Rows.IsValidGaSpaceDimension() == false)
{
throw new GMacSymbolicException("Matrix rows not a GA dimension");
}
if (matrix.Columns.IsValidGaSpaceDimension() == false)
{
throw new GMacSymbolicException("Matrix columns not a GA dimension");
}
InnerAssociatedMatrix = matrix;
}
internal GaFrameNonOrthogonal(GaFrame baseOrthoFrame, ISymbolicMatrix ipm, GaOuterMorphism derivedToBaseOm, GaOuterMorphism baseToDerivedOm)
{
if (baseOrthoFrame.IsOrthogonal == false)
{
throw new GMacSymbolicException("Base frame must be orthogonal");
}
if (ipm.IsSymmetric() == false || ipm.IsDiagonal())
{
throw new GMacSymbolicException("Inner product matrix must be symmetric and non-diagonal");
}
InnerProductMatrix = ipm.ToMathematicaMatrix();
Dfs = new DerivedFrameSystem(baseOrthoFrame, this, derivedToBaseOm, baseToDerivedOm);
}
public static GaSymOutermorphism CreateArray(ISymbolicMatrix vectorsMappingMatrix)
{
var multivectorsMap =
vectorsMappingMatrix
.ToOutermorphismDictionary()
.ToArrayMap(
vectorsMappingMatrix.ColumnCount,
vectorsMappingMatrix.RowCount
);
return(new GaSymOutermorphism(
vectorsMappingMatrix,
multivectorsMap,
GaUnilinearMapImplementation.Array
));
}
public static GaSymFrame CreateFromIpm(ISymbolicMatrix ipm)
{
if (ipm.IsSymmetric() == false)
{
throw new GMacSymbolicException("Inner product matrix must be symmetric");
}
if (ipm.IsIdentity())
{
return(CreateEuclidean(ipm.RowCount));
}
return
(ipm.IsDiagonal()
? CreateOrthogonal(ipm.GetDiagonal())
: CreateNonOrthogonalFromIpm(ipm.ToMathematicaMatrix()));
}
public static Dictionary <int, GaSymMultivector> ToOutermorphismDictionary(this ISymbolicMatrix linearVectorMapMatrix)
{
var domainGaSpaceDim =
linearVectorMapMatrix.ColumnCount.ToGaSpaceDimension();
var targetGaSpaceDim =
linearVectorMapMatrix.RowCount.ToGaSpaceDimension();
var omMapDict = new Dictionary <int, GaSymMultivector>();
//Add unit scalar as the image of the 0-basis blade
omMapDict.Add(0, GaSymMultivector.CreateUnitScalar(targetGaSpaceDim));
for (var id = 1; id <= domainGaSpaceDim - 1; id++)
{
GaSymMultivector basisBladeImage;
if (id.IsValidBasisVectorId())
{
//Add images of vector basis blades
basisBladeImage =
GaSymMultivector.CreateVectorFromColumn(
linearVectorMapMatrix,
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 GaSymMapUnilinearCoefSums ToCoefSumsMap(this ISymbolicMatrix linearMapMatrix)
{
Debug.Assert(linearMapMatrix.RowCount.IsValidGaSpaceDimension() && linearMapMatrix.ColumnCount.IsValidGaSpaceDimension());
var resultMap = GaSymMapUnilinearCoefSums.Create(
linearMapMatrix.ColumnCount.ToVSpaceDimension(),
linearMapMatrix.RowCount.ToVSpaceDimension()
);
for (var id = 0; id < linearMapMatrix.ColumnCount; id++)
{
var mv = GaSymMultivector.CreateFromColumn(linearMapMatrix, id);
if (!mv.IsNullOrZero())
{
resultMap.SetBasisBladeMap(id, mv);
}
}
return(resultMap);
}
internal GaSymFrameNonOrthogonal(GaSymFrame baseOrthoFrame, ISymbolicMatrix ipm, GaSymOutermorphism derivedToBaseOm, GaSymOutermorphism baseToDerivedOm)
{
if (baseOrthoFrame.IsOrthogonal == false)
{
throw new GMacSymbolicException("Base frame must be orthogonal");
}
if (ipm.IsSymmetric() == false || ipm.IsDiagonal())
{
throw new GMacSymbolicException("Inner product matrix must be symmetric and non-diagonal");
}
InnerProductMatrix = ipm.ToMathematicaMatrix();
NonOrthogonalMetric =
new GaSymMetricNonOrthogonal(
baseOrthoFrame,
this,
derivedToBaseOm,
baseToDerivedOm
);
Op = ComputedOp = new GaSymOp(VSpaceDimension);
Gp = ComputedGp = GaSymBilinearProductCba.CreateGp(NonOrthogonalMetric);
Sp = ComputedSp = GaSymBilinearProductCba.CreateSp(NonOrthogonalMetric);
Lcp = ComputedLcp = GaSymBilinearProductCba.CreateLcp(NonOrthogonalMetric);
Rcp = ComputedRcp = GaSymBilinearProductCba.CreateRcp(NonOrthogonalMetric);
Fdp = ComputedFdp = GaSymBilinearProductCba.CreateFdp(NonOrthogonalMetric);
Hip = ComputedHip = GaSymBilinearProductCba.CreateHip(NonOrthogonalMetric);
Acp = ComputedAcp = GaSymBilinearProductCba.CreateAcp(NonOrthogonalMetric);
Cp = ComputedCp = GaSymBilinearProductCba.CreateCp(NonOrthogonalMetric);
UnitPseudoScalarCoef =
MaxBasisBladeId.BasisBladeIdHasNegativeReverse()
? CasConstants.MinusOne / BasisBladeSignature(MaxBasisBladeId)[0].ToMathematicaScalar()
: CasConstants.One / BasisBladeSignature(MaxBasisBladeId)[0].ToMathematicaScalar();
}
private GaSymMapUnilinearMatrix(ISymbolicMatrix mappingMatrix)
{
InternalMappingMatrix = mappingMatrix;
TargetVSpaceDimension = mappingMatrix.ColumnCount.ToVSpaceDimension();
DomainVSpaceDimension = mappingMatrix.RowCount.ToVSpaceDimension();
}
public static GaSymMapUnilinearMatrix Create(ISymbolicMatrix mappingMatrix)
{
return(new GaSymMapUnilinearMatrix(mappingMatrix));
}
public ISymbolicVector Times(ISymbolicMatrix m)
{
throw new NotImplementedException();
}
public static GaSymMapUnilinearMatrix ToMatrixMap(this ISymbolicMatrix linearMapMatrix)
{
return(GaSymMapUnilinearMatrix.Create(linearMapMatrix));
}
public static GaSymOutermorphism ToOutermorphism(this ISymbolicMatrix linearVectorMapMatrix)
{
return(GaSymOutermorphism.Create(linearVectorMapMatrix));
}
public ISymbolicVector Times(ISymbolicMatrix m)
{
var e = CasInterface[Mfs.Dot[Expression, m.ToMathematicaMatrix().Expression]];
return(Create(CasInterface, e));
}
