static void testpowperformance(int start, int end, int times = 10000000)
{
Random r = new Random();
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < times; i++)
{
for (int j = start; j < end; j++)
{
double y1 = FastPow.Pow(r.NextDouble(), j);
}
}
sw.Stop();
Console.WriteLine(sw.ElapsedTicks);
sw.Reset();
sw.Start();
for (int i = 0; i < times; i++)
{
for (int j = start; j < end; j++)
{
double y2 = Math.Pow(r.NextDouble(), j);
}
}
sw.Stop();
Console.WriteLine(sw.ElapsedTicks);
Console.ReadLine();
}
protected virtual double speed_sound(double T, double p)
{
double tau = T_star / T, PI = p / p_star;
double RHS = (1 + 2 * PI * dgammar_dPI(T, p) + PI * PI * FastPow.Pow(dgammar_dPI(T, p), 2)) / ((1 - PI * PI * d2gammar_dPI2(T, p)) + FastPow.Pow(1 + PI * dgammar_dPI(T, p) - tau * PI * d2gammar_dPIdTAU(T, p), 2) / (tau * tau * (d2gammar0_dTAU2(T, p) + d2gammar_dTAU2(T, p))));
return(Math.Sqrt(R * 1000 * T * RHS));
}
double delTr(double rho)
{
/// This is the IF97 correlation for drhodp at the reducing temperature, Tr
double rhobar = rho / Constants.Rhocrit;
double summer = 0;
int j;
//
if (rhobar <= 0.310559006)
{
j = 0;
}
else if (rhobar <= 0.776397516)
{
j = 1;
}
else if (rhobar <= 1.242236025)
{
j = 2;
}
else if (rhobar <= 1.863354037)
{
j = 3;
}
else
{
j = 4;
}
//
for (int i = 0; i < 6; i++)
{
summer += Constants.A[i, j] * FastPow.Pow(rhobar, i);
}
return(1.0 / summer);
}
static double lambda0(double T)
{
double T_bar = T / Constants.Tcrit;
double summer = 0.0;
for (int i = 0; i < lamJ0.Length; ++i)
{
summer += lamn0[i] / FastPow.Pow(T_bar, lamJ0[i]);
}
return(Math.Sqrt(T_bar) / summer);
}
static double mu0(double T)
{
double T_bar = T / Constants.Tcrit;
double summer = 0.0;
for (int i = 0; i < muJ0.Length; ++i)
{
summer += mun0[i] / FastPow.Pow(T_bar, muJ0[i]);
}
return(100.0 * Math.Sqrt(T_bar) / summer);
}
double d2phi_ddelta2(double T, double rho)
{
double delta = rho / Constants.Rhocrit, tau = Constants.Tcrit / T;
double summer = -nr[0] / (delta * delta);
for (int i = 1; i < 40; ++i)
{
summer += nr[i] * Ir[i] * (Ir[i] - 1.0) * FastPow.Pow(delta, Ir[i] - 2) * FastPow.Pow(tau, Jr[i]);
}
return(summer);
}
//
// These two extra terms Needed to evaluate Newton-Raphson
// ****************************************************************************
double dphi_ddelta(double T, double rho)
{
double delta = rho / Constants.Rhocrit, tau = Constants.Tcrit / T;
double summer = nr[0] / delta;
for (int i = 1; i < 40; ++i)
{
summer += nr[i] * Ir[i] * FastPow.Pow(delta, Ir[i] - 1) * FastPow.Pow(tau, Jr[i]);
}
return(summer);
}
static double phi(double T, double rho)
{
double delta = rho / Constants.Rhocrit, tau = Constants.Tcrit / T;
double summer = nr[0] * Math.Log(delta);
for (int i = 1; i < 40; ++i)
{
summer += nr[i] * FastPow.Pow(delta, Ir[i]) * FastPow.Pow(tau, Jr[i]);
}
return(summer);
}
double mu1(double T, double rho)
{
double rho_bar = rho / Constants.Rhocrit;
double summer = 0.0;
for (int i = 0; i < muJr.Length; ++i)
{
summer += rho_bar * FastPow.Pow(Trterm(T), muIr[i]) * munr[i] * FastPow.Pow(Rhorterm(rho), muJr[i]);
}
return(Math.Exp(summer));
}
double d2gammar0_dTAU2(double T, double _)
{
double _TAU = TAU0term(T);
double summer = 0;
for (int i = 0; i < J0.Length; ++i)
{
summer += n0[i] * J0[i] * (J0[i] - 1) * FastPow.Pow(_TAU, J0[i] - 2);
}
return(summer);
}
protected double d2gammar_dTAU2(double T, double p)
{
double _PI = PIrterm(p), _TAU = TAUrterm(T);
double summer = 0;
for (int i = 0; i < Jr.Length; ++i)
{
summer += nr[i] * Jr[i] * (Jr[i] - 1) * FastPow.Pow(_PI, Ir[i]) * FastPow.Pow(_TAU, Jr[i] - 2);
}
return(summer);
}
static double lambda1(double T, double rho)
{
double rho_bar = rho / Constants.Rhocrit;
double summer = 0.0;
for (int i = 0; i < lamJr.Length; ++i)
{
summer += rho_bar * FastPow.Pow(Trterm(T), lamIr[i]) * lamnr[i] * FastPow.Pow(Rhorterm(rho), lamJr[i]);
}
return(Math.Exp(summer));
}
static double deltatau_d2phi_ddelta_dtau(double T, double rho)
{
double delta = rho / Constants.Rhocrit, tau = Constants.Tcrit / T;
double summer = 0;
for (int i = 1; i < 40; ++i)
{
summer += nr[i] * Jr[i] * Ir[i] * FastPow.Pow(delta, Ir[i]) * FastPow.Pow(tau, Jr[i]);
}
return(summer);
}
// Add function for Tb23(h,s) Boundary Line. There will only be one instance below.
// It may double as Tsat(h,s) in Region 4 as well.
public virtual double t_hs(double h, double s)
{
double eta = h / h_star, sigma = s / s_star;
double summer = 0;
for (int i = 0; i < N; ++i)
{
summer += n[i] * FastPow.Pow(eta + a, I[i]) * FastPow.Pow(sigma + b, J[i]);
}
return(summer * T_star);
}
// This function implements the backward formulas for p(h,s) as defined in the IAPWS
// supplementary releases of 2014 for regions 1, 2, and 3. It should only be called
// when the appropriate coefficients are provided for a p(h,s) instance of this class.
public double p_hs(double h, double s)
{
double eta = h / h_star, sigma = s / s_star;
double summer = 0;
for (int i = 0; i < N; ++i)
{
summer += n[i] * FastPow.Pow(eta + a, I[i]) * FastPow.Pow(sigma + b, J[i]);
}
return(Math.Pow(summer, c) * p_star);
}
// This function imitates the Region3BackwardsRegion structure already written above
// for v(T,p) in Region 3. However, it can be used for the functions T(p,h) [Y=T, X=h] or
// T(p,s) [Y=T, X=s] in Regions 1, 2, or 3. Additionally, it can be called for
// v(p,h) [Y=v, X=h] or v(p,s) [Y=v, X=s] in Region 3. since there are no direct formulas
// for v(p,h) and v(p,s) in Regions 1 and 2, they have got be evaluated in a two step
// process by evaluating v(T,p) using T(p,X) and the p value supplied.
public double T_pX(double p, double X)
{
double pi = p / p_star, eta = X / X_star;
double summer = 0;
for (int i = 0; i < N; ++i)
{
summer += n[i] * Math.Pow(pi + a, I[i]) * FastPow.Pow(eta + b, J[i]) * FastPow.Pow(f, J[i]);
}
return(summer * T_star);
}
static void testpow(int start, int end)
{
double x = 2;
for (int j = start; j < end; j++)
{
double y1 = FastPow.Pow(x, j);
double y2 = Math.Pow(x, j);
Console.WriteLine(String.Format("{0}:{1}", j, y1 - y2));
}
Console.ReadLine();
}
// This function implements the backward boundary formulas for h'(s), h"(s) as defined
// in the IAPWS supplementary releases of 2014 for region 3. It should only be called
// when the appropriate coefficients are provided for an h(s) instance of this class.
public virtual double h_s(double s)
{
double sigma1 = s / s_star, sigma2 = s / s2_star;
double summer = 0;
for (int i = 0; i < N; ++i)
{
summer += n[i] * FastPow.Pow(Math.Pow(sigma1, d) + a, I[i]) * FastPow.Pow(sigma2 + b, J[i]);
}
// NOTE: c=1, e=0 : Straight summation
// c>1, e=0 : Power fit
// c=1, e=1 : Exp fit
return(((1 - e) * Math.Pow(summer, c) + e * Math.Exp(summer)) * h_star);
}
public static double p_T(double T)
{
// Allow extrapolation down to Pmin = P(Tmin=273.15K) = 611.213 Pa
if ((T < Constants.Tmin) || (T > Constants.Tcrit))
{
throw new ArgumentOutOfRangeException("Temperature out of range");
}
double theta = T / T_star + n[9] / (T / T_star - n[10]);
double A = theta * theta + n[1] * theta + n[2];
double B = n[3] * theta * theta + n[4] * theta + n[5];
double C = n[6] * theta * theta + n[7] * theta + n[8];
return(p_star * FastPow.Pow(2 * C / (-B + Math.Sqrt(B * B - 4 * A * C)), 4));
}
double gammar0(double T, double p)
{
if (J0.Length == 0)
{
return(0);
} // Region 1 has no term
double PI = p / p_star, _TAU = TAU0term(T);
double summer = Math.Log(PI);
for (int i = 0; i < n0.Length; ++i)
{
summer += n0[i] * FastPow.Pow(_TAU, J0[i]);
}
return(summer);
}
protected virtual double cvmass(double T, double p)
{
double tau = T_star / T, PI = p / p_star;
return(cpmass(T, p) - R * FastPow.Pow(1 + PI * dgammar_dPI(T, p) - tau * PI * d2gammar_dPIdTAU(T, p), 2) / (1 - PI * PI * d2gammar_dPI2(T, p)));
}
