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(); }