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