public void RectangularToPolarTransformation()
{
Span <Number> cc = new Number[] { 1, Math.Sqrt(3) };
Span <Number> hcBuffer = new Number[1];
HypersphericalCoordinate hc = cc.ToSpherical(in hcBuffer);
hc.DimensionsCount.AssertIsEqualTo(2);
hc.R.AssertIsEqualTo(2d);
const double φ = Math.PI / 3; // x to r
hc.Angles.Span.Single().AssertIsEqualTo(φ);
Span <Number> cv = stackalloc Number[2];
hc.ToCartesian(in cv);
Span <Number> derivatives = stackalloc Number[2];
hc.DerivativeByR(in derivatives);
derivatives[0].AssertIsEqualTo(0.5); // x
derivatives[1].AssertIsEqualTo(Math.Sqrt(3) / 2); // y
cv.AssertSequenceEqualsTo(cc);
VerifyCartesianCoordinateAngle(hc, cc);
}
public void CubeToSphericalTransformation()
{
Span <Number> cc = new Number[] { 1, Math.Sqrt(2), 2 * Math.Sqrt(3) };
Span <Number> hcBuffer = new Number[2];
HypersphericalCoordinate hc = cc.ToSpherical(hcBuffer);
hc.DimensionsCount.AssertIsEqualTo(3);
hc.R.AssertIsEqualTo(cc.GetVectorLength());
double φ = (double)hc.Angles.Span[0]; // r to y
double θ = (double)hc.Angles.Span[1]; // r to xy
Span <Number> derivatives = stackalloc Number[3];
hc.DerivativeByR(in derivatives);
derivatives[0].AssertIsEqualTo(Math.Cos(θ) * Math.Cos(φ)); // x
derivatives[1].AssertIsEqualTo(Math.Cos(θ) * Math.Sin(φ)); // y
derivatives[2].AssertIsEqualTo(Math.Sin(θ)); // z
Span <Number> cv = stackalloc Number[3];
hc.ToCartesian(in cv);
cv.AssertSequenceEqualsTo(cc);
VerifyCartesianCoordinateAngle(hc, cc);
}
public void CubeToSphericalTransformation_Known()
{
Span <Number> cc = new Number[] { Math.Sqrt(2), Math.Sqrt(2), 2 * Math.Sqrt(3) };
const double φ = Math.PI / 4; // x to r(xy)
const double θ = Math.PI / 3; // xy to r
Span <Number> hcBuffer = new Number[2];
HypersphericalCoordinate hc = cc.ToSpherical(hcBuffer);
hc.DimensionsCount.AssertIsEqualTo(3);
hc.R.AssertIsEqualTo(4d);
hc.Angles.Span[0].AssertIsEqualTo(φ);
hc.Angles.Span[1].AssertIsEqualTo(θ);
Span <Number> derivatives = stackalloc Number[3];
hc.DerivativeByR(in derivatives);
derivatives[0].AssertIsEqualTo(Math.Sqrt(2) / 4); // x
derivatives[1].AssertIsEqualTo(Math.Sqrt(2) / 4); // y
derivatives[2].AssertIsEqualTo(Math.Sqrt(3) / 2); // z
Span <Number> cv = new Number[3];
hc.ToCartesian(in cv);
cv.AssertSequenceEqualsTo(cc);
}
public void TranslateByAngle()
{
Span <Number> buffer = new Number[3];
HypersphericalCoordinate coordinate = new HypersphericalCoordinate(2, new Number[] { 2, 1, -1 });
coordinate.TranslateSelf(HypersphericalAngleVector.CreateOrthogonalDirection(1, 0.5, in buffer));
coordinate.AssertIsEqualTo(new HypersphericalCoordinate(2, new Number[] { 2, 1.5, -1 }));
}
public void Constructor_3d()
{
var hc = new HypersphericalCoordinate(3, new Number[] { 1, 0.5 });
hc.DimensionsCount.AssertIsEqualTo(3);
hc.R.AssertIsEqualTo(3d);
hc.Angles.Span.AssertSequenceEqualsTo(new Number[] { 1, 0.5 });
}
public void Cast_PolarCoordinates()
{
var pc = new PolarCoordinate(3, 1);
HypersphericalCoordinate hc = pc;
hc.DimensionsCount.AssertIsEqualTo(2);
hc.R.AssertIsEqualTo(3);
hc.Angles.Span.Single().AssertIsEqualTo(1);
}
public void Cast_ToCartesian(double[] cartesian, double r, double[] angles)
{
var sc = new HypersphericalCoordinate(r, angles.ToNumberArray());
Span <Number> cc = stackalloc Number[cartesian.Length];
sc.ToCartesian(in cc);
cc.AssertSequenceEqualsTo(cartesian);
}
public void Cast_ToHyperspherical(double[] cartesian, double r, double[] angles)
{
Span <Number> cc = cartesian.ToNumberArray();
Span <Number> buffer = stackalloc Number[cartesian.Length - 1];
HypersphericalCoordinate sc = cc.ToSpherical(in buffer);
sc.R.AssertIsEqualTo(r);
sc.Angles.Span.AssertSequenceEqualsTo(angles);
}
public void HypersphericalCoordinate_GetValidTranslation_fullRadius_cutAngle()
{
HypersphericalCoordinate hc = new HypersphericalCoordinate(1, new Number[] { Angle.HalfRightAngle });
ReadOnlySpan <Number> expected = new Number[] { Angle.HalfRightAngle };
HypersphericalAngleVector current = new Number[] { Angle.RightAngle };
_range.GetValidTranslationForLastAngle(hc, in current);
current.Span.AssertSequenceEqualsTo(expected);
}
public void HypersphericalCoordinate_GetValidTranslation_cutRadius()
{
double r = 2 * Math.Sqrt(3) / 3;
HypersphericalCoordinate hc = new HypersphericalCoordinate(r, new Number[] { Angle.HalfRightAngle });
ReadOnlySpan <Number> expected = new Number[] { Angle.HalfCycle / 2 / 6 };
HypersphericalAngleVector current = new Number[] { Angle.HalfRightAngle };
_range.GetValidTranslationForLastAngle(hc, in current);
current.Span.AssertSequenceEqualsTo(expected);
}
private static PolynomialDivision GetSum(uint inputCount)
{
var cartesianInputs = Number.Terms(inputCount).ToArray();
Number[] cartesianPoint = cartesianInputs;
var sphericalPoint = new HypersphericalCoordinate((PolynomialTerm)'R', Number.GreekTerms(inputCount - 1).ToArray());
Number product = cartesianInputs.SumDefensive();
return((PolynomialDivision)product.ToSpherical(cartesianPoint, sphericalPoint));
}
public void AddDimension_ToCartesian(double[] cartesian, double r, double[] angles)
{
HypersphericalCoordinate sc = new HypersphericalCoordinate(r, angles.ToNumberArray());
Span <Number> scBuffer = new Number[sc.Angles.Length + 1];
HypersphericalCoordinate scWithExtraDimension = sc.Clone(in scBuffer);
Span <Number> ccActual = stackalloc Number[cartesian.Length + 1];
scWithExtraDimension.ToCartesian(in ccActual);
ccActual.AssertSequenceEqualsTo(cartesian.Append(0).ToArray());
}
private static void VerifyCartesianCoordinateAngle(HypersphericalCoordinate hc, ReadOnlySpan <Number> cc)
{
Span <Number> hcBuffer = new Number[hc.Angles.Length];
Span <Number> axisCc = new Number[cc.Length];
for (ushort pos = 0; pos < cc.Length; ++pos)
{
var cartesianCoordinatesAngles = HypersphericalCoordinate.CartesianCoordinatesAngle(pos, in hcBuffer);
new HypersphericalCoordinate(hc.R, cartesianCoordinatesAngles).ToCartesian(in axisCc);
axisCc[pos].AssertIsEqualTo(hc.R);
axisCc.IsOrthogonal().AssertIsTrue();
}
}
public void Cast_HyperspehricalEqualsRectangular(double x, double y)
{
var rc = new RectangularCoordinate(x, y);
Span <Number> cc = new Number[] { x, y };
Span <Number> buffer = stackalloc Number[1];
var pc = rc.ToPolar();
HypersphericalCoordinate sc = cc.ToSpherical(in buffer);
sc.DimensionsCount.AssertIsEqualTo(2);
sc.R.AssertIsEqualTo(pc.R);
sc.Angles.Span.Single().AssertIsEqualTo(pc.Φ);
}
public void ToSpherical_Generalizes_ToPolar()
{
Number expression = (x - y).ToPower(2);
var rc = new RectangularCoordinate(x, y);
var pc = new PolarCoordinate(r, φ);
var expected = expression.ToPolar(rc, pc);
var cc = new Number[] { x, y };
var hc = new HypersphericalCoordinate(r, new Number[] { φ });
var actual = expression.ToSpherical(cc, hc);
expected.AssertIsEqualTo(actual);
}
private static void EqualityAfterTransformation(PolynomialDivision polynomial)
{
var cartesianPoint = new Number[] { Term.x, Term.y, Term.z };
var sphericalPoint = new HypersphericalCoordinate(Term.r, new Number[] { Term.θ, Term.φ });
PolynomialDivision sphericalPolynomial = polynomial.ToSpherical(cartesianPoint, sphericalPoint);
double sqrt2 = Math.Sqrt(2);
double sqrt3 = Math.Sqrt(3);
Number polynomialResult = polynomial.GetOperation(Term.x, Term.y, Term.z).Value(sqrt2, sqrt2, 2 * sqrt3);
double sphericalResult = sphericalPolynomial.GetOperation(Term.r, Term.θ, Term.φ).Value(4, Math.PI / 4, Math.PI / 3);
polynomialResult.AssertIsEqualTo(sphericalResult);
}
public void ConversationCircle()
{
Span <Number> cc = new Number[] { 1, 2, 3, 4 };
Span <Number> hcBuffer = stackalloc Number[3];
HypersphericalCoordinate hc = cc.ToSpherical(in hcBuffer);
hc.DimensionsCount.AssertIsEqualTo(cc.Length);
Span <Number> cc2 = stackalloc Number[4];
hc.ToCartesian(in cc2);
cc2.AssertSequenceEqualsTo(cc);
}
public void AddDimension_ToSpherical(double[] cartesian, double r, double[] angles)
{
HypersphericalCoordinate sc = new HypersphericalCoordinate(r, angles.ToNumberArray());
Span <Number> scBuffer = new Number[sc.Angles.Length + 1];
HypersphericalCoordinate scWithExtraDimension = sc.Clone(in scBuffer);
Span <Number> ccWithExtraDimension = stackalloc Number[cartesian.Length + 1];
ccWithExtraDimension.Clear();
cartesian.ToNumberArray().CopyTo(ccWithExtraDimension);
Span <Number> scBuffer2 = new Number[sc.Angles.Length + 1];
HypersphericalCoordinate scActual = ccWithExtraDimension.ToSpherical(in scBuffer);
scActual.AssertIsEqualTo(in scWithExtraDimension);
}
public void DerivativeByR()
{
var cartesianPoint = new Number[] { x, y, z };
var sphericalPoint = new HypersphericalCoordinate(r, new Number[] { θ, φ });
Span <Number> cartesianActual = new Number[3];
sphericalPoint.ToCartesian(in cartesianActual);
Span <Number> derivatives = new Number[cartesianPoint.Length];
sphericalPoint.DerivativeByR(in derivatives);
for (ushort dimensionPos = 0; dimensionPos < cartesianPoint.Length; ++dimensionPos)
{
var symbol = (PolynomialDivision)cartesianPoint[dimensionPos];
(r * derivatives[dimensionPos]).AssertIsEqualTo(symbol.ToSpherical(cartesianPoint, sphericalPoint));
}
}
public void GetCartesianAxisViewsRatiosDerivativesByAngle()
{
var sphericalPoint = new HypersphericalCoordinate(r, new Number[] { α, β, γ, δ });
Span <Number> cartesianActual = new Number[5];
sphericalPoint.ToCartesian(in cartesianActual);
for (ushort anglePos = 0; anglePos < sphericalPoint.Angles.Length; ++anglePos)
{
PolynomialTerm angleTerm = (PolynomialTerm)sphericalPoint.Angles.Span[anglePos];
var derivatives = new HypersphericalCoordinateOnAxisViewForAngleDerivatives(sphericalPoint, anglePos: anglePos).DerivativesCartesianVector;
derivatives.Length.AssertIsEqualTo(sphericalPoint.DimensionsCount);
for (ushort coordinatePos = 0; coordinatePos < cartesianActual.Length; ++coordinatePos)
{
PolynomialDivision coordinate = (PolynomialDivision)cartesianActual[coordinatePos];
PolynomialDivision expected = coordinate.DerivativeBy(angleTerm);
derivatives[coordinatePos].AssertIsEqualTo(expected);
}
}
}
public void HypersphericalCoordinate_IsValidTranslation_false()
{
HypersphericalCoordinate hc = new HypersphericalCoordinate(1, new Number[] { Angle.HalfRightAngle });
_range.IsValidTranslation(hc, new Number[] { Angle.RightAngle }).AssertIsFalse();
}
