tsai
/
mathnet-numerics
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Math.NET Numerics
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
442 Commits
25 Branches
121 Tags
187 MiB
 
 
 
Tree: 7caa9b1110
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7caa9b1110'
${ noResults }
mathnet-numerics/src/UnitTests/TrigonometryTest.cs

724 lines
34 KiB
Raw Blame History

// <copyright file="TrigonometryTest.cs" company="Math.NET">
// Math.NET Numerics, part of the Math.NET Project
// http://numerics.mathdotnet.com
// http://github.com/mathnet/mathnet-numerics
// http://mathnetnumerics.codeplex.com
//
// Copyright (c) 2009-2010 Math.NET
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
// </copyright>
namespace MathNet.Numerics.UnitTests
{
using System;
using System.Numerics;
using MbUnit.Framework;
[TestFixture]
public class TrigonometryTest
{
[Test]
[Row(0.0, 0.0, 1.0, 0.0)]
[Row(8.388608e6, 0.0, -0.90175467375875928, 0.0)]
[Row(-8.388608e6, 0.0, -0.90175467375875928, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 0.99999999999999289, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, 0.99999999999999289, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, -0.90175467375876572, -5.1528001100635277e-8)]
[Row(-1.19209289550780998537e-7, -8.388608e6, double.PositiveInfinity, double.NegativeInfinity)]
public void CanComputeComplexCosine(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).Cosine();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 13);
}
[Test]
[Row(0.0, 0.0, 0.0, 0.0)]
[Row(8.388608e6, 0.0, 0.43224820225679778, 0.0)]
[Row(-8.388608e6, 0.0, -0.43224820225679778, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.19209289550780998537e-7, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -1.19209289550780998537e-7, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 0.43224820225680083, -1.0749753400787824e-7)]
[Row(-1.19209289550780998537e-7, -8.388608e6, double.NegativeInfinity, double.NegativeInfinity)]
public void CanComputeComplexSine(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).Sine();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 13);
}
[Test]
[Row(0.0, 0.0, 0.0, 0.0)]
[Row(8.388608e6, 0.0, -0.47934123862654288, 0.0)]
[Row(-8.388608e6, 0.0, 0.47934123862654288, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.1920928955078157e-7, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -1.1920928955078157e-7, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, -0.47934123862653449, 1.4659977233982276e-7)]
[Row(-8.388608e6, -1.19209289550780998537e-7, 0.47934123862653449, -1.4659977233982276e-7)]
public void CanComputeComplexTangent(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).Tangent();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 13);
}
[Test]
[Row(0.0, double.PositiveInfinity)]
[Row(8388608, 2.3134856195559191)]
[Row(1.19209289550780998537e-7, 8388608.0000000376)]
[Row(-8388608, -2.3134856195559191)]
[Row(-1.19209289550780998537e-7, -8388608.0000000376)]
public void CanComputeCosecant(double value, double expected)
{
var actual = Trig.Cosecant(value);
AssertHelpers.AlmostEqual(expected, actual, 13);
}
[Test]
[Row(0.0, 1.0)]
[Row(8388608, -0.90175467375875928)]
[Row(1.19209289550780998537e-7, 0.99999999999999289)]
[Row(-8388608, -0.90175467375875928)]
[Row(-1.19209289550780998537e-7, 0.99999999999999289)]
public void CanComputeCosine(double value, double expected)
{
var actual = Trig.Cosine(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, double.PositiveInfinity)]
[Row(8388608, -2.086196470108229)]
[Row(1.19209289550780998537e-7, 8388607.999999978)]
[Row(-8388608, 2.086196470108229)]
[Row(-1.19209289550780998537e-7, -8388607.999999978)]
public void CanComputeCotangent(double value, double expected)
{
var actual = Trig.Cotangent(value);
AssertHelpers.AlmostEqual(expected, actual, 13);
}
[Test]
[Row(0.0, double.PositiveInfinity)]
[Row(8388608, 1.3670377960148449e-3643126)]
[Row(1.19209289550780998537e-7, 8388607.9999999978)]
[Row(-8388608, -1.3670377960148449e-3643126)]
[Row(-1.19209289550780998537e-7, -8388607.9999999978)]
public void CanComputeHyperbolicCosecant(double value, double expected)
{
var actual = Trig.HyperbolicCosecant(value);
AssertHelpers.AlmostEqual(expected, actual, 15);
}
[Test]
[Row(0.0, 1.0)]
[Row(8388608, double.PositiveInfinity)]
[Row(1.19209289550780998537e-7, 1.0000000000000071)]
[Row(-8388608, double.PositiveInfinity)]
[Row(-1.19209289550780998537e-7, 1.0000000000000071)]
public void CanComputeHyperbolicCosine(double value, double expected)
{
var actual = Trig.HyperbolicCosine(value);
AssertHelpers.AlmostEqual(expected, actual, 15);
}
[Test]
[Row(0.0, double.PositiveInfinity)]
[Row(8388608, 1.0)]
[Row(1.19209289550780998537e-7, 8388608.0000000574)]
[Row(-8388608, -1.0)]
[Row(-1.19209289550780998537e-7, -8388608.0000000574)]
public void CanComputeHyperbolicCotangent(double value, double expected)
{
var actual = Trig.HyperbolicCotangent(value);
AssertHelpers.AlmostEqual(expected, actual, 15);
}
[Test]
[Row(0.0, 1.0)]
[Row(8388608, 1.3670377960148449e-3643126)]
[Row(1.19209289550780998537e-7, 0.99999999999999289)]
[Row(-8388608, 1.3670377960148449e-3643126)]
[Row(-1.19209289550780998537e-7, 0.99999999999999289)]
public void CanComputeHyperbolicSecant(double value, double expected)
{
var actual = Trig.HyperbolicSecant(value);
AssertHelpers.AlmostEqual(expected, actual, 15);
}
[Test]
[Row(8388608, double.PositiveInfinity)]
[Row(1.19209289550780998537e-7, 1.1920928955078128e-7)]
[Row(-8388608, double.NegativeInfinity)]
[Row(-1.19209289550780998537e-7, -1.1920928955078128e-7)]
public void CanComputeHyperbolicSine(double value, double expected)
{
var actual = Trig.HyperbolicSine(value);
AssertHelpers.AlmostEqual(expected, actual, 15);
}
[Test]
[Row(0.0, 0.0)]
[Row(8388608, 1.0)]
[Row(1.19209289550780998537e-7, 1.1920928955078043e-7)]
[Row(-8388608, -1.0)]
[Row(-1.19209289550780998537e-7, -1.1920928955078043e-7)]
public void CanComputeHyperbolicTangent(double value, double expected)
{
var actual = Trig.HyperbolicTangent(value);
AssertHelpers.AlmostEqual(expected, actual, 15);
}
[Test]
[Row(8388608, 1.1920928955078097e-7)]
[Row(-8388608, -1.1920928955078097e-7)]
[Row(1, 1.5707963267948966)]
[Row(-1, -1.5707963267948966)]
public void CanComputeInverseCosecant(double value, double expected)
{
var actual = Trig.InverseCosecant(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(1, 0)]
[Row(-1, 3.1415926535897931)]
[Row(1.19209289550780998537e-7, 1.570796207585607)]
[Row(-1.19209289550780998537e-7, 1.5707964460041861)]
public void CanComputeInverseCosine(double value, double expected)
{
var actual = Trig.InverseCosine(value);
AssertHelpers.AlmostEqual(expected, actual, 15);
}
[Test]
[Row(0.0, 1.5707963267948966)]
[Row(8388608, 1.1920928955078069e-7)]
[Row(-8388608, -1.1920928955078069e-7)]
[Row(1.19209289550780998537e-7, 1.5707962075856071)]
[Row(-1.19209289550780998537e-7, -1.5707962075856071)]
public void CanComputeInverseCotangent(double value, double expected)
{
var actual = Trig.InverseCotangent(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, double.PositiveInfinity)]
[Row(8388608, 1.1920928955078097e-7)]
[Row(-8388608, -1.1920928955078097e-7)]
[Row(1.19209289550780998537e-7, 16.635532333438693)]
[Row(-1.19209289550780998537e-7, -16.635532333438693)]
public void CanComputeInverseHyperbolicCosecant(double value, double expected)
{
var actual = Trig.InverseHyperbolicCosecant(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(1.0, 0.0)]
[Row(8388608, 16.635532333438682)]
public void CanComputeInverseHyperbolicCosine(double value, double expected)
{
var actual = Trig.InverseHyperbolicCosine(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(8388608, 1.1920928955078181e-7)]
[Row(-8388608, -1.1920928955078181e-7)]
[Row(1, double.PositiveInfinity)]
[Row(-1, double.NegativeInfinity)]
public void CanComputeInverseHyperbolicCotangent(double value, double expected)
{
var actual = Trig.InverseHyperbolicCotangent(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0, double.PositiveInfinity)]
[Row(.5, 1.3169578969248167)]
[Row(1, 0.0)]
public void CanComputeInverseHyperbolicSecant(double value, double expected)
{
var actual = Trig.InverseHyperbolicSecant(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0)]
[Row(8388608, 16.63553233343869)]
[Row(-8388608, -16.63553233343869)]
[Row(1.19209289550780998537e-7, 1.1920928955078072e-7)]
[Row(-1.19209289550780998537e-7, -1.1920928955078072e-7)]
public void CanComputeInverseHyperbolicSine(double value, double expected)
{
var actual = Trig.InverseHyperbolicSine(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0)]
[Row(1.0, double.PositiveInfinity)]
[Row(-1.0, double.NegativeInfinity)]
[Row(1.19209289550780998537e-7, 1.19209289550780998537e-7)]
[Row(-1.19209289550780998537e-7, -1.19209289550780998537e-7)]
public void CanComputeInverseHyperbolicTangent(double value, double expected)
{
var actual = Trig.InverseHyperbolicTangent(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(8388608, 1.5707962075856071)]
[Row(-8388608, 1.5707964460041862)]
[Row(1.0, 0.0)]
[Row(-1.0, 3.1415926535897932)]
public void CanComputeInverseSecant(double value, double expected)
{
var actual = Trig.InverseSecant(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0)]
[Row(1.0, 1.5707963267948966)]
[Row(-1.0, -1.5707963267948966)]
[Row(1.19209289550780998537e-7, 1.1920928955078128e-7)]
[Row(-1.19209289550780998537e-7, -1.1920928955078128e-7)]
public void CanComputeInverseSine(double value, double expected)
{
var actual = Trig.InverseSine(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0)]
[Row(8388608, 1.570796207585607)]
[Row(-8388608, -1.570796207585607)]
[Row(1.19209289550780998537e-7, 1.19209289550780998537e-7)]
[Row(-1.19209289550780998537e-7, -1.19209289550780998537e-7)]
public void CanComputeInverseTangent(double value, double expected)
{
var actual = Trig.InverseTangent(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 1.0)]
[Row(8388608, -1.1089490624226292)]
[Row(1.19209289550780998537e-7, 1.0000000000000071)]
[Row(-8388608, -1.1089490624226292)]
[Row(-1.19209289550780998537e-7, 1.0000000000000071)]
public void CanComputeSecant(double value, double expected)
{
var actual = Trig.Secant(value);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0)]
[Row(8388608, 0.43224820225679778)]
[Row(-8388608, -0.43224820225679778)]
[Row(1.19209289550780998537e-7, 1.1920928955078072e-7)]
[Row(-1.19209289550780998537e-7, -1.1920928955078072e-7)]
public void CanComputeSine(double value, double expected)
{
var actual = Trig.Sine(value);
AssertHelpers.AlmostEqual(expected, actual, 13);
}
[Test]
[Row(0.0, 0.0)]
[Row(8388608, -0.47934123862654288)]
[Row(-8388608, 0.47934123862654288)]
[Row(1.19209289550780998537e-7, 1.1920928955078157e-7)]
[Row(-1.19209289550780998537e-7, -1.1920928955078157e-7)]
public void CanComputeTangent(double value, double expected)
{
var actual = Trig.Tangent(value);
AssertHelpers.AlmostEqual(expected, actual, 13);
}
[Test]
public void CanConvertDegreeToGrad()
{
AssertHelpers.AlmostEqual(90 / .9, Trig.DegreeToGrad(90), 15);
}
[Test]
public void CanConvertDegreeToRadian()
{
AssertHelpers.AlmostEqual(Math.PI / 2, Trig.DegreeToRadian(90), 15);
}
[Test]
public void CanConvertGradToDegree()
{
AssertHelpers.AlmostEqual(180, Trig.GradToDegree(200), 15);
}
[Test]
public void CanConvertGradToRadian()
{
AssertHelpers.AlmostEqual(Math.PI, Trig.GradToRadian(200), 15);
}
[Test]
public void CanConvertRadianToDegree()
{
AssertHelpers.AlmostEqual(60.0, Trig.RadianToDegree(Math.PI / 3.0), 15);
}
[Test]
public void CanConvertRadianToGrad()
{
AssertHelpers.AlmostEqual(200.0 / 3.0, Trig.RadianToGrad(Math.PI / 3.0), 15);
}
[Test]
[Row(0.0, 0.0, double.PositiveInfinity, 0.0)]
[Row(8.388608e6, 0.0, -2.086196470108229, 0.0)]
[Row(-8.388608e6, 0.0, 2.086196470108229, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 8388607.999999978, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -8388607.999999978, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, -2.0861964701080704, -6.3803383253713457e-7)]
[Row(-8.388608e6, -1.19209289550780998537e-7, 2.0861964701080704, 6.3803383253713457e-7)]
public void CanComputeComplexCotangent(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).Cotangent();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 13);
}
[Test]
[Row(0.0, 0.0, 1.0, 0.0)]
[Row(8.388608e6, 0.0, -1.1089490624226292, 0.0)]
[Row(-8.388608e6, 0.0, -1.1089490624226292, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.0000000000000071, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, 1.0000000000000071, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, -1.1089490624226177, 6.3367488045143761e-8)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -1.1089490624226177, 6.3367488045143761e-8)]
public void CanComputeComplexSecant(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).Secant();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 13);
}
[Test]
[Row(0.0, 0.0, double.PositiveInfinity, 0.0)]
[Row(8.388608e6, 0.0, 2.3134856195559191, 0.0)]
[Row(-8.388608e6, 0.0, -2.3134856195559191, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 8388608.0000000376, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -8388608.0000000376, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 2.3134856195557596, 5.7534999050657057e-7)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -2.3134856195557596, -5.7534999050657057e-7)]
public void CanComputeComplexCosecant(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).Cosecant();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 13);
}
[Test]
[Row(0.0, 0.0, 0.0, 0.0)]
[Row(8.388608e6, 0.0, double.PositiveInfinity, 0.0)]
[Row(-8.388608e6, 0.0, double.NegativeInfinity, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.1920928955078128e-7, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -1.1920928955078128e-7, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, double.PositiveInfinity, double.PositiveInfinity)]
[Row(-8.388608e6, -1.19209289550780998537e-7, double.NegativeInfinity, double.NegativeInfinity)]
[Row(0.5, -0.5, 0.45730415318424922, -0.54061268571315335)]
public void CanComputeComplexHyperbolicSine(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).HyperbolicSine();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0, 1.0, 0.0)]
[Row(8.388608e6, 0.0, double.PositiveInfinity, 0.0)]
[Row(-8.388608e6, 0.0, double.PositiveInfinity, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.0000000000000071, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, 1.0000000000000071, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, double.PositiveInfinity, double.PositiveInfinity)]
[Row(-8.388608e6, -1.19209289550780998537e-7, double.PositiveInfinity, double.PositiveInfinity)]
[Row(0.5, -0.5, 0.9895848833999199, -0.24982639750046154)]
public void CanComputeComplexHyperbolicCosine(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).HyperbolicCosine();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0, 0.0, 0.0)]
[Row(8.388608e6, 0.0, 1.0, 0.0)]
[Row(-8.388608e6, 0.0, -1.0, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.1920928955078043e-7, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -1.1920928955078043e-7, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.0, 0.0)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -1.0, 0.0)]
[Row(0.5, -0.5, 0.56408314126749848, -0.40389645531602575)]
public void CanComputeComplexHyperbolicTangent(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).HyperbolicTangent();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0, double.PositiveInfinity, 0.0)]
[Row(8.388608e6, 0.0, 1.0, 0.0)]
[Row(-8.388608e6, 0.0, -1.0, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 8388608.0000000574, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -8388608.0000000574, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.0, 0.0)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -1.0, 0.0)]
[Row(0.5, -0.5, 1.1719451445243514, -0.8391395790248311)]
public void CanComputeComplexHyperbolicCotangent(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).HyperbolicCotangent();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0, 1.0, 0.0)]
[Row(8.388608e6, 0.0, 0.0, 0.0)]
[Row(-8.388608e6, 0.0, 0.0, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 0.99999999999999289, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, 0.99999999999999289, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 0.0, 0.0)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -0.0, 0.0)]
[Row(0.5, -0.5, 0.94997886761549463, 0.23982763093808804)]
public void CanComputeComplexHyperbolicSecant(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).HyperbolicSecant();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0, double.PositiveInfinity, 0.0)]
[Row(8.388608e6, 0.0, 0.0, 0.0)]
[Row(-8.388608e6, 0.0, 0.0, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 8388607.9999999978, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -8388607.9999999978, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 0.0, 0.0)]
[Row(-8.388608e6, -1.19209289550780998537e-7, 0.0, 0.0)]
[Row(0.5, -0.5, 0.91207426403881078, 1.0782296946540223)]
public void CanComputeComplexHyperbolicCosecant(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).HyperbolicCosecant();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0,0.0, 0.0 )]
[Row(8.388608e6, 0.0, 1.5707963267948966, -16.635532333438682)]
[Row(-8.388608e6, 0.0, -1.5707963267948966, 16.635532333438682)]
[Row(1.19209289550780998537e-7, 0.0, 1.1920928955078128e-7, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -1.1920928955078128e-7, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.5707963267948966, 16.635532333438682)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -1.5707963267948966, -16.635532333438682)]
[Row(0.5, -0.5, 0.4522784471511907, -0.53063753095251787)]
public void CanComputeComplexInverseSine(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseSine();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0, 1.5707963267948966, 0.0)]
[Row(8.388608e6, 0.0, 0.0, 16.635532333438682)]
[Row(-8.388608e6, 0.0, 3.1415926535897931, -16.635532333438682)]
[Row(1.19209289550780998537e-7, 0.0, 1.570796207585607, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, 1.5707964460041861, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.4210854715202073e-14, -16.635532333438682)]
[Row(-8.388608e6, -1.19209289550780998537e-7, 3.1415926535897789,16.63553233343868)]
[Row(0.5, -0.5, 1.1185178796437059,0.53063753095251787)]
public void CanComputeComplexInverseCosine(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseCosine();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0, 0.0, 0.0)]
[Row(8.388608e6, 0.0, 1.570796207585607, 0.0 )]
[Row(-8.388608e6, 0.0, -1.570796207585607,0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.1920928955078043e-7, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -1.1920928955078043e-7, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.570796207585607, 0.0)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -1.570796207585607, 0.0)]
[Row(0.5, -0.5, 0.5535743588970452, -0.40235947810852507)]
public void CanComputeComplexInverseTangent(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseTangent();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(0.0, 0.0, Math.PI/2.0, 0.0)]
[Row(8.388608e6, 0.0, 1.1920928955078069e-7, 0.0)]
[Row(-8.388608e6, 0.0, -1.1920928955078069e-7, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.5707962075856071, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -1.5707962075856071, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.1920928955078069e-7, -1.6907571720583645e-21)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -1.1920928955078069e-7, 1.6907571720583645e-21)]
[Row(0.5, -0.5, 1.0172219678978514, 0.40235947810852509)]
public void CanComputeComplexInverseCotangent(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseCotangent();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(8.388608e6, 0.0, 1.5707962075856071, 0.0)]
[Row(-8.388608e6, 0.0, 1.5707964460041862, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 0.0, 16.635532333438686)]
[Row(-1.19209289550780998537e-7, 0.0, 3.1415926535897932, -16.635532333438686)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.5707962075856071, 1.6940658945086007e-21)]
[Row(-8.388608e6, -1.19209289550780998537e-7, 1.5707964460041862, -1.6940658945086007e-21)]
[Row(0.5, -0.5, 0.90455689430238136,-1.0612750619050357)]
public void CanComputeComplexInverseSecant(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseSecant();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(8.388608e6, 0.0, 1.1920928955078153e-7, 0.0)]
[Row(-8.388608e6, 0.0, -1.1920928955078153e-7, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.5707963267948966, -16.635532333438686)]
[Row(-1.19209289550780998537e-7, 0.0, -1.5707963267948966, 16.635532333438686)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.1920928955078153e-7, -1.6940658945086007e-21)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -1.1920928955078153e-7, 1.6940658945086007e-21)]
[Row(0.5, -0.5, 0.66623943249251526, 1.0612750619050357)]
public void CanComputeComplexInverseCosecant(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseCosecant();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(8.388608e6, 0.0, 16.63553233343869, 0.0)]
[Row(-8.388608e6, 0.0, -16.63553233343869, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.1920928955078072e-7, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -1.1920928955078072e-7, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 16.63553233343869, 1.4210854715201873e-14)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -16.63553233343869, -1.4210854715201873e-14)]
[Row(0.5, -0.5, 0.53063753095251787, -0.4522784471511907)]
public void CanComputeComplexInverseHyperbolicSine(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseHyperbolicSine();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(8.388608e6, 0.0, 16.635532333438682, 0.0)]
[Row(-8.388608e6, 0.0, 16.635532333438682, 3.1415926535897931)]
[Row(1.19209289550780998537e-7, 0.0, 0.0, 1.570796207585607)]
[Row(-1.19209289550780998537e-7, 0.0, 0.0, 1.5707964460041861)]
[Row(8.388608e6, 1.19209289550780998537e-7, 16.635532333438682, 1.4210854715202073e-14)]
[Row(-8.388608e6, -1.19209289550780998537e-7, 16.635532333438682, -3.1415926535897789)]
[Row(0.5, -0.5, 0.53063753095251787, -1.1185178796437059)]
public void CanComputeComplexInverseHyperbolicCosine(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseHyperbolicCosine();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(8.388608e6, 0.0, 1.1920928955078125e-7, -1.5707963267948966)]
[Row(-8.388608e6, 0.0, -1.1920928955078125e-7, 1.5707963267948966)]
[Row(1.19209289550780998537e-7, 0.0, 1.1920928955078157e-7, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -1.1920928955078157e-7, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.1920928955078125e-7, 1.5707963267948966)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -1.1920928955078125e-7, -1.5707963267948966)]
[Row(0.5, -0.5, 0.40235947810852509, -0.55357435889704525)]
public void CanComputeComplexInverseHyperbolicTangent(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseHyperbolicTangent();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(8.388608e6, 0.0, 1.1920928955078181e-7, 0.0)]
[Row(-8.388608e6, 0.0, -1.1920928955078181e-7, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 1.1920928955078157e-7, -1.5707963267948966)]
[Row(-1.19209289550780998537e-7, 0.0, -1.1920928955078157e-7, 1.5707963267948966)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.1920928955078181e-7, -1.6940658945086212e-21)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -1.1920928955078181e-7, 1.6940658945086212e-21)]
[Row(0.5, -0.5, 0.40235947810852509, 1.0172219678978514)]
public void CanComputeComplexInverseHyperbolicCotangent(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseHyperbolicCotangent();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(8.388608e6, 0.0, 0.0, 1.5707962075856071)]
[Row(-8.388608e6, 0.0, 0.0, 1.5707964460041862)]
[Row(1.19209289550780998537e-7, 0.0, 16.635532333438686, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, 16.635532333438686, 3.1415926535897932)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.6940658945086007e-21, -1.5707962075856071)]
[Row(-8.388608e6, -1.19209289550780998537e-7, 1.6940658945086007e-21, 1.5707964460041862)]
[Row(0.5, -0.5, 1.0612750619050357, 0.90455689430238136)]
public void CanComputeComplexInverseHyperbolicSecant(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseHyperbolicSecant();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
[Test]
[Row(8.388608e6, 0.0, 1.1920928955078097e-7, 0.0)]
[Row(-8.388608e6, 0.0, -1.1920928955078097e-7, 0.0)]
[Row(1.19209289550780998537e-7, 0.0, 16.635532333438693, 0.0)]
[Row(-1.19209289550780998537e-7, 0.0, -16.635532333438693, 0.0)]
[Row(8.388608e6, 1.19209289550780998537e-7, 1.1920928955078076e-7, -1.6940658945085851e-21)]
[Row(-8.388608e6, -1.19209289550780998537e-7, -1.1920928955078076e-7, 1.6940658945085851e-21)]
[Row(0.5, -0.5, 1.0612750619050357, 0.66623943249251526)]
public void CanComputeComplexInverseHyperbolicCosecant(double real, double imag, double expectedReal, double expectedImag)
{
var actual = new Complex(real, imag).InverseHyperbolicCosecant();
var expected = new Complex(expectedReal, expectedImag);
AssertHelpers.AlmostEqual(expected, actual, 14);
}
}
}