public Color ConvertLinearToGamma()
{
this.R = (int)SMath.Sqrt(this.R);
this.G = (int)SMath.Sqrt(this.G);
this.B = (int)SMath.Sqrt(this.B);
return(this);
}
// For performance improvements Color and Spatial functions are recalculated prior to filter execution and put into 2 dimensional arrays
private void InitSpatialFunc( )
{
if ((spatialFunc == null) || (spatialFunc.Length != kernelSize * kernelSize) ||
(spatialPropertiesChanged))
{
if ((spatialFunc == null) || (spatialFunc.Length != kernelSize * kernelSize))
{
spatialFunc = new double[kernelSize, kernelSize];
}
int kernelRadius = kernelSize / 2;
for (int i = 0; i < kernelSize; i++)
{
int ti = i - kernelRadius;
int ti2 = ti * ti;
for (int k = 0; k < kernelSize; k++)
{
int tk = k - kernelRadius;
int tk2 = tk * tk;
spatialFunc[i, k] = M.Exp(-0.5 * M.Pow(M.Sqrt((ti2 + tk2) / spatialFactor), spatialPower));
}
}
spatialPropertiesChanged = false;
}
}
public Color CopyLinearToGamma(Color Color)
{
this.R = (int)SMath.Sqrt(Color.R);
this.G = (int)SMath.Sqrt(Color.G);
this.B = (int)SMath.Sqrt(Color.B);
return(this);
}
// For performance improvements Color and Spatial functions are recalculated prior to filter execution and put into 2 dimensional arrays
private void InitSpatialFunc( )
{
if ((this.spatialFunc == null) || (this.spatialFunc.Length != this.kernelSize * this.kernelSize) ||
(this.spatialPropertiesChanged))
{
if ((this.spatialFunc == null) || (this.spatialFunc.Length != this.kernelSize * this.kernelSize))
{
this.spatialFunc = new double[this.kernelSize, this.kernelSize];
}
var kernelRadius = this.kernelSize / 2;
for (var i = 0; i < this.kernelSize; i++)
{
var ti = i - kernelRadius;
var ti2 = ti * ti;
for (var k = 0; k < this.kernelSize; k++)
{
var tk = k - kernelRadius;
var tk2 = tk * tk;
this.spatialFunc[i, k] = M.Exp(-0.5 * M.Pow(M.Sqrt((ti2 + tk2) / this.spatialFactor), this.spatialPower));
}
}
this.spatialPropertiesChanged = false;
}
}
public static bool Intersect(Sphere sphere, Ray ray, out Num distance)
{
distance = 0;
var l = sphere.Center - ray.Org;
var a = Vec3.Dot(l, ray.Dir);
if (a < 0) // opposite direction
{
return(false);
}
var b2 = Vec3.Dot(l, l) - (a * a);
var r2 = sphere.Radius * sphere.Radius;
if (b2 > r2) // perpendicular > r
{
return(false);
}
Num c = MATH.Sqrt(r2 - b2);
Num near = a - c;
Num far = a + c;
distance = (near < 0) ? far : near;
// near < 0 means ray starts inside
return(true);
}
public static Quaternion Slerp(Quaternion p, Quaternion q, float time, bool useShortCut = false)
{
var cos = p.Dot(q);
var angle = MathDotNet.Acos(cos);
if (MathDotNet.Abs(angle) < Quaternion.EPSILONE)
{
return(p);
}
var sin = MathDotNet.Sin(angle);
var inverseSin = 1f / sin;
var coeff0 = MathDotNet.Sin((1f - time) * angle) * inverseSin;
var coeff1 = MathDotNet.Sin(time * angle) * inverseSin;
if (useShortCut == false || cos >= 0d)
{
return(p * coeff0 + q * coeff1);
}
coeff0 = -coeff0;
Quaternion temp = p * coeff0 + q * coeff1;
var factor = 1d / MathDotNet.Sqrt(temp.Normalized);
return(temp * factor);
}
public static Plane Normalize(Plane value)
{
const float FLT_EPSILON = 1.192092896e-07f; // smallest such that 1.0+FLT_EPSILON != 1.0
Plane result;
float f = value.Normal.X * value.Normal.X + value.Normal.Y * value.Normal.Y + value.Normal.Z * value.Normal.Z;
if (SM.Abs(f - 1.0f) < FLT_EPSILON)
{
result.Normal = value.Normal;
result.D = value.D;
return(result); // It already normalized, so we don't need to farther process.
}
float fInv = 1.0f / (float)SM.Sqrt(f);
result.Normal.X = value.Normal.X * fInv;
result.Normal.Y = value.Normal.Y * fInv;
result.Normal.Z = value.Normal.Z * fInv;
result.D = value.D * fInv;
return(result);
}
public bool WasHit(Ray p_ray, double p_tMin, double p_tMax, ref HitRecord p_hitRecord)
{
// If the quadratic is confusing, remember that several 2s are pre-canceled out. - Comment by Matt Heimlich on 06/23/2019 @ 12:15:02
var oc = p_ray.Origin - GetCenter(p_ray.Time);
var a = Vec3.GetDotProduct(p_ray.Direction, p_ray.Direction);
var b = Vec3.GetDotProduct(oc, p_ray.Direction);
var c = Vec3.GetDotProduct(oc, oc) - Radius * Radius;
var discriminant = b * b - a * c;
if (discriminant > 0)
{
var sqrtCache = Math.Sqrt(b * b - a * c);
var temp = (-b - sqrtCache) / a;
if (temp < p_tMax && temp > p_tMin)
{
p_hitRecord.T = temp;
p_hitRecord.Point = p_ray.PointAt(p_hitRecord.T);
p_hitRecord.Normal = (p_hitRecord.Point - GetCenter(p_ray.Time)) / Radius;
p_hitRecord.Material = Material;
return(true);
}
temp = (-b + sqrtCache) / a;
if (temp < p_tMax && temp > p_tMin)
{
p_hitRecord.T = temp;
p_hitRecord.Point = p_ray.PointAt(p_hitRecord.T);
p_hitRecord.Normal = (p_hitRecord.Point - GetCenter(p_ray.Time)) / Radius;
p_hitRecord.Material = Material;
return(true);
}
}
return(false);
}
List <PointF> GenerateRandNormal(int n)
{
if (n % 2 == 1)
{
n++;
}
List <PointF> points = new List <PointF>(n);
for (int i = 0; i < n / 2; i++)
{
do
{
double u = 2 * rnd.NextDouble() - 1;
double v = 2 * rnd.NextDouble() - 1;
double s = u * u + v * v;
if (s < 1)
{
s = Math.Sqrt(-2 * Math.Log(s) / s);
points.Add(new PointF(i, (float)(u * s)));
points.Add(new PointF(i + 1, (float)(v * s)));
break;
}
} while (true);
}
return(points);
}
public override string ToString()
{
var groupInfo = $"{this.Center} Range={Math.Sqrt(this.Range2)} Weight={this.Weight} WreckCount={this.Wrecks.Count}";
var bestPosInfo = $"BestPos={this.BestPos} BestWeight={this.BestPosWeight} IsInter={this.IsBestPosInter}";
return($"WreckGroup {groupInfo} || {bestPosInfo}");
}
/// <summary>
/// The total straight length between the offset points.
/// </summary>
/// <returns>System.Double.</returns>
public double Length()
{
return(NMath.Sqrt(I.Radius.Squared() + J.Radius.Squared() - 2 * I.Radius * J.Radius * (
NMath.Sin(I.Inclination.Radians) * NMath.Sin(J.Inclination.Radians) * NMath.Cos(I.Azimuth.Radians - J.Azimuth.Radians) +
NMath.Cos(I.Inclination.Radians) * NMath.Cos(J.Inclination.Radians)
)));
}
public Task <QuotationResult> CalculatePremiums(QuotationInput quoteparams)
{
try
{
return(Task.Run(() =>
{
double d1 = 0.0;
double d2 = 0.0;
QuotationResult quotes = new QuotationResult();
double S = double.Parse(quoteparams.StockPrice.Replace(".", ","));
double K = double.Parse(quoteparams.StrikePrice.Replace(".", ","));
double T = double.Parse(quoteparams.TimeToMaturity.Replace(".", ","));
double r = double.Parse(quoteparams.InterestRate.Replace(".", ","));
double v = double.Parse(quoteparams.Volatility.Replace(".", ","));
d1 = Math.Round((Math.Log(S / K) + (r + v * v / 2.0) * T) / v / Math.Sqrt(T), 4);
d2 = Math.Round(d1 - v * Math.Sqrt(T), 4);
quotes.D1 = d1;
quotes.D2 = d2;
quotes.CallPremium = Math.Round(S * CumulativeNormDistFunction(d1) - K * Math.Exp(-r * T) * CumulativeNormDistFunction(d2), 4);
quotes.PutPremium = Math.Round(K * Math.Exp(-r * T) * CumulativeNormDistFunction(-d2) - S * CumulativeNormDistFunction(-d1), 4);
return quotes;
}));
}
catch (Exception ex)
{
throw;
}
}
static double CumulativeNormDistFunction(double x)
{
try
{
double b0 = 0.2316419;
double b1 = 0.319381530;
double b2 = -0.356563782;
double b3 = 1.781477937;
double b4 = -1.821255978;
double b5 = 1.330274429;
double pi = Math.PI;
double phi = Math.Exp(-x * x / 2.0) / Math.Sqrt(2.0 * pi);
double t, c;
double CDF = 0.5;
if (x > 0.0)
{
t = 1.0 / (1.0 + b0 * x);
CDF = 1.0 - phi * (b1 * t + b2 * Math.Pow(t, 2) + b3 * Math.Pow(t, 3) + b4 * Math.Pow(t, 4) + b5 * Math.Pow(t, 5));
}
else if (x < 0.0)
{
x = -x;
t = 1.0 / (1.0 + b0 * x);
c = 1.0 - phi * (b1 * t + b2 * Math.Pow(t, 2) + b3 * Math.Pow(t, 3) + b4 * Math.Pow(t, 4) + b5 * Math.Pow(t, 5));
CDF = 1.0 - c;
}
return(CDF);
}
catch (Exception ex)
{
throw;
}
}
public static Vector2D GetProjectedPointOnLine(Vector2D v1, Vector2D v2, Vector2D p, bool disableBBcheck = false)
{
Func <Vector2D, Vector2D, double> dotProduct = (a, b) =>
{
return(a.X * b.X + a.Y * b.Y);
};
var e1 = new Vector2D(v2.X - v1.X, v2.Y - v1.Y);
var e2 = new Vector2D(p.X - v1.X, p.Y - v1.Y);
double valDp = dotProduct(e1, e2);
double lenLineE1 = SysMath.Sqrt(e1.X * e1.X + e1.Y * e1.Y);
double lenLineE2 = SysMath.Sqrt(e2.X * e2.X + e2.Y * e2.Y);
double cos = valDp / (lenLineE1 * lenLineE2);
double projLenOfLine = cos * lenLineE2;
var qp = new Vector2D((v1.X + (projLenOfLine * e1.X) / lenLineE1), (v1.Y + (projLenOfLine * e1.Y) / lenLineE1));
if (!disableBBcheck)
{
if (!IsPointInsideBoundingBox(v1, v2, qp))
{
return(null);
}
}
return(qp);
}
public static Plane CreateFromVertices(Vector3 point1, Vector3 point2, Vector3 point3)
{
Plane result;
float ax = point2.X - point1.X;
float ay = point2.Y - point1.Y;
float az = point2.Z - point1.Z;
float bx = point3.X - point1.X;
float by = point3.Y - point1.Y;
float bz = point3.Z - point1.Z;
// N=Cross(a,b)
float nx = ay * bz - az * by;
float ny = az * bx - ax * bz;
float nz = ax * by - ay * bx;
// Normalize(N)
float ls = nx * nx + ny * ny + nz * nz;
float invNorm = 1.0f / (float)SM.Sqrt((double)ls);
result.Normal.X = nx * invNorm;
result.Normal.Y = ny * invNorm;
result.Normal.Z = nz * invNorm;
// D = - Dot(N, point1)
result.D = -(result.Normal.X * point1.X + result.Normal.Y * point1.Y + result.Normal.Z * point1.Z);
return(result);
}
/// <summary>
/// Computes the new motor velocity based on the current velocity, such that the velocity always moves towards
/// the set point (if regulation is active), or the acceleration curve dictated by the <see cref="Acceleration" />
/// property.
/// The magnitude of the returned speed will never be greater than <see cref="StepperMotor.MaximumSpeed" /> which in turn
/// can never
/// exceed <see cref="StepperMotor.MaximumPossibleSpeed" />.
/// <see cref="StepperMotor.MaximumSpeed" />.
/// </summary>
/// <returns>The computed velocity, in steps per second.</returns>
/// <remarks>
/// A positive value indicates speed in the forward direction, while a negative value indicates speed in the reverse
/// direction.
/// 'forward' is defined as motion towards a higher position value; 'reverse' is defined as motion towards a lower
/// position value.
/// No attempt is made here to define the mechanical direction. A speed value that is within
/// <see cref="StepperMotor.MotorStoppedThreshold" />
/// of zero is considered to mean that the motor should be stopped.
/// </remarks>
double ComputeAcceleratedVelocity()
{
var distanceToGo = ComputeDistanceToTarget();
var absoluteDistance = Math.Abs(distanceToGo);
var direction = Math.Sign(distanceToGo);
if (distanceToGo == 0)
{
return(0.0); // We're there.
}
if (!IsMoving)
{
return(Math.Sqrt(2.0 * Acceleration) * direction); // Accelerate away from stop.
}
// Compute the unconstrained target speed based on the deceleration curve or the regulation set point.
var targetSpeed = regulating ? speedSetpoint : Math.Sqrt(2.0 * absoluteDistance * Acceleration) * direction;
// The change in speed is a function of the absolute current speed and acceleration.
var increment = Acceleration / Math.Abs(motorSpeed);
var directionOfChange = Math.Sign(targetSpeed - motorSpeed);
var newSpeed = motorSpeed + increment * directionOfChange;
// The computed new speed must be constrained by both the MaximumSpeed and the acceleration curve.
var clippedSpeed = newSpeed.ConstrainToLimits(-maximumSpeed, +maximumSpeed);
return(clippedSpeed);
}
/// <summary>光線r = p + td, |vD| = 1が球sに対して交差しているかどうか。</summary>
/// <param name="rvP">基点</param>
/// <param name="vD">方向ベクトル</param>
/// <param name="rS">対象とする球体</param>
/// <param name="t">0≦ｔ≦Tmax</param>
/// <param name="hit">交差した位置</param>
/// <return>交差している場合、交差している*tの値および交差点*hitを返す</return>
public static bool IntersectRaySphere(MCVector3 rvP, MCVector3 vD, Sphere rS, out float t, out MCVector3 hit)
{
hit = new MCVector3();
t = 0;
MCVector3 vM = rvP - rS.c;
float fB = vM.Dot(vD);
float fC = vM.Dot(vM) - rS.r * rS.r;
// rの原点が*rSの外側にあり(c > 0)、rが*rSから離れていく方向を指している場合(fB > 0)に終了
if (fC > 0.0f && fB > 0.0f)
{
return(false);
}
float fDiscr = fB * fB - fC;
// 負の判別式は光線が球を外れていることに一致
if (fDiscr < 0.0f)
{
return(false);
}
// これで光線は球と交差していることが分かり、交差する最小の値*tを計算
t = -fB - (float)Mt.Sqrt(fDiscr);
// *tが負である場合、光線は球の内側から開始しているので*tをゼロにクランプ
if (t < 0.0f)
{
t = 0.0f;
}
hit = rvP + t * vD;
return(true);
}
/// <summary>
/// 将stec转换为vtec
/// </summary>
/// <param name="stec"></param>
/// <param name="ele">高度角(弧度)</param>
/// <param name="earthRadius">地球半径(默认6371000)</param>
/// <param name="ionoHeight">电离层单层模型高度(默认450000)</param>
/// <returns></returns>
public static double STEC2VTEC(double stec, double ele, double earthRadius = 6371100, double ionoHeight = 450000)
{
double sinz = Math.Sin(PI / 2d - ele);
double sinzz = earthRadius / (earthRadius + ionoHeight) * sinz;
double coszz = Math.Sqrt(1d - sinzz * sinzz);
return(stec * coszz);
}
/// <summary>
/// Returns the x solution to the equation ax^2 + bx + c = 0.
/// </summary>
/// <param name="a">Multiplier to x^2.</param>
/// <param name="b">Multiplier to x.</param>
/// <param name="c">Constant.</param>
/// <returns></returns>
public static double[] QuadraticFormula(double a, double b, double c)
{
double denominator = 2 * a;
double operand1 = -b / denominator;
double operand2 = NMath.Sqrt(b.Squared() - 4 * a * c) / denominator;
return(operand1.PlusMinus(operand2));
}
public static double Distance(Vector3D value1, Vector3D value2)
{
double num1 = value1.X - value2.X;
double num2 = value1.Y - value2.Y;
double num3 = value1.Z - value2.Z;
return(SystemMath.Sqrt(num1 * num1 + num2 * num2 + num3 * num3));
}
public static double Distance(Vector2D x, Vector2D y)
{
if (x == null || y == null)
{
return(double.MaxValue);
}
return(SysMath.Sqrt(SysMath.Pow(y.X - x.X, 2) + SysMath.Pow(y.Y - x.Y, 2)));
}
/// <summary>
/// Returns the distance between two vectors.
/// </summary>
public static float Distance(Vector3 a, Vector3 b)
{
Vector3 diff = new Vector3(
a.x - b.x,
a.y - b.y,
a.z - b.z);
return((float)Maths.Sqrt(Maths.Pow(diff.x, 2f) + Maths.Pow(diff.y, 2f) + Maths.Pow(diff.z, 2f)));
}
/// <summary>
/// Changes the coefficients of the normal vector of the plane to make it of unit length.
/// </summary>
/// <param name="plane">The source plane.</param>
/// <param name="result">When the method completes, contains the normalized plane.</param>
public static void Normalize(ref Plane plane, out Plane result)
{
float magnitude = 1.0f / (float)(SMath.Sqrt((plane.Normal.X * plane.Normal.X) + (plane.Normal.Y * plane.Normal.Y) + (plane.Normal.Z * plane.Normal.Z)));
result.Normal.X = plane.Normal.X * magnitude;
result.Normal.Y = plane.Normal.Y * magnitude;
result.Normal.Z = plane.Normal.Z * magnitude;
result.D = plane.D * magnitude;
}
/// <summary>
/// Changes the coefficients of the normal vector of the plane to make it of unit length.
/// </summary>
public void Normalize()
{
float magnitude = 1.0f / (float)(SMath.Sqrt((Normal.X * Normal.X) + (Normal.Y * Normal.Y) + (Normal.Z * Normal.Z)));
Normal.X *= magnitude;
Normal.Y *= magnitude;
Normal.Z *= magnitude;
D *= magnitude;
}
public static float Distance(Vector2 value1, Vector2 value2)
{
float dx = value1.X - value2.X;
float dy = value1.Y - value2.Y;
float ls = dx * dx + dy * dy;
return((float)SM.Sqrt((double)ls));
}
public void Jump(float height)
{
var velocity = Body.GetLinearVelocity();
var vYForHeight = (float)Math.Sqrt(2f * 9.8f * height);
velocity.Y = -vYForHeight;
Body.SetLinearVelocity(velocity);
}
public double NextGaussian()
{
const double mean = 0, stdDev = 1;
double u1 = 1.0 - rand.NextDouble();
double u2 = 1.0 - rand.NextDouble();
double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
return(mean + stdDev * randStdNormal);
}
/// <summary>
/// Standard Deviation of Y (requires at least 2 samples)
/// </summary>
/// <returns>Standard Deviation of Y</returns>
public double Qy()
{
if (!(N > 1))
{
throw new InvalidOperationException(
"There must be more than one sample to find the Standard Deviation.");
}
return(Math.Sqrt(Sy2 - Math.Pow(Sy, 2) / N) / (N - 1));
}
/// <summary>
/// The y-coordinates of a line intersecting a circle centered at 0,0.
/// </summary>
/// <param name="radius"></param>
/// <param name="lineLength"></param>
/// <param name="incidence"></param>
/// <param name="determinant"></param>
/// <param name="delta"></param>
/// <returns></returns>
public static double[] CircleLineIntersectY(
double radius,
double lineLength,
double incidence,
double determinant,
Offset delta)
{
return((-determinant * delta.X() / lineLength.Squared()).PlusMinus(
NMath.Abs(delta.Y()) * NMath.Sqrt(incidence) / lineLength.Squared()));
}
/// <summary>
/// Performs the square root of the sum of the squares of the provided values.
/// </summary>
/// <param name="values"></param>
/// <returns></returns>
public static double SRSS(params double[] values)
{
double sumOfSquares = 0;
foreach (double value in values)
{
sumOfSquares += value.Squared();
}
return(NMath.Sqrt(sumOfSquares));
}
