public void MultivectorCopy()
{
var A = new Multivector(R3)
{
[E1] = 3.5,
[E2] = 0.14,
[E3] = -1 / 12d
};
Assert.AreEqual(A, M["Vector3B"]);
Assert.IsTrue(A == M["Vector3B"]);
Assert.IsFalse(A != M["Vector3B"]);
Assert.IsTrue(A.Equals(M["Vector3B"]));
A.Copy(M["Vector3A"]);
Assert.AreEqual(A, M["Vector3A"]);
Assert.IsTrue(A == M["Vector3A"]);
Assert.IsFalse(A != M["Vector3A"]);
Assert.IsTrue(A.Equals(M["Vector3A"]));
Assert.AreNotEqual(A, M["Vector3B"]);
Assert.IsFalse(A == M["Vector3B"]);
Assert.IsTrue(A != M["Vector3B"]);
Assert.IsTrue(A.Equals(M["Vector3A"]));
Assert.AreEqual(A.GetHashCode(), M["Vector3A"].GetHashCode());
}
public MainPage()
{
InitializeComponent();
var S = new Space(4);
var A = new Multivector(S)
{
[EScalar] = 42,
ScalarPart = 43
};
}
public UnaryScalarOp Round(double epsilon)
{
Multivector V = m_value.Round(epsilon);
if (V != m_value)
{
return(new UnaryScalarOp(m_opName, V));
}
else
{
return(this);
}
}
public BinaryScalarOp Round(double epsilon)
{
Multivector A = m_value1.Round(epsilon);
Multivector B = m_value2.Round(epsilon);
if ((A != m_value1) || (B != m_value2))
{
return(new BinaryScalarOp(m_opName, A, B));
}
else
{
return(this);
}
}
/// <summary>
/// Evaluates a Multivector to a summary of its expected value (-1, 0, 1).
/// The function uses a Symbolic.RandomSymbolicEvaluator to randomly evaluate
/// <paramref name="A"/>. If the results are consistently negative, zero or
/// positive then -1, 0 or 1 is returned. Otherwise an exception is thrown.
/// </summary>
/// <param name="A">The multivector to evaluate</param>
/// <returns>-1, 0 or 1</returns>
/// <remarks>
/// Used by Multivector.Exp(), Multivector.Cos() and Multivector.Sin() to see
/// if the input bivector has a scalar square.
/// </remarks>
public static double EvaluateRandomSymbolicToScalar(Multivector A)
{
double EPS = 1e-4;
int NB_ITER = 100;
int REQ = 98;
Symbolic.RandomSymbolicEvaluator RSE = new Symbolic.RandomSymbolicEvaluator(-100.0, 100.0);
int pos = 0, neg = 0, zero = 0;
for (int i = 0; i < NB_ITER; i++)
{
Multivector E = A.SymbolicEval(RSE);
double scalarPart = E.RealScalarPart();
Multivector theRest = Multivector.Subtract(E, scalarPart);
if (Math.Abs(theRest.Norm_e().RealScalarPart()) > Math.Abs(scalarPart) * EPS)
{
throw new Exception("Multivector did not evaluate to scalar");
}
if (scalarPart > EPS)
{
pos++;
}
else if (scalarPart < -EPS)
{
neg++;
}
else
{
zero++;
}
}
if (pos >= REQ)
{
return(1.0);
}
else if (zero >= REQ)
{
return(0.0);
}
else if (neg >= REQ)
{
return(-1.0);
}
else
{
throw new Exception("Multivector did not evaluate to a consistent value");
}
}
/// <summary>
/// Substitutes all symbolic scalars for doubles (as evaluated by <paramref name="E"/>)
/// and evaluates the symbolic ScalarOps. E.g. sqrt(2.0) would evaluate to 1.4142...
/// </summary>
/// <param name="E">SymbolicEvaluator used to evaluate the symbolic scalars</param>
/// <returns></returns>
public double SymbolicEval(RefGA.Symbolic.SymbolicEvaluator E)
{
Multivector A = m_value1.SymbolicEval(E);
Multivector B = m_value2.SymbolicEval(E);
if (!(A.IsScalar() && B.IsScalar()))
{
throw new ArgumentException("BinaryScalarOp.SymbolicEval: argument is not scalar");
}
double a = A.RealScalarPart();
double b = B.RealScalarPart();
if (m_opName == ATAN2)
{
return(Math.Atan2(a, b));
}
else
{
throw new ArgumentException("BinaryScalarOp.SymbolicEval: unknown opname " + m_opName);
}
}
public void MultivectorConstructor()
{
var A = new Multivector(R3)
{
[E1] = 3.5,
[E2] = 0.14,
[E3] = -1 / 12d
};
Assert.AreEqual(3.5, A[1]);
Assert.AreEqual(0.14, A[2]);
Assert.AreEqual(-1 / 12d, A[4]);
#pragma warning disable CS1718 // Comparison made to same variable
Assert.IsTrue(A == A);
Assert.IsTrue(A.Equals(A));
Assert.IsFalse(A != A);
#pragma warning restore CS1718 // Comparison made to same variable
}
/// <summary>
/// Compares scalar multivectors
/// </summary>
/// <param name="A">Scalar Multivector</param>
/// <param name="B">Scalar Multivector</param>
/// <returns>-1 (A < B), 0 (A = B), or 1 (A>B)</returns>
public static int CompareScalarMultivector(Multivector A, Multivector B)
{
int thisLength = A.BasisBlades.Length;
int ILength = B.BasisBlades.Length;
// first get rid of inverse(0) (how can those exist anyway?)
if ((thisLength == 0) && (ILength == 0))
{
return(0);
}
else if ((thisLength == 0) && (ILength > 0))
{
return(-1);
}
else if ((thisLength > 0) && (ILength == 0))
{
return(1);
}
else
{
return(A.BasisBlades[0].SymbolicCompareTo(B.BasisBlades[0]));
}
}
static void Main(string[] args)
{
System.Console.WriteLine("Hello world");
{
ArrayList AL = new ArrayList();
AL.Add(new BasisBlade(1, 1.0, "a1"));
AL.Add(new BasisBlade(2, 1.0, "a2"));
Multivector A = new Multivector(AL);
System.Console.WriteLine("A = " + A.ToString());
ArrayList BL = new ArrayList();
BL.Add(new BasisBlade(2, 1.0, "b1"));
BL.Add(new BasisBlade(3, 1.0, "b2"));
Multivector B = new Multivector(BL);
System.Console.WriteLine("B = " + B.ToString());
Multivector AB = Multivector.gp(A, B);
System.Console.WriteLine("AB = " + AB.ToString());
Symbolic.HashtableSymbolicEvaluator HSE = new Symbolic.HashtableSymbolicEvaluator();
HSE.Add("a1", 3.0);
HSE.Add("a2", -2.0);
HSE.Add("b1", 4.0);
HSE.Add("b2", 1.0);
Multivector ABeval = AB.SymbolicEval(HSE);
System.Console.WriteLine("ABeval = " + ABeval.ToString());
return;
}
Metric M;
try
{
// Conformal metric (no, e1, e2, e3, ni)
/* int N = 5;
* double[] EVM = new double[]{
* -0.707107, -0.707107, 0, 0, 0,
* 0, 0, 0, 0, 1,
* 0, 0, 1, 0, 0,
* 0, 0, 0, -1, 0,
* -0.707107, 0.707107, 0, 0, 0};
*
* double[] EV = new double[] { -1.0, 1.0, 1.0, 1.0, 1.0 };*/
/*// Euclidean metric (e1, e2, e3)
* double[] m = new double[]{
* 1.0, 0.0, 0.0,
* 0.0, 1.0, 0.0,
* 0.0, 0.0, 1.0};*/
// Conformal metric (no, e1, e2, e3, ni)
double[] m = new double[] {
0.0, 0.0, 0.0, 0.0, -1.0,
0.0, 1.0, 0.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 0.0, 1.0, 0.0,
-1.0, 0.0, 0.0, 0.0, 0.0
};
M = new Metric(m);
}
catch (Exception E)
{
System.Console.WriteLine(E.ToString());
return;
}
/*{
* ArrayList AL = new ArrayList();
* AL.Add(new BasisBlade(1 << 3)); // e1
* Multivector A = new Multivector(AL);
*
* ArrayList BL = new ArrayList();
* BL.Add(new BasisBlade(1 << 3)); // e1
* Multivector B = new Multivector(BL);
*
* Multivector V = Multivector.InnerProduct(A, B, M, BasisBlade.InnerProductType.LEFT_CONTRACTION);
*
* System.Console.WriteLine("A = " + A.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* System.Console.WriteLine("B = " + B.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* System.Console.WriteLine("A . B = " + V.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* }*/
/* ArrayList AL = new ArrayList();
* // AL.Add(new BasisBlade(2 + 16, 1.0, "a_e1ni"));
* // AL.Add(new BasisBlade(4 + 16, 1.0, "a_e2ni"));
* // AL.Add(new BasisBlade(8 + 16, 1.0, "a_e3ni"));
* // AL.Add(new BasisBlade(2 + 4, 1.0, "a_e1e2"));
* // AL.Add(new BasisBlade(4 + 8, 1.0, "a_e2e3"));
* // AL.Add(new BasisBlade(8 + 2, 1.0, "a_e1e3"));
* // AL.Add(new BasisBlade(1 + 16, 1.0, "a_noni"));
* AL.Add(new BasisBlade(2 + 16, 1.0));
* AL.Add(new BasisBlade(4 + 16, 2.0));
* AL.Add(new BasisBlade(8 + 16, 3.0));
* AL.Add(new BasisBlade(2 + 4, 4.0));
* AL.Add(new BasisBlade(4 + 8, 5.0));
* AL.Add(new BasisBlade(8 + 2, 6.0));
* Multivector A = new Multivector(AL);
*
* Multivector Aexp = A.Exp(M, false, 0.0);
*
* System.Console.WriteLine("A = " + A.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }) + ",");
* System.Console.WriteLine("expA = " + Aexp.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }) + ",");*/
// Symbolic.HashtableSymbolicEvaluator HSE = new Symbolic.HashtableSymbolicEvaluator();
// HSE.Add("a_e1ni", 1.0);
// HSE.Add("a_e2ni", 2.0);
// HSE.Add("a_e3ni", 3.0);
// HSE.Add("a_e1e2", 4.0);
// HSE.Add("a_e2e3", 5.0);
// HSE.Add("a_e1e3", 6.0);
// HSE.Add("a_noni", 6.0);
// System.Console.WriteLine("A = " + A.SymbolicEval(HSE).ToString(new string[] { "no", "e1", "e2", "e3", "ni" }) + ",");
// System.Console.WriteLine("expA = " + Aexp.SymbolicEval(HSE).ToString(new string[] { "no", "e1", "e2", "e3", "ni" }) + ",");
/* // compute square
* Multivector A2 = Multivector.gp(A, A, M);
* System.Console.WriteLine("A2 = " + A2.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
*
*
* // evaluate with random coords
* Symbolic.RandomSymbolicEvaluator RSE = new Symbolic.RandomSymbolicEvaluator(-100.0, 100.0);
* int pos = 0, neg = 0, zero = 0;
* for (int i = 0; i < 1; i++)
* {
* Multivector MV = A2.SymbolicEval(RSE);
* double val = MV.RealScalarPart();
* System.Console.WriteLine("MV = " + MV);
* System.Console.WriteLine("val = " + val);
* if (val > 1e-7) pos++;
* else if (val < -1e-7) neg++;
* else zero++;
* RSE.reset();
* }
* System.Console.WriteLine("pos = " + pos);
* System.Console.WriteLine("neg = " + neg);
* System.Console.WriteLine("zero = " + zero);*/
/*
* ArrayList AL = new ArrayList();
* AL.Add(new BasisBlade(1 << 0, 1.0, "a_e1"));
* AL.Add(new BasisBlade(1 << 1, 1.0, "a_e2"));
* AL.Add(new BasisBlade(1 << 2, 1.0, "a_e3"));
* Multivector A = new Multivector(AL);
*
* ArrayList BL = new ArrayList();
* BL.Add(new BasisBlade(1 << 0, 1.0, "b_e1"));
* BL.Add(new BasisBlade(1 << 1, 1.0, "b_e2"));
* BL.Add(new BasisBlade(1 << 2, 1.0, "b_e3"));
* Multivector B = new Multivector(BL);
*
* System.Console.WriteLine("A = " + A.ToString());
* System.Console.WriteLine("B = " + B.ToString());
* System.Console.WriteLine("A B = " + Multivector.gp(A, B).ToString());
*/
/*
* BasisBlade Z = new BasisBlade(1 << 0, 1.0, new Object[][] {
* new Object[] { "blah", "aaaarg", 3.0, 2.0, 1 },
* new Object[] { "bloooey", 'x', "crap", true, false},
* new Object[] { "blah", "aaaarg", -10.0, 1 }
* });
*
* System.Console.WriteLine("Z = " + Z.ToString());
* return;*/
// OK: now check for harder objects . . .
/*
* Symbolic.HashtableSymbolicEvaluator HSE = new Symbolic.HashtableSymbolicEvaluator();
* HSE.Add("a_e1", 1.0);
* HSE.Add("a_e2", 2.0);
* HSE.Add("a_e3", 3.0);
* //Symbolic.RandomSymbolicEvaluator HSE = new Symbolic.RandomSymbolicEvaluator(-100.0, 100.0);
*
*
* ArrayList AL = new ArrayList();
* //AL.Add(new BasisBlade(1 << 0, 1.0, "a_no"));
* AL.Add(new BasisBlade(1 << 1, 1.0, "a_e1"));
* AL.Add(new BasisBlade(1 << 2, 1.0, "a_e2"));
* AL.Add(new BasisBlade(1 << 3, 1.0, "a_e3"));
* AL.Add(new BasisBlade(1 << 4, 1.0, "a_e1"));
* Multivector A = new Multivector(AL);
* A = Multivector.gp(A, Symbolic.ScalarOp.Exp(new Multivector(new BasisBlade(0, 1.0, "a_e2"))));
* System.Console.WriteLine("A = " + A.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* // todo: check if exp, etc is working, then check why not collapse (by Multivector simplify, basis blade simplify) to single scalar value . .
* Multivector Ae = A.SymbolicEval(HSE);
* System.Console.WriteLine("Ae = " + Ae.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* return;
*
* ArrayList BL = new ArrayList();
* // BL.Add(new BasisBlade(1 << 0, 1.0));//, "b_no"));
* BL.Add(new BasisBlade(1 << 1, -2.0));//, "b_e1"));
* BL.Add(new BasisBlade(1 << 2, 3.0));//, "b_e2"));
* BL.Add(new BasisBlade(1 << 3, -4.0));//, "b_e3"));
* // BL.Add(new BasisBlade(1 << 4, 1.0));//, "b_ni"));
* Multivector B = new Multivector(BL);
*
*
* A = Multivector.op(A, B);
*
* B = Multivector.gp(A, A);
*
* System.Console.WriteLine("A = " + A.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* System.Console.WriteLine("B = " + B.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
*
* // how to know whether outcome of symbolic computation is positive, negative or zero???
* // simply fill in values for random variables?
*
*
* //Multivector unitA = A.Unit_r(M);
* //System.Console.WriteLine("unitA = " + unitA.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
*/
/* Multivector ApAgB = Multivector.Add(Multivector.Add(A, Multivector.gp(A, B, M)), Multivector.gp(Multivector.GetPseudoscalar(4), 0.01));
*
* // still testing . . .
* System.Console.WriteLine("ApAgB = " + ApAgB.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* int g = ApAgB.LargestGradePartIndex();
*
* System.Console.WriteLine("Largest grade part = " + g);
* System.Console.WriteLine("Largest grade part = " + ApAgB.ExtractGrade(g).ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
*
* System.Console.WriteLine("Top grade part = " + ApAgB.TopGradePartIndex(0.02));*/
/*
* BasisBlade se1 = new BasisBlade(1 << 1, 1.0, "ae1");
* BasisBlade se2 = new BasisBlade(1 << 2, 1.0, "ae2");
* BasisBlade X = BasisBlade.op(se1, se2);
* System.Console.WriteLine("se1 = " + se1);
* System.Console.WriteLine("se2 = " + se2);
* System.Console.WriteLine("X = " + X);
*/
/*
* Multivector no = new Multivector(new BasisBlade(1, 1.0));
* Multivector ni = new Multivector(new BasisBlade(1 << 4, 1.0));
* Multivector noni = Multivector.GeometricProduct(no, ni, M);
*
* System.Console.WriteLine("no = " + no.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* System.Console.WriteLine("ni = " + ni.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* System.Console.WriteLine("noni = " + noni.ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* System.Console.WriteLine("noni2 = " + noni.ExtractGrade(2).ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
* System.Console.WriteLine("dual(noni) = " + noni.Dual(M).ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
*
* System.Console.WriteLine("dual(I) = " + Multivector.GetPseudoscalar(5).Dual(M).ToString(new string[] { "no", "e1", "e2", "e3", "ni" }));
*/
/*BasisBlade no = new BasisBlade(1);
* BasisBlade ni = new BasisBlade(1 << 4);
*
* System.Console.WriteLine("no = " + no);
* System.Console.WriteLine("ni = " + ni);
*
* System.Collections.ArrayList L = BasisBlade.GeometricProduct(ni, no, M);
* System.Console.WriteLine("L = " + BasisBlade.ToString(L, new string[] {"no", "e1", "e2", "e3", "ni"}));
*/
/*
* BasisBlade A = new BasisBlade(1 | 4, 2.0);
* BasisBlade B = new BasisBlade(2, 2.0);
* BasisBlade C = new BasisBlade(1 | 4, 3.0);
* BasisBlade D =new BasisBlade(1, 1.0);
* System.Collections.ArrayList L = new System.Collections.ArrayList();
* L.Add(A); L.Add(B); L.Add(C); L.Add(D); L.Add(new BasisBlade(2 | 4, 2.0));
*
* System.Console.WriteLine("Before: ");
* foreach (BasisBlade BB in L)
* {
* System.Console.WriteLine(BB.ToString());
* }
* L = BasisBlade.Simplify(L);
* System.Console.WriteLine("After: ");
* foreach (BasisBlade BB in L)
* {
* System.Console.WriteLine(BB.ToString());
* }
*/
// System.Console.WriteLine("A = " + A);
// System.Console.WriteLine("B = " + B); // .ToString(new string[] { "no", "e1", "ni" })
// System.Console.WriteLine("A ^ B = " + (A ^ B));
/* try
* {
* double[][] MA = new double[][]{
* new double[]{0.0, 0.0, 0.0, 0.0, -1.0},
* new double[]{0.0, 1.0, 0.0, 0.0, 0.0},
* new double[]{0.0, 0.0, 1.0, 0.0, 0.0},
* new double[]{0.0, 0.0, 0.0, 1.0, 0.0},
* new double[]{-1.0, 0.0, 0.0, 0.0, 0.0}};
* new Metric(MA);
* }
* catch (Exception E)
* {
* System.Console.WriteLine(E.ToString());
* }*/
/*
*
* double[] A = new double[]{
* 1.0, 0.0, 0.0,
* 0.0, 1.0, 0.0,
* 0.0, 0.0, 1.0};
* int nbRows = 3;
* int nbColumns = 3;
* bool columnWise = false;
* dnAnalytics.LinearAlgebra.Matrix M = dnAnalytics.LinearAlgebra.MatrixBuilder.CreateMatrix(A, nbRows, nbColumns, columnWise);
*
* System.Console.WriteLine("Hi hoi!" + M);
*
*/
}
/// <summary>
/// Substitutes all symbolic scalars for doubles (as evaluated by <paramref name="E"/>)
/// and evaluates the symbolic ScalarOps. E.g. sqrt(2.0) would evaluate to 1.4142...
/// </summary>
/// <param name="E">SymbolicEvaluator used to evaluate the symbolic scalars</param>
/// <returns></returns>
public double SymbolicEval(RefGA.Symbolic.SymbolicEvaluator E)
{
Multivector V = m_value.SymbolicEval(E);
if (!V.IsScalar())
{
throw new ArgumentException("UnaryScalarOp.SymbolicEval: argument is not scalar");
}
double v = V.RealScalarPart();
if (m_opName == INVERSE)
{
if (v == 0.0)
{
throw new ArgumentException("UnaryScalarOp.SymbolicEval: divide by zero");
}
return(1.0 / v);
}
else if (m_opName == SQRT)
{
if (v < 0.0)
{
throw new ArgumentException("UnaryScalarOp.SymbolicEval: square root of negative value");
}
else
{
return(Math.Sqrt(v));
}
}
else if (m_opName == EXP)
{
return(Math.Exp(v));
}
else if (m_opName == LOG)
{
if (v <= 0.0)
{
throw new ArgumentException("UnaryScalarOp.SymbolicEval: logarithm of value <= 0");
}
else
{
return(Math.Log(v));
}
}
else if (m_opName == SIN)
{
return(Math.Sin(v));
}
else if (m_opName == COS)
{
return(Math.Cos(v));
}
else if (m_opName == TAN)
{
// how to detect bad input (1/2 pi, etc)?
return(Math.Tan(v));
}
else if (m_opName == SINH)
{
return(Math.Sinh(v));
}
else if (m_opName == COSH)
{
return(Math.Cosh(v));
}
else if (m_opName == TANH)
{
return(Math.Tanh(v));
}
else if (m_opName == ABS)
{
return(Math.Abs(v));
}
else
{
throw new ArgumentException("UnaryScalarOp.SymbolicEval: unknown opname " + m_opName);
}
}
/// <summary>
/// Evaluates a Multivector to a summary of its expected value (-1, 0, 1).
/// The function uses a Symbolic.RandomSymbolicEvaluator to randomly evaluate
/// <paramref name="A"/>. If the results are consistently negative, zero or
/// positive then -1, 0 or 1 is returned. Otherwise an exception is thrown.
/// </summary>
/// <param name="A">The multivector to evaluate</param>
/// <returns>-1, 0 or 1</returns>
/// <remarks>
/// Used by Multivector.Exp(), Multivector.Cos() and Multivector.Sin() to see
/// if the input bivector has a scalar square.
/// </remarks>
public static double EvaluateRandomSymbolicToScalar(Multivector A)
{
double EPS = 1e-4;
int NB_ITER = 100;
int REQ = 98;
Symbolic.RandomSymbolicEvaluator RSE = new Symbolic.RandomSymbolicEvaluator(-100.0, 100.0);
int pos = 0, neg = 0, zero = 0;
for (int i = 0; i < NB_ITER; i++)
{
Multivector E = A.SymbolicEval(RSE);
double scalarPart = E.RealScalarPart();
Multivector theRest = Multivector.Subtract(E, scalarPart);
if (Math.Abs(theRest.Norm_e().RealScalarPart()) > Math.Abs(scalarPart) * EPS)
throw new Exception("Multivector did not evaluate to scalar");
if (scalarPart > EPS) pos++;
else if (scalarPart < -EPS) neg++;
else zero++;
}
if (pos >= REQ) return 1.0;
else if (zero >= REQ) return 0.0;
else if (neg >= REQ) return -1.0;
else throw new Exception("Multivector did not evaluate to a consistent value");
}
/// <summary>Used to construct a scalar operations</summary>
/// <param name="operationName">The name of the operation (e.g. "inverse", "sqrt", "log"; use one of the supplied constants like INVERSE, SQRT or LOG.)</param>
/// <param name="A">The value upon which the ScalarOp will operate.
/// Only the scalarpart is used of A is used.</param>
public UnaryScalarOp(string operationName, Multivector A)
{
m_opName = operationName;
m_value = A.ScalarPart();
}
/// <returns>Multivector(inverse(A))</returns>
public static Multivector Inverse(Multivector A)
{
return(new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(INVERSE, A))));
}
/// <returns>Multivector(sqrt(A))</returns>
public static Multivector Sqrt(Multivector A)
{
return(new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(SQRT, A))));
}
/// <summary>Used to construct a scalar operations</summary>
/// <param name="operationName">The name of the operation (e.g. "atan2"; use one of the supplied constants like ATAN2.)</param>
/// <param name="A">The first operand. Only the scalarpart is used.</param>
/// <param name="B">The second operand. Only the scalarpart is used.</param>
public BinaryScalarOp(string operationName, Multivector A, Multivector B)
{
m_opName = operationName;
m_value1 = A.ScalarPart();
m_value2 = B.ScalarPart();
}
/// <summary>Used to construct a scalar operations</summary>
/// <param name="operationName">The name of the operation (e.g. "inverse", "sqrt", "log"; use one of the supplied constants like INVERSE, SQRT or LOG.)</param>
/// <param name="A">The value upon which the ScalarOp will operate.
/// Only the scalarpart is used of A is used.</param>
public UnaryScalarOp(string operationName, Multivector A)
{
m_opName = operationName;
m_value = A.ScalarPart();
}
/// <returns>Multivector(sqrt(A))</returns>
public static Multivector Sqrt(Multivector A)
{
return new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(SQRT, A)));
}
/// <returns>Multivector(cosh(A))</returns>
public static Multivector Cosh(Multivector A)
{
return new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(COSH, A)));
}
/// <returns>Multivector(tan(A))</returns>
public static Multivector Tan(Multivector A)
{
return(new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(TAN, A))));
}
/// <returns>Multivector(cos(A))</returns>
public static Multivector Cos(Multivector A)
{
return(new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(COS, A))));
}
/// <returns>Multivector(log(A))</returns>
public static Multivector Log(Multivector A)
{
return(new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(LOG, A))));
}
/// <returns>Multivector(exp(A))</returns>
public static Multivector Exp(Multivector A)
{
return(new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(EXP, A))));
}
/// <returns>Multivector(inverse(A))</returns>
public static Multivector Inverse(Multivector A)
{
return new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(INVERSE, A)));
}
public void SetUp()
{
M["GeneralMultivector3"] = new Multivector(R3)
{
[EScalar] = 2 / 13d,
[E1] = 5,
[E2] = -3,
[E13] = 2 * PI,
[E123] = 42
};
M["Vector3A"] = new Multivector(R3)
{
[E1] = 4,
[E2] = 3,
[E3] = 5
};
M["Vector3B"] = new Multivector(R3)
{
[E1] = 3.5,
[E2] = 0.14,
[E3] = -1 / 12d
};
M["Vector3C"] = new Multivector(R3)
{
[E2] = 8,
[E3] = -7
};
M["GeneralMultivector4"] = new Multivector(R4)
{
[EScalar] = 5 / 3d,
[E1] = 12,
[E3] = -45,
[E14] = 3 / 5d,
[E23] = -6.2832,
[E34] = 1,
[E124] = -3,
[E134] = 86,
[E1234] = -5
};
M["Vector4A"] = new Multivector(R4)
{
[E1] = 5,
[E2] = -3,
[E3] = 9,
[E4] = -14
};
M["Vector4B"] = new Multivector(R4)
{
[E1] = 21,
[E3] = 3
};
M["Vector4C"] = new Multivector(R4)
{
[E2] = -6,
[E3] = -5,
[E4] = 4
};
/*
* M["Big"] = new Multivector(R7)
* {
* [E()] = 8,
* [E(7)] = 4,
* [E(1, 5)] = 42,
* [E(5, 3, 7)] = -99,
* [E(1, 2, 3, 4, 5, 7)] = 222
* };
*
* M["BigSparse"] = new SparseMultivector(R7)
* {
* [E()] = -8,
* [E(7)] = -4,
* [E(1, 6)] = 2,
* [E(5, 3, 7)] = -1,
* [E(1, 2, 3, 4, 5, 6, 7)] = -0.2
* };
*
* M["GiantSparse"] = new SparseMultivector(R30)
* {
* [E()] = 1,
* [E(1, 29)] = 2,
* [E(8, 13, 15, 30)] = -3,
* [E(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)] = 4.2,
* [E(1,2,3,4,5,6,7,8,9,10,11,12,13,4)] = 640
* };
*/
}
/// <returns>Multivector(tanh(A))</returns>
public static Multivector Tanh(Multivector A)
{
return new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(TANH, A)));
}
/// <summary>Used to construct a scalar operations</summary>
/// <param name="operationName">The name of the operation (e.g. "atan2"; use one of the supplied constants like ATAN2.)</param>
/// <param name="A">The first operand. Only the scalarpart is used.</param>
/// <param name="B">The second operand. Only the scalarpart is used.</param>
public BinaryScalarOp(string operationName, Multivector A, Multivector B)
{
m_opName = operationName;
m_value1 = A.ScalarPart();
m_value2 = B.ScalarPart();
}
/// <returns>Multivector(abs(A))</returns>
public static Multivector Abs(Multivector A)
{
return new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(ABS, A)));
}
/// <returns>Multivector(inverse(A))</returns>
public static Multivector Atan2(Multivector A, Multivector B)
{
return(new Multivector(new BasisBlade(0, 1.0, new BinaryScalarOp(ATAN2, A, B))));
}
/// <returns>Multivector(inverse(A))</returns>
public static Multivector Atan2(Multivector A, Multivector B)
{
return new Multivector(new BasisBlade(0, 1.0, new BinaryScalarOp(ATAN2, A, B)));
}
/// <returns>Multivector(sinh(A))</returns>
public static Multivector Sinh(Multivector A)
{
return(new Multivector(new BasisBlade(0, 1.0, new UnaryScalarOp(SINH, A))));
}
