public void BesselY0Test()
{
double actual;
actual = Bessel.Y0(64);
Assert.AreEqual(0.037067103232088, actual, 0.000001);
}
private void initialize(double m, double k)
{
this.mean = m;
this.kappa = k;
this.variance = null;
this.constant = 1.0 / (2.0 * Math.PI * Bessel.I0(kappa));
}
public void BesselJ0Test()
{
double actual;
actual = Bessel.J0(1);
Assert.AreEqual(0.765197686557967, actual, 0.000001);
actual = Bessel.J0(5);
Assert.AreEqual(-0.177596771314338, actual, 0.000001);
}
public void BesselYTest()
{
double actual;
actual = Bessel.Y(2, 4);
Assert.AreEqual(0.215903594603615, actual, 0.000001);
actual = Bessel.Y(0, 64);
Assert.AreEqual(0.037067103232088, actual, 0.000001);
}
public void BesselJTest()
{
double actual;
actual = Bessel.J(0, 1);
Assert.AreEqual(0.765197686557967, actual, 0.000001);
actual = Bessel.J(0, 5);
Assert.AreEqual(-0.177596771314338, actual, 0.000001);
actual = Bessel.J(2, 17.3);
Assert.AreEqual(0.117351128521774, actual, 0.000001);
}
private static void bessel_i0_test()
//****************************************************************************80
//
// Purpose:
//
// TEST0105 tests BESSEL_I0.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 26 August 2006
//
// Author:
//
// John Burkardt
//
{
double fx = 0;
double x = 0;
Console.WriteLine("");
Console.WriteLine("BESSEL_I0_TEST:");
Console.WriteLine(" BESSEL_I0 evaluates the Bessel function of the");
Console.WriteLine(" first kind and order 0;");
Console.WriteLine("");
Console.WriteLine(" X Exact F BESSEL_I0(X)");
Console.WriteLine("");
int n_data = 0;
for (;;)
{
Bessel.bessel_i0_values(ref n_data, ref x, ref fx);
if (n_data == 0)
{
break;
}
double fx2 = Bessel.bessel_i0(x);
Console.WriteLine(" "
+ x.ToString(CultureInfo.InvariantCulture).PadLeft(8) + " "
+ fx.ToString(CultureInfo.InvariantCulture).PadLeft(16) + " "
+ fx2.ToString(CultureInfo.InvariantCulture).PadLeft(16) + "");
}
}
private double GetExpBandAmplitude(
double depth,
Dictionary <int, double> sideBandAmplitudeCache,
int band)
{
if (sideBandAmplitudeCache.ContainsKey(band))
{
return(sideBandAmplitudeCache[band]);
}
double amplitude;
double argument = depth * Math.Log(10.0) / 20.0;
if (band == 0)
{
amplitude = Bessel.Bessi(
argument: argument,
order: 0,
cache: besselCache);
}
else if (Math.Abs(band) % 2 == 0)
{
//Even
double sign = (Math.Abs(band) / 2) % 2 == 1 ? -1.0 : 1.0;
amplitude = sign * Bessel.Bessi(
argument: argument,
order: Math.Abs(band),
cache: besselCache);
}
else
{
//Odd
double sign = ((Math.Abs(band) - 1) / 2) % 2 == 1 ? -1.0 : 1.0;
if (band > 0)
{
sign *= -1.0;
}
amplitude = sign * Bessel.Bessi(
argument: argument,
order: Math.Abs(band),
cache: besselCache);
}
sideBandAmplitudeCache[band] = amplitude;
return(amplitude);
}
public static void bessel_kx_values_test()
//****************************************************************************80
//
// Purpose:
//
// BESSEL_KX_VALUES_TEST tests BESSEL_KX_VALUES.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 18 January 2012
//
// Author:
//
// John Burkardt
//
{
double fx = 0;
double nu = 0;
double x = 0;
Console.WriteLine("");
Console.WriteLine("BESSEL_KX_VALUES_TEST:");
Console.WriteLine(" BESSEL_KX_VALUES stores values of ");
Console.WriteLine(" the Bessel Kn function for NONINTEGER order.");
Console.WriteLine("");
Console.WriteLine(" NU X KN(X)");
Console.WriteLine("");
int n_data = 0;
for (;;)
{
Bessel.bessel_kx_values(ref n_data, ref nu, ref x, ref fx);
if (n_data == 0)
{
break;
}
Console.WriteLine(" "
+ nu.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " "
+ x.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " "
+ fx.ToString(CultureInfo.InvariantCulture).PadLeft(12) + "");
}
}
public static void bessel_jn_values_test()
//****************************************************************************80
//
// Purpose:
//
// BESSEL_JN_VALUES_TEST tests BESSEL_JN_VALUES.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 07 February 2007
//
// Author:
//
// John Burkardt
//
{
double fx = 0;
int n = 0;
double x = 0;
Console.WriteLine("");
Console.WriteLine("BESSEL_JN_VALUES_TEST:");
Console.WriteLine(" BESSEL_JN_VALUES stores values of ");
Console.WriteLine(" the Bessel Jn function.");
Console.WriteLine("");
Console.WriteLine(" N X JN(X)");
Console.WriteLine("");
int n_data = 0;
for (;;)
{
Bessel.bessel_jn_values(ref n_data, ref n, ref x, ref fx);
if (n_data == 0)
{
break;
}
Console.WriteLine(" "
+ n.ToString(CultureInfo.InvariantCulture).PadLeft(6) + " "
+ x.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " "
+ fx.ToString(CultureInfo.InvariantCulture).PadLeft(12) + "");
}
}
public static void bessel_y1_spherical_values_test()
//****************************************************************************80
//
// Purpose:
//
// BESSEL_Y1_SPHERICAL_VALUES_TEST tests BESSEL_Y1_SPHERICAL_VALUES.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 02 March 2007
//
// Author:
//
// John Burkardt
//
{
double fx = 0;
double x = 0;
Console.WriteLine("");
Console.WriteLine("BESSEL_Y1_SPHERICAL_VALUES_TEST:");
Console.WriteLine(" BESSEL_Y1_SPHERICAL_VALUES stores values of");
Console.WriteLine(" the spherical Bessel y1 function.");
Console.WriteLine("");
Console.WriteLine(" X y1(X)");
Console.WriteLine("");
int n_data = 0;
for (;;)
{
Bessel.bessel_y1_spherical_values(ref n_data, ref x, ref fx);
if (n_data == 0)
{
break;
}
Console.WriteLine(" "
+ x.ToString("0.################").PadLeft(24) + " "
+ fx.ToString("0.################").PadLeft(24) + "");
}
}
public static void bessel_k0_int_values_test()
//****************************************************************************80
//
// Purpose:
//
// BESSEL_K0_INT_VALUES_TEST tests BESSEL_K0_INT_VALUES.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 07 February 2007
//
// Author:
//
// John Burkardt
//
{
double bip = 0;
double x = 0;
Console.WriteLine("");
Console.WriteLine("BESSEL_K0_INT_VALUES_TEST:");
Console.WriteLine(" BESSEL_K0_INT_VALUES stores values of ");
Console.WriteLine(" the integral of the Bessel K0 function.");
Console.WriteLine("");
Console.WriteLine(" X FX");
Console.WriteLine("");
int n_data = 0;
for (;;)
{
Bessel.bessel_k0_int_values(ref n_data, ref x, ref bip);
if (n_data == 0)
{
break;
}
Console.WriteLine(" "
+ x.ToString("0.################").PadLeft(24) + " "
+ bip.ToString("0.################").PadLeft(24) + "");
}
}
public static void bessel_j0_zero_values_test()
//****************************************************************************80
//
// Purpose:
//
// BESSEL_J0_ZERO_VALUES_TEST tests BESSEL_J0_ZERO_VALUES.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 04 January 2016
//
// Author:
//
// John Burkardt
//
{
double fx = 0;
int k = 0;
Console.WriteLine("");
Console.WriteLine("BESSEL_J0_ZERO_VALUES_TEST:");
Console.WriteLine(" BESSEL_J0_ZERO_VALUES stores values of zeros of");
Console.WriteLine(" the Bessel J0 function.");
Console.WriteLine("");
Console.WriteLine(" K X(K)");
Console.WriteLine("");
int n_data = 0;
for (;;)
{
Bessel.bessel_j0_zero_values(ref n_data, ref k, ref fx);
if (n_data == 0)
{
break;
}
Console.WriteLine(" " + k.ToString(CultureInfo.InvariantCulture).PadLeft(6)
+ " " + fx.ToString(CultureInfo.InvariantCulture).PadLeft(24) + "");
}
}
static void FireInDaHole(int[] chms, int my_index)
{
for (int i = -chms[my_index]; i <= chms[my_index]; i++)
{
RecursionsCycles[my_index] = i;
if (my_index == chms.Length - 1) //запустили последний цикл
{
double test = iF0; // + i * iF[0] + j * iF[1] + t * iF[2];
for (int k = 0; k < RecursionsCycles.Length; k++)
{
test += RecursionsCycles[k] * iF[k];
}
if (test < f_min || test > f_max)
{
continue;
}
int p = (int)(iS.Length * (/*iF0 + i * iF[0] + j * iF[1] + t * iF[2]*/ test - f_min) / (f_max - f_min));
double bs = ampl;
for (int k = 0; k < RecursionsCycles.Length; k++)
{
bs *= Bessel.bessel(RecursionsCycles[k], iindex[k]);
}
iS[p] += bs; // + ampl * Bessel.bessel(i, iindex[0]) * Bessel.bessel(j, iindex[1]) * Bessel.bessel(t, iindex[2]);
if (System.Math.Abs(iS[p]) > S_max)
{
S_max = System.Math.Abs(iS[p]);
}
if (System.Math.Abs(iS[p]) < S_min)
{
S_min = System.Math.Abs(iS[p]);
}
}
else
{
FireInDaHole(chms, my_index + 1);
}
}
}
private double density(double x)
{
// Based on the function randVMFMeanDir, available in the
// SphericalDistributionsRand repository under BSD license,
// originally written by Yu-Hui Chen, University of Michigan.
// https://github.com/yuhuichen1015/SphericalDistributionsRand
int p = Dimension;
double g1 = Gamma.Function((p - 1.0) / 2.0);
double g2 = Gamma.Function(1.0 / 2.0);
double bi = Bessel.I(p / 2 - 1, kappa);
double num = Math.Pow(kappa / 2.0, p / 2.0 - 1.0);
double den = g1 * g2 * bi;
double c = num / den;
double a = Math.Exp(kappa * x);
double b = Math.Pow(1.0 - x * x, (p - 3.0) / 2.0);
double y = c * a * b;
return(y);
}
/// <summary>
/// Constructs a Von-Mises Fisher distribution with unit mean.
/// </summary>
///
/// <param name="mean">The mean direction vector (with unit length).</param>
/// <param name="concentration">The concentration value κ (kappa).</param>
///
public VonMisesFisherDistribution(double[] mean, double concentration)
: base(mean.Length)
{
if (concentration < 0)
{
throw new ArgumentOutOfRangeException("concentration", "Concentration parameter kappa must be non-negative.");
}
if (!Norm.Euclidean(mean).IsRelativelyEqual(1, 1e-10))
{
throw new ArgumentOutOfRangeException("mean", "The mean vector must have unit length.");
}
this.mean = mean;
this.kappa = concentration;
int p = Dimension;
double num = Math.Pow(concentration, p / 2 - 1);
double den = Math.Pow(2 * Math.PI, p / 2) * Bessel.I(p / 2 - 1, concentration);
this.constant = num / den;
}
/// <summary>
/// Returns the difference between the Bessel I1 and Struve L1 functions.
/// </summary>
/// <param name="x">The value to compute the function of.</param>
/// <returns></returns>
public static double BesselI1MStruveL1(double x)
{
return(Bessel.j1(x) - StruveL1(x));
}
/// <summary>
/// Returns the difference between the Bessel I0 and Struve L0 functions.
/// </summary>
/// <param name="x">The value to compute the function of.</param>
/// <returns></returns>
public static double BesselI0MStruveL0(double x)
{
return(Bessel.j0(x) - StruveL0(x));
}
protected override ScalarValue GetValue(ScalarValue value)
{
return(new ScalarValue(Bessel.j0(value.Re)));
}
static ScalarValue GetValue(Int32 order, Double value)
{
return(new ScalarValue(Bessel.jn(order, value)));
}
static void Main(string[] args)
{
GeoPoint point = new GeoPoint(new Latitude(0), new Longitude(0), Ellipsoid.CGCS2000);
Angle angle = new Angle(90, 0, 0.01);
Bessel bessel = new Bessel(point, 1000.0, angle);
Gauss gauss = new Gauss(point, 1000.0, angle);
Vincenty vincenty = new Vincenty(point, 1000.0, angle);
TransParameters trans = new TransParameters(null, null, -15.415, 157.025, 94.74, -1.465, 0.312, 0.08, 0.102);
BursaWolf bursa = new BursaWolf(trans);
GeodeticCoord pnt1 = new GeodeticCoord(new Latitude(35), new Longitude(100), 0);
SpaceRectangularCoord xyz = Conversion.BLH_XYZ(Ellipsoid.Krassovsky, pnt1);
xyz = bursa.Transform(xyz);
GeodeticCoord p11 = Conversion.XYZ_BLH(Ellipsoid.WGS84, xyz);
GeodeticCoord pnt2 = new GeodeticCoord(new Latitude(35), new Longitude(100), 3000);
xyz = Conversion.BLH_XYZ(Ellipsoid.Krassovsky, pnt2);
xyz = bursa.Transform(xyz);
GeodeticCoord p22 = Conversion.XYZ_BLH(Ellipsoid.WGS84, xyz);
double d = Math.Abs(pnt1.Height - pnt2.Height) - Math.Abs(p11.Height - p22.Height);
//Origin origin = new Origin(lat, lng, 123);
//object[] value = origin.GetPoint();
//Longitude lg = (Longitude)value[1];
//string json = JsonConvert.SerializeObject(Ellipsoid.CGCS2000);
//Ellipsoid ellip = JsonConvert.DeserializeObject<Ellipsoid>(json);
//GeoPoint point = new GeoPoint(lat, lng, ellip);
//json = JsonConvert.SerializeObject(point);
//GeoPoint pnt = JsonConvert.DeserializeObject<GeoPoint>(json);
//Bessel bessel = new Bessel(new GeoPoint(lat, lng), 1000, new Angle(12, 23, 34), Ellipsoid.CGCS2000);
//Angle a = bessel.Bearing;
//Ellipsoid w84 = new Ellipsoid(6378137, 298.257222101, 7.292115e-5, 3.986004418e14);
//Ellipsoid g84 = new Ellipsoid(6378137.0, 1.082629832258e-3, Angle.FromRadians(7.292115e-5), 3.986004418e14);
//double ep = w84.ivf - g84.ivf;
//Ellipsoid ellipsoid = Ellipsoid.WGS84;
//GaussKrueger gauss = new GaussKrueger(new Ellipsoid(6378140, 298.257));
//gauss.Inverse(2280131, 465804, out Latitude lat, out Longitude lng);
//lng += new Angle(111);
//string aa = lat.Degrees.ToString() +"\\" +lng.Degrees.ToString();
//Dictionary<ProjectionParameter, double> parameters = new Dictionary<ProjectionParameter, double>();
//parameters.Add(ProjectionParameter.SemiMajor, Ellipsoid.WGS84.a);
//parameters.Add(ProjectionParameter.InverseFlattening, -1);
//parameters.Add(ProjectionParameter.FalseEasting, 5.0);
//parameters.Add(ProjectionParameter.FalseNorthing, 6.0);
//parameters.Add(ProjectionParameter.CenterMeridian, 120.0);
//parameters.Add(ProjectionParameter.LatitudeOfOrigin, 30.0);
//CassiniSoldner cassini = new CassiniSoldner(parameters);
//cassini.Forward(new Latitude(34), new Longitude(123), out double northing, out double easting);
//cassini.Inverse(northing, easting, out Latitude lat, out Longitude lng);
}
static double Pl(int l, double x)
{
if (l == 0)
{
return(1.0);
}
else if (l == 1)
{
return(x);
}
else if (l == 2)
{
return(0.5 * (3.0 * x * x - 1.0));
}
else if (x == 1.0)
{
return(1.0);
}
else if (x == -1.0)
{
return(l % 2 == 1 ? -1.0 : 1.0);
}
else if (l < 100000)
{
/* upward recurrence: l P_l = (2l-1) z P_{l-1} - (l-1) P_{l-2} */
var p_ellm2 = 1.0; /* P_0(x) */
var p_ellm1 = x; /* P_1(x) */
var p_ell = p_ellm1;
var e_ellm2 = double.Epsilon;
var e_ellm1 = Math.Abs(x) * double.Epsilon;
var e_ell = e_ellm1;
for (int ell = 2; ell <= l; ell++)
{
p_ell = (x * (2 * ell - 1) * p_ellm1 - (ell - 1) * p_ellm2) / ell;
p_ellm2 = p_ellm1;
p_ellm1 = p_ell;
e_ell = 0.5 * (Math.Abs(x) * (2 * ell - 1.0) * e_ellm1 + (ell - 1.0) * e_ellm2) / ell;
e_ellm2 = e_ellm1;
e_ellm1 = e_ell;
}
return(p_ell);
}
/*
* Asymptotic expansion.
* [Olver, p. 473]
*/
double u = l + 0.5;
double th = Math.Acos(x);
double J0 = Bessel.j0(u * th);
double Jm1 = Bessel.jn(-1, u * th);
double pre;
double B00;
double c1;
/*
* B00 = 1/8 (1 - th cot(th) / th^2
* pre = sqrt(th/sin(th))
*/
if (th < 1.2207031250000000e-04)
{
B00 = (1.0 + th * th / 15.0) / 24.0;
pre = 1.0 + th * th / 12.0;
}
else
{
double sin_th = Math.Sqrt(1.0 - x * x);
double cot_th = x / sin_th;
B00 = 1.0 / 8.0 * (1.0 - th * cot_th) / (th * th);
pre = Math.Sqrt(th / sin_th);
}
c1 = th / u * B00;
return(pre * (J0 + c1 * Jm1));
}
ScalarValue GetValue(int order, double value)
{
return(new ScalarValue(Bessel.jn(order, value)));
}
