lindo pato cole
utilizando el sistema;
espacio de nombres Legalsoft.Truffer
{ /// <summary> /// Integrales elípticas y funciones elípticas jacobianas /// </summary> public class Elliptic { public Elliptic() { }
private static double rc(doble x, doble y)
{ const double ERRTOL = 0.0012; const doble TERCERO = 1.0 / 3.0; constante doble C1 = 0,3; constante doble C2 = 1,0 / 7,0; constante doble C3 = 0,375; constante doble C4 = 9,0 / 22,0; const double TINY = 5.0 * float.MinValue; const doble GRANDE = 0.2 * doble.MaxValue;
doble COMP1 = 2.236 / Math.Sqrt(MINUTO);
doble COMP2 = Globals.SQR(MINUTO * GRANDE) / 25.0;
//si (x < 0.0 || y == 0.0 || (x + Math.Abs(y)) < PEQUEÑO || (x + Math.Abs(y)) > GRANDE || (y < -COMP1 && x > 0.0 && x < COMP2))
if (x < 0.0 || Math.Abs(y) <= float.Epsilon || (x + Math.Abs(y)) < PEQUEÑO || (x + Math.Abs(y) )) > GRANDE || (y < -COMP1 && x > 0.0 && x < COMP2))
{ throw new Exception("argumentos inválidos en rc"); }
doble xt;
doble yt;
doble w;
si (y > 0.0)
{ xt = x; yt = y; w = 1,0; } más { xt = x - y; yt = -y; w = Math.Sqrt(x) / Math.Sqrt(xt); }
doble s;
doble avenida;
do
{ double alamb = 2.0 * Math.Sqrt(xt) * Math.Sqrt(yt) + yt; xt = 0,25 * (xt + alamb); yt = 0,25 * (yt + alamb); ave = TERCERO * (xt + yt + yt); s = (yt - promedio) / promedio; } while (Math.Abs(s) > ERRTOL); return w * (1.0 + s * s * (C1 + s * (C2 + s * (C3 + s * C4)))) / Math.Sqrt(ave); }
privado estático doble rd(doble x, doble y, doble z)
{ const doble ERRTOL = 0.0015; constante doble C1 = 3,0 / 14,0; constante doble C2 = 1,0 / 6,0; constante doble C3 = 9,0 / 22,0; constante doble C4 = 3,0 / 26,0; constante doble C5 = 0,25 * C3; constante doble C6 = 1,5 * C4; doble PEQUEÑO = 2.0 * Math.Pow(doble.MaxValue, -2.0 / 3.0); doble GRANDE = 0.1 * ERRTOL * Math.Pow(float.MinValue, -2.0 / 3.0);
doble avenida;
doble delx;
doble retraso;
doble delz;
if (Math.Min(x, y) < 0.0 || Math.Min(x + y, z) < PEQUEÑO || Math.Max(Math.Max(x, y), z) > GRANDE) {
lanza una nueva excepción ("argumentos inválidos en rd"); } doble xt = x; doble yt = y; doble zt = z; doble suma = 0.0; doble cara = 1,0; hacer { doble sqrtx = Math.Sqrt(xt); doble sqrty = Matemáticas.Sqrt(yt); doble sqrtz = Matemáticas.Sqrt(zt);
double alamb = sqrtx * (sqrty + sqrtz) + sqrty * sqrtz;
suma += fac / (sqrtz * (zt + alamb));
fact = 0,25 * fact;
xt = 0,25 * (xt + alamb);
yt = 0,25 * (yt + alamb);
zt = 0,25 * (zt + alamb);
media = 0,2 * (xt + yt + 3,0 * zt);
delx = (promedio - xt) /promedio;
retraso = (promedio - yt) /promedio;
delz = (promedio - zt) /promedio;
} while (Math.Max(Math.Max(Math.Abs(delx), Math.Abs(dely)), Math.Abs(delz)) > ERRTOL);
doble ea = delx * dely;
doble eb = delz * delz;
doble ec = ea - eb;
doble ed = ea - 6.0 * eb;
doble ee = ed + ec + ec;
return 3.0 * sum + fac * (1.0 + ed * (-C1 + C5 * ed - C6 * delz * ee) + delz * (C2 * ee + delz * (-C3 * ec + delz * C4 * ea))) / (promedio * Math.Sqrt(promedio));
}
rf doble estático privado (doble x, doble y, doble z)
{ const doble ERRTOL = 0.0025; const doble TERCERO = 1.0 / 3.0; constante doble C1 = 1,0 / 24,0; constante doble C2 = 0,1; constante doble C3 = 3,0 / 44,0; constante doble C4 = 1,0 / 14,0; doble TINY = 5.0 * float.MinValue; doble GRANDE = 0.2 * doble.MaxValue;
doble avenida;
doble delx;
doble retraso;
doble delz;
if (Math.Min(Math.Min(x, y), z) < 0.0 || Math.Min(Math.Min(x + y, x + z), y + z) < PEQUEÑO || Math.Max( Math.Max(x, y), z) > BIG)
{ throw new Exception("argumentos inválidos en rf"); } doble xt = x; doble yt = y; doble zt = z; hacer { doble sqrtx = Math.Sqrt(xt); doble sqrty = Matemáticas.Sqrt(yt); doble sqrtz = Matemáticas.Sqrt(zt);
double alamb = sqrtx * (sqrty + sqrtz) + sqrty * sqrtz;
xt = 0,25 * (xt + alamb);
yt = 0,25 * (yt + alamb);
zt = 0,25 * (zt + alamb);
ave = TERCERO * (xt + yt + zt);
delx = (promedio - xt) /promedio;
retraso = (promedio - yt) /promedio;
delz = (promedio - zt) /promedio;
} while (Math.Max(Math.Max(Math.Abs(delx), Math.Abs(dely)), Math.Abs(delz)) > ERRTOL);
doble e2 = delx * dely - delz * delz;
doble e3 = delx * dely * delz;
return (1.0 + (C1 * e2 - C2 - C3 * e3) * e2 + C4 * e3) / Math.Sqrt(promedio);
}
privado estático doble rj(doble x, doble y, doble z, doble p)
{ const doble ERRTOL = 0.0015; constante doble C1 = 3,0 / 14,0; const doble C2 = 1.0 / 3.0; constante doble C3 = 3,0 / 22,0; constante doble C4 = 3,0 / 26,0; doble C5 = 0,75 * C3; doble C6 = 1,5 * C4; doble C7 = 0,5 * C2; doble C8 = C3 + C3; doble PEQUEÑO = Math.Pow(5.0 * float.MinValue, 1.0 / 3.0); doble GRANDE = 0.3 * Math.Pow(0.2 * doble.MaxValue, 1.0 / 3.0); doble a = 0.0;
doble avenida;
doble b = 0,0;
doble delp;
doble delx;
doble retraso;
doble delz;
doble rcx = 0.0;
si (Math.Min(Math.Min(x, y), z) < 0.0 || Math.Min(Math.Min(x + y, x + z), Math.Min(y + z, Math.Abs( p))) < PEQUEÑO || Math.Max(Math.Max(x, y), Math.Max(z, Math.Abs(p))) > GRANDE) {
lanza una nueva excepción ("argumentos no válidos en rj") ; } doble suma = 0.0; doble cara = 1,0; doble xt; doble yt; doble zt; punto doble;
si (p > 0.0)
{ xt = x; yt = y; zt = z; pto = p; } else { xt = Math.Min(Math.Min(x, y), z); zt = Math.Max(Math.Max(x, y), z); yt = x + y + z - xt - zt; a = 1.0 / (yt - p); b = a * (zt - yt) * (yt - xt); pt = yt + b; doble rho = xt * zt / yt; doble tau = p * pt / yt; rcx = rc(rho, tau); }
hacer
{ doble sqrtx = Math.Sqrt(xt); doble sqrty = Matemáticas.Sqrt(yt); doble sqrtz = Matemáticas.Sqrt(zt); double alamb = sqrtx * (sqrty + sqrtz) + sqrty * sqrtz; doble alfa = Globals.SQR(pt * (sqrtx + sqrty + sqrtz) + sqrtx * sqrty * sqrtz); doble beta = pt * Globals.SQR(pt + alamb); suma += fac * rc(alfa, beta); fact = 0,25 * fact; xt = 0,25 * (xt + alamb); yt = 0,25 * (yt + alamb); zt = 0,25 * (zt + alamb); pt = 0,25 * (pt + alamb);
media = 0,2 * (xt + yt + zt + pt + pt);
delx = (promedio - xt) /promedio;
retraso = (promedio - yt) /promedio;
delz = (promedio - zt) /promedio;
delp = (ave - pt) /ave;
} while (Math.Max(Math.Max(Math.Abs(delx), Math.Abs(dely)), Math.Max(Math.Abs(delz), Math.Abs(delp))) > ERRTOL);
doble ea = delx * (dely + delz) + dely * delz;
doble eb = delx * dely * delz;
doble ec = delp * delp;
doble ed = ea - 3.0 * ec;
doble ee = eb + 2.0 * delp * (ea - ec);
doble respuesta = 3.0 * sum + fac * (1.0 + ed * (-C1 + C5 * ed - C6 * ee) + eb * (C7 + delp * (-C8 + delp * C4)) + delp * ea * (C2 - delp * C3) - C2 * delp * ec) / (ave * Math.Sqrt(ave));
if (p <= 0.0)
{ ans = a * (b * ans + 3.0 * (rcx - rf(xt, yt, zt))); } volver respuesta; }
ellf doble estático privado (doble phi, doble ak)
{ doble s = Math.Sin (phi); return s * rf(Globals.SQR(Math.Cos(phi)), (1.0 - s * ak) * (1.0 + s * ak), 1.0); }
elle doble estática privada (doble phi, doble ak)
{ doble s = Math.Sin (phi); doble cc = Globals.SQR(Math.Cos(phi)); doble q = (1.0 - s * ak) * (1.0 + s * ak); return s * (rf(cc, q, 1.0) - (Globals.SQR(s * ak)) * rd(cc, q, 1.0) / 3.0); }
privado estático doble ellpi (doble phi, doble en, doble ak)
{ doble s = Math.Sin (phi); doble ens = en * s * s; doble cc = Globals.SQR(Math.Cos(phi)); doble q = (1.0 - s * ak) * (1.0 + s * ak); return s * (rf(cc, q, 1.0) - enss * rj(cc, q, 1.0, 1.0 + enss) / 3.0); }
privado static void sncndn(doble uu, doble emmc, ref doble sn, ref doble cn, ref doble dn)
{ const doble CA = 1.0e-8; intl = 0; doble c = 0,0; doble d = 0,0; doble[] em = nuevo doble[13]; doble[] es = nuevo doble[13]; doble emc = emmc; doble u = uu; if (emc != 0.0) { bool bo = (emc < 0.0); si (bo) { d = 1.0 - emc; emc /= -1.0 / d; u *= (d = Math.Sqrt(d));
}
doble a = 1.0;
dn = 1,0;
para (int i = 0; i < 13; i++)
{ l = i; em[i] = un; en[i] = (emc = Math.Sqrt(emc)); c = 0,5 * (a + emc); if (Math.Abs(a - emc) <= CA * a) { break; } emc *= un; a = c; } tu *= c; sn = Math.Sin(u); cn = Math.Cos(u);
si (sn != 0.0)
{ a = cn / sn; c*= un; for (int ii = l; ii >= 0; ii--) { double b = em[ii]; un *= c; c *= dn; dn = (en[ii] + a) / (b + a); a = c/b; } a = 1.0 / Math.Sqrt(c * c + 1.0); sn = (sn >= 0.0 ? a : -a); cn = c * sn; } si (bo) {
a = dn;
dn = cn;
cn = un;
sn /= d;
}
}
más
{ cn = 1.0 / Math.Cosh(u); dn = cn; sn = Math.Tanh(u); } } } }