public static GaSymMultivectorHash CreateTerm(int gaSpaceDim, int id, MathematicaScalar coef)
{
return(new GaSymMultivectorHash(gaSpaceDim)
{
[id] = coef.Expression
});
}
public static GaSymMultivectorHash CreatePseudoscalar(int gaSpaceDim, MathematicaScalar coef)
{
return(new GaSymMultivectorHash(gaSpaceDim)
{
[gaSpaceDim - 1] = coef.Expression
});
}
public ILanguageType VerifyType_SymbolicExpression(MathematicaScalar sc, OperandsByName operands)
{
var s = new StringBuilder();
var varTypes = new Dictionary <string, MathematicaAtomicType>();
foreach (var pair in operands.OperandsDictionary)
{
//var lhs_type = this.GMacSymbolTable.Scalar
var rhsType = pair.Value.ExpressionType;
if (rhsType.IsBoolean())
{
varTypes.Add(pair.Key, MathematicaAtomicType.Boolean);
}
if (rhsType.IsInteger())
{
varTypes.Add(pair.Key, MathematicaAtomicType.Integer);
}
if (rhsType.IsScalar())
{
varTypes.Add(pair.Key, MathematicaAtomicType.Real);
}
else
{
s.Append("cannot assign RHS expression of type ");
s.Append(rhsType.TypeSignature);
s.Append(" to symbolic expression parameter ");
s.Append(pair.Key);
}
}
if (s.Length > 0)
{
return(Context.CreateTypeMismatch(s.ToString()));
}
var assumeExpr = Cas.CreateAssumeExpr(varTypes);
if (sc.IsBooleanScalar(assumeExpr))
{
return(GMacRootAst.BooleanType);
}
//if (sc.IsIntegerScalar(assumeExpr))
// return GMacRootAst.IntegerType;
if (sc.IsRealScalar(assumeExpr))
{
return(GMacRootAst.ScalarType);
}
return
(sc.IsComplexScalar(assumeExpr)
? GMacRootAst.ScalarType
: Context.CreateTypeMismatch("Symbolic expression type cannot be determined"));
}
public static void ConstructionTest()
{
TestUtils.AddTestStartingMessage("MathematicaScalar Creation Test Started.");
var s = MathematicaScalar.CreateRational(Cas, 3, 5);
TestUtils.AddTest("Try create scalar from rational 3/5 ... ", s);
s = MathematicaScalar.CreateSymbol(Cas, "x3");
TestUtils.AddTest("Try create scalar from symbol name ... ", s);
s = MathematicaScalar.Create(Cas, 5);
TestUtils.AddTest("Try create scalar from integer 5 ... ", s);
s = MathematicaScalar.Create(Cas, 5.0f);
TestUtils.AddTest("Try create scalar from float 5.0f ... ", s);
s = MathematicaScalar.Create(Cas, 5.0d);
TestUtils.AddTest("Try create scalar from double 5.0d ... ", s);
var e = Mfs.Plus["v1".ToSymbolExpr(), Mfs.Power[5.ToExpr(), "n".ToSymbolExpr()]];
s = MathematicaScalar.Create(Cas, e);
TestUtils.AddTest("Try create scalar from expression object ... ", s);
s = MathematicaScalar.Create(Cas, @"Pi + 5 / 3");
TestUtils.AddTest("Try create scalar from expression text \"Pi + 5 / 3\" ... ", s);
TestUtils.AddTestCompletionMessage("MathematicaScalar Creation Test Completed.");
}
///Translate a constant number (Int32 or Double)
private ILanguageExpression translate_Constant_Number(ParseTreeNode node)
{
var numberText = node.FindTokenAndGetText();
Int32 intNumber;
if (Int32.TryParse(numberText, out intNumber))
{
return(ValuePrimitive <MathematicaScalar> .Create(
GMacRootAst.ScalarType,
MathematicaScalar.Create(SymbolicUtils.Cas, intNumber)
));
}
Double doubleNumber;
if (Double.TryParse(numberText, out doubleNumber))
{
return(ValuePrimitive <MathematicaScalar> .Create(
GMacRootAst.ScalarType,
MathematicaScalar.Create(SymbolicUtils.Cas, doubleNumber)
));
}
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Constant number not recognized", node));
}
/// <summary>
/// Create a symbolic scalar from this pattern. If the pattern is a constant its internal
/// expression is returned, else a symbolic expression with a single variable is created and returned
/// </summary>
/// <param name="varNameTemplate"></param>
/// <returns></returns>
internal MathematicaScalar ToMathematicaScalar(StringSequenceTemplate varNameTemplate)
{
return
(IsConstant
? ConstantSymbolicScalar
: MathematicaScalar.Create(SymbolicUtils.Cas, varNameTemplate.GenerateNextString()));
}
public GaSymMultivector SetTermCoef(int grade, int index, MathematicaScalar coef)
{
return(SetTermCoef(
GMacMathUtils.BasisBladeId(grade, index),
coef.Expression
));
}
internal MathematicaConstants(MathematicaInterface parentCas)
{
Cas = parentCas;
True = MathematicaCondition.Create(parentCas, true);
_constantsDictionary.Add("true", True);
False = MathematicaCondition.Create(parentCas, false);
_constantsDictionary.Add("false", False);
Zero = MathematicaScalar.Create(parentCas, 0);
_constantsDictionary.Add("zero", Zero);
One = MathematicaScalar.Create(parentCas, 1);
_constantsDictionary.Add("one", One);
MinusOne = MathematicaScalar.Create(parentCas, -1);
_constantsDictionary.Add("minusone", MinusOne);
Pi = MathematicaScalar.Create(parentCas, CasConnection.EvaluateToExpr("Pi"));
_constantsDictionary.Add("pi", Pi);
TwoPi = MathematicaScalar.Create(parentCas, CasConnection.EvaluateToExpr("Times[2, Pi]"));
_constantsDictionary.Add("twopi", TwoPi);
}
private bool InitSymbolicEngine()
{
try
{
_log.Append("Initializing Symbolic Engine...");
labelStatus.Text = _log.ToString();
Application.DoEvents();
MathematicaScalar.Create(SymbolicUtils.Cas, "0");
_log.AppendLine("Done").AppendLine();
labelStatus.Text = _log.ToString();
Application.DoEvents();
return(true);
}
catch (Exception e)
{
_log.AppendLine("Failed").AppendLine(e.Message).AppendLine();
labelStatus.Text = _log.ToString();
Application.DoEvents();
return(false);
}
}
/// <summary>
/// Finds the value of a primitive value access if exists; else returns the default primitive value
/// </summary>
/// <param name="valueAccess"></param>
/// <returns></returns>
public ValuePrimitive <MathematicaScalar> ReadRhsPrimitiveValue(LanguageValueAccess valueAccess)
{
//Try to read the value from the existing table low-level entries
var result = ReadRHSPrimitiveValue_ExistingOnly(valueAccess);
//If an entry is found just return the value
if (ReferenceEquals(result, null) == false)
{
return(result);
}
//If an entry is not found create and return a default value
if (valueAccess.ExpressionType.IsBoolean())
{
ValuePrimitive <MathematicaScalar> .Create(
(TypePrimitive)valueAccess.ExpressionType,
MathematicaScalar.Create(SymbolicUtils.Cas, "False")
);
}
return
(ValuePrimitive <MathematicaScalar> .Create(
(TypePrimitive)valueAccess.ExpressionType,
SymbolicUtils.Constants.Zero
));
}
private ValuePrimitive <MathematicaScalar> GetRandomValue(ILanguageType valueType)
{
Expr valueExpr;
if (valueType.IsInteger())
{
valueExpr = new Expr(_randomSource.Next(1, 10));
}
else if (valueType.IsBoolean())
{
valueExpr = new Expr(_randomSource.Next(0, 1) != 0);
}
else if (valueType.IsScalar())
{
valueExpr = new Expr(_randomSource.NextDouble() * 10.0 - 5.0);
}
//value_expr = new Expr(new Expr(ExpressionType.Symbol, "Rational"), _RandomSource.Next(1, 10), _RandomSource.Next(1, 10));
else
{
throw new InvalidOperationException();
}
return
(ValuePrimitive <MathematicaScalar> .Create(
(TypePrimitive)valueType,
MathematicaScalar.Create(SymbolicUtils.Cas, valueExpr)
));
}
/// <summary>
/// Bind a macro parameter of scalar type to a constant
/// </summary>
/// <param name="valueAccessName"></param>
/// <param name="value"></param>
public GMacMacroBinding BindScalarToConstant(string valueAccessName, MathematicaScalar value)
{
return(BindScalarToPattern(
ToValueAccess(valueAccessName, ScalarType),
GMacScalarBinding.CreateConstant(BaseMacro.Root, value.MathExpr)
));
}
private static MathematicaScalar[] ComputeBasisBladesSignatures(MathematicaScalar[] basisVectorsSignaturesList)
{
var vspacedim = basisVectorsSignaturesList.Length;
var bbsList = new MathematicaScalar[FrameUtils.GaSpaceDimension(vspacedim)];
bbsList[0] = SymbolicUtils.Constants.One;
for (var m = 0; m < vspacedim; m++)
{
bbsList[1 << m] = basisVectorsSignaturesList[m];
}
var idsSeq = FrameUtils.BasisBladeIDsSortedByGrade(vspacedim, 2);
foreach (var id in idsSeq)
{
int id1, id2;
id.SplitBySmallestBasisVectorId(out id1, out id2);
bbsList[id] = bbsList[id1] * bbsList[id2];
}
return(bbsList);
}
private void translate_Dependency_List(string expressionText, out MathematicaScalar scalar, out OperandsByName operands)
{
var finalScalarText = new StringBuilder(expressionText);
operands = OperandsByName.Create();
var varIdx = 1;
var allMatches = GenUtils.ExtractDistinctInternalExpressions(expressionText);
foreach (var rgexMatch in allMatches)
{
var rhsExprText = rgexMatch.Value.Substring(1, rgexMatch.Value.Length - 2);
var rhsExpr =
BasicExpressionGenerator.Generate_PolyadicOperand(
GMacRootAst.ScalarType,
translate_LanguageExpression(rhsExprText)
);
var lhsVarName = "var" + (varIdx++).ToString("0000");
finalScalarText = finalScalarText.Replace(rgexMatch.Value, lhsVarName);
operands.AddOperand(lhsVarName, rhsExpr);
}
scalar = MathematicaScalar.Create(Cas, finalScalarText.ToString());
}
/// <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
)
));
}
MathematicaScalar[] IGaSymMultivector.TermsToArray()
{
var termsArray = new MathematicaScalar[GaSpaceDimension];
termsArray[TermId] = TermCoef.ToMathematicaScalar();
return(termsArray);
}
protected override void ComputeIpm()
{
var bvSig = _basisVectorsSignatures.Select(i => MathematicaScalar.Create(CasInterface, i));
var v = MathematicaVector.CreateFullVector(CasInterface, bvSig);
InnerProductMatrix = MathematicaMatrix.CreateDiagonal(v);
}
private TreeNode Visit(MathematicaScalar value)
{
var node = new TreeNode("<SCALAR_VALUE> " + value)
{
Tag = value
};
return(node);
}
public static GaTreeMultivector CreateTerm(int gaSpaceDim, int id, MathematicaScalar coef)
{
var resultMv = new GaTreeMultivector(gaSpaceDim)
{
[id] = coef.Expression
};
return(resultMv);
}
public static GaTreeMultivector CreatePseudoScalar(int gaSpaceDim, MathematicaScalar coef)
{
var resultMv = new GaTreeMultivector(gaSpaceDim)
{
[gaSpaceDim - 1] = coef.Expression
};
return(resultMv);
}
internal GMacFrameBasisVector(string basisVectorName, GMacFrame parentFrame, int basisVectorIndex, MathematicaScalar signature)
: base(basisVectorName, parentFrame.ChildScope, RoleNames.FrameBasisVector, parentFrame.MultivectorType)
{
BasisVectorIndex = basisVectorIndex;
Signature = signature;
MultivectorValue = GMacValueMultivector.CreateBasisBlade(ParentFrame.MultivectorType, BasisVectorId);
}
public MathematicaScalar[] TermsToArray()
{
var scalarsArray = new MathematicaScalar[GaSpaceDimension];
foreach (var term in NonZeroTerms)
{
scalarsArray[term.Key] = term.Value;
}
return(scalarsArray);
}
/// <summary>
/// Create a symbolic value from this pattern. If the pattern is a constant its internal
/// expression is returned, else a symbolic expression with a single variable is created and returned
/// </summary>
/// <param name="varNameTemplate"></param>
/// <returns></returns>
public AstValueScalar ToValue(StringSequenceTemplate varNameTemplate)
{
return
(IsConstant
? ConstantValue
: new AstValueScalar(
ValuePrimitive <MathematicaScalar> .Create(
GMacType.AssociatedPrimitiveType,
MathematicaScalar.Create(SymbolicUtils.Cas, varNameTemplate.GenerateNextString())
)
));
}
public static GaSymMultivector CreateSymbolicTerm(int gaSpaceDim, string baseCoefName, int id)
{
var vSpaceDim = gaSpaceDim.ToVSpaceDimension();
return(new GaSymMultivector(gaSpaceDim)
.SetTermCoef(
id,
MathematicaScalar.CreateSymbol(
SymbolicUtils.Cas,
baseCoefName + id.PatternToString(vSpaceDim)
)));
}
public static GaSymMultivectorHash CreateSymbolicTerm(int gaSpaceDim, string baseCoefName, int id)
{
var vSpaceDim = gaSpaceDim.ToVSpaceDimension();
return(new GaSymMultivectorHash(gaSpaceDim)
{
[id] = MathematicaScalar.CreateSymbol(
SymbolicUtils.Cas,
baseCoefName + id.PatternToString(vSpaceDim)
).Expression
});
}
private TreeNode Visit(GMacFrameMultivector mvType, int lhsId, MathematicaScalar rhsScalar)
{
var lhsName = "#" + mvType.ParentFrame.BasisBladeName(lhsId) + "#";
var node = new TreeNode("<ASSIGN> " + lhsName)
{
Tag = lhsId
};
node.Nodes.Add(Visit(rhsScalar));
return(node);
}
public bool TryGetValue(int key, out MathematicaScalar value)
{
Expr expr;
if (_internalDictionary.TryGetValue(key, out expr))
{
value = expr.ToMathematicaScalar();
return(true);
}
value = null;
return(false);
}
public static string InitializeGMac()
{
var log = new LinearComposer();
try
{
log.Append("Initializing GA Data...");
GMacLookupTables.Choose(1, 1);
log.AppendLine("Done").AppendLine();
log.Append("Initializing GMac Resources...");
if (Directory.Exists(IconsPath) == false)
{
Directory.CreateDirectory(IconsPath);
}
SaveIcon(Resources.BasisVector64, "BasisVector64");
SaveIcon(Resources.Compile64, "Compile64");
SaveIcon(Resources.Constant64, "Constant64");
SaveIcon(Resources.Filter64, "Filter64");
SaveIcon(Resources.Frame64, "Frame64");
SaveIcon(Resources.GMacAST64, "GMacAST64");
SaveIcon(Resources.GMac_Icon64, "GMac_Icon64");
SaveIcon(Resources.Idea64, "Idea64");
SaveIcon(Resources.Input64, "Input64");
SaveIcon(Resources.Macro64, "Macro64");
SaveIcon(Resources.Namespace64, "Namespace64");
SaveIcon(Resources.Output64, "Output64");
SaveIcon(Resources.Scalar64, "Scalar64");
SaveIcon(Resources.Structure64, "Structure64");
SaveIcon(Resources.Subspace64, "Subspace64");
SaveIcon(Resources.Transform64, "Transform64");
log.AppendLine("Done").AppendLine();
log.Append("Initializing Symbolic Engine...");
MathematicaScalar.Create(SymbolicUtils.Cas, "0");
log.AppendLine("Done").AppendLine();
}
catch (Exception e)
{
log.AppendLine("Failed").AppendLine(e.Message).AppendLine();
}
return(log.ToString());
}
private ILanguageValue EvaluateBasicUnaryCastToScalar(BasicUnary expr)
{
var value1 = expr.Operand.AcceptVisitor(this);
if (value1.ExpressionType.IsInteger())
{
return(ValuePrimitive <MathematicaScalar> .Create(
(TypePrimitive)expr.ExpressionType,
MathematicaScalar.Create(SymbolicUtils.Cas, ((ValuePrimitive <int>)value1).Value)
));
}
throw new InvalidOperationException("Invalid cast operation");
}
public GaSymMapBilinearCombined AddMapping(MathematicaScalar coef, IGaSymMapBilinear linearMap)
{
if (
linearMap.DomainVSpaceDimension != DomainVSpaceDimension ||
linearMap.TargetVSpaceDimension != TargetVSpaceDimension
)
{
throw new InvalidOperationException("Linear map dimensions mismatch");
}
_termsList.Add(new GaSymMapBilinearCombinedTerm(coef, linearMap));
return(this);
}
