public static double TorsionalAngle(Vector p1, Vector p2, Vector p3, Vector p4) { //function angle = torangle(atom1, atom2, atom3, atom4) // plane_123 = cross(atom2-atom1, atom3-atom2); n1 = plane_123; n1 = n1 / sqrt(dot(n1,n1)); // plane_234 = cross(atom3-atom2, atom4-atom3); n2 = plane_234; n2 = n2 / sqrt(dot(n2,n2)); // vec_23 = atom3 - atom2; b = vec_23; b = b / sqrt(dot(b,b)); // angle = atan2(dot(cross(n1,n2),b), dot(n1,n2)); //end Vector plane_123 = LinAlg.CrossProd(p2 - p1, p3 - p2); Vector n1 = plane_123.UnitVector(); Vector plane_234 = LinAlg.CrossProd(p3 - p2, p4 - p3); Vector n2 = plane_234.UnitVector(); Vector vec_23 = p3 - p2; Vector b = vec_23.UnitVector(); double angle = Math.Atan2(LinAlg.VtV(LinAlg.CrossProd(n1, n2), b), LinAlg.VtV(n1, n2)); { Vector p12 = p2 - p1; Vector p23 = p3 - p2; Vector p34 = p4 - p3; Vector nn1 = LinAlg.CrossProd(p12, p23).UnitVector(); Vector nn2 = LinAlg.CrossProd(p23, p34).UnitVector(); double a = AngleBetween(nn1, nn2); HDebug.Assert(Math.Abs(Math.Abs(a) - Math.Abs(angle)) < 0.00000001); } return(angle); }
public static Vector PlaneNormal(Vector pt1, Vector pt2, Vector pt3) { Vector a = pt2 - pt1; Vector b = pt3 - pt1; Vector n = LinAlg.CrossProd(a, b); return(n.UnitVector()); }
static void GetTriGeom(Vector pt1, Vector pt2, Vector pt3 , out double a, out double b, out double c , out double A, out double B, out double C , out double r , out Vector pto ) { Func <Vector, Vector, Vector, double> angle2 = delegate(Vector p1, Vector p2, Vector p3) { Vector v21 = p1 - p2; Vector v23 = p3 - p2; double d21 = v21.Dist; double d23 = v23.Dist; double cos2 = LinAlg.DotProd(v21, v23) / (d21 * d23); double ang2 = Math.Acos(cos2); return(ang2); }; //////////////////////////////////////////////////////////////// // 1 (1,2,3) // /A\ | // / | \ r // c | b | // / o \ origin // /B C\ // 2-----a-----3 // ///////////////////////////////////////////////////////////////// // http://schools-wikipedia.org/wp/t/Trigonometric_functions.htm // a/sinA = b/sinB = c/sinC = 2R Vector pt23 = pt2 - pt3; double dist23 = pt23.Dist; Vector pt31 = pt3 - pt1; double dist31 = pt31.Dist; Vector pt12 = pt1 - pt2; double dist12 = pt12.Dist; a = dist23; // =(pt2-pt3).Dist; // distance between pt2 and pt3 b = dist31; // =(pt3-pt1).Dist; // distance between pt2 and pt3 c = dist12; // =(pt1-pt2).Dist; // distance between pt2 and pt3 A = angle2(pt3, pt1, pt2); // angle A = ∠pt3-pt1(a)-pt2 B = angle2(pt1, pt2, pt3); // angle B = ∠pt1-pt2(b)-pt3 C = angle2(pt2, pt3, pt1); // angle C = ∠pt2-pt3(c)-pt1 r = 0.5 * a / Math.Sin(A); // Barycentric coordinates from cross- and dot-products // http://en.wikipedia.org/wiki/Circumscribed_circle#Barycentric_coordinates_as_a_function_of_the_side_lengths /// po = v1.p1 + v2.p2 + v3.p3 /// v1 = (|p2-p3|^2 * (p1-p2).(p1-p3)) / (2*|(p1-p2)x(p2-p3)|^2) = a*a*Dot( /// v2 = (|p1-p3|^2 * (p2-p1).(p2-p3)) / (2*|(p1-p2)x(p2-p3)|^2) = b*b*Dot( /// v3 = (|p1-p2|^2 * (p3-p1).(p3-p2)) / (2*|(p1-p2)x(p2-p3)|^2) = c*c*Dot( { double div = 2 * LinAlg.CrossProd(pt1 - pt2, pt2 - pt3).Dist2; double v1 = dist23 * dist23 * LinAlg.DotProd(pt12, -pt31) / div; double v2 = dist31 * dist31 * LinAlg.DotProd(-pt12, pt23) / div; double v3 = dist12 * dist12 * LinAlg.DotProd(pt31, -pt23) / div; pto = v1 * pt1 + v2 * pt2 + v3 * pt3; } }
public static Vector RotateTangentUnit(Vector pt, Vector axis1, Vector axis2) { Vector pt_on_axis = ClosestPointOnLine(axis1, axis2, pt, false); Vector direct_pt = (pt - pt_on_axis).UnitVector(); Vector direct_axis = (axis2 - axis1).UnitVector(); Vector direct_tanpt = LinAlg.CrossProd(direct_axis, direct_pt).UnitVector(); if (HDebug.IsDebuggerAttached) { Vector dbg_axis = LinAlg.CrossProd(direct_pt, direct_tanpt).UnitVector(); HDebug.AssertTolerance(0.00000001, (direct_axis - dbg_axis).Dist); } return(direct_tanpt); }
public static Trans3 GetTransformNoScale(Vector from1, Vector from2, Vector to1, Vector to2) { //HTLib.DoubleVector3 lfrom1 = new HTLib.DoubleVector3(from1); //HTLib.DoubleVector3 lfrom2 = new HTLib.DoubleVector3(from2); //HTLib.DoubleVector3 lto1 = new HTLib.DoubleVector3(to1 ); //HTLib.DoubleVector3 lto2 = new HTLib.DoubleVector3(to2 ); //HTLib.Trans3 ltrans = HTLib.Trans3.GetTransformNoScale(lfrom1, lfrom2, lto1, lto2); //return new Trans3(ltrans); { double ds = 1; //double dx = to2.x - from2.x; // dx + from2.x = to2.x //double dy = to2.y - from2.y; // dx + from2.y = to2.y //double dz = to2.z - from2.z; // dx + from2.z = to2.z Vector from = (from2 - from1).UnitVector(); Vector to = (to2 - to1).UnitVector(); Quaternion dr; double innerprod = LinAlg.DotProd(from, to); // InnerProduct(from,to); if (innerprod >= 1) { HDebug.Assert(innerprod == 1); dr = Quaternion.UnitRotation; } else { Vector axis = LinAlg.CrossProd(from, to); // CrossProduct(from, to); if (axis.Dist2 == 0) { // to avoid degenerate cases double mag = to.Dist / 100000000; axis = LinAlg.CrossProd(from, to + (new double[] { mag, mag * 2, mag * 3 })); //Vector.CrossProduct(from, to+new DoubleVector3(mag, mag*2, mag*3)); } double angle = Math.Acos(innerprod); dr = new Quaternion(axis, angle); HDebug.Assert(LinAlg.DotProd((dr.RotationMatrix * from), to) > 0.99999); } Trans3 trans = Trans3.GetTransform(-from1, 1, Quaternion.UnitRotation); trans = Trans3.AppendTrans(trans, Trans3.GetTransform(new double[3], ds, dr)); trans = Trans3.AppendTrans(trans, Trans3.GetTransform(to1, 1, Quaternion.UnitRotation)); //new Trans3(dx, dy, dz, ds, dr); if (HDebug.IsDebuggerAttached) { Vector fromto1 = trans.DoTransform(from1); HDebug.Assert((fromto1 - to1).Dist < 0.000001); Vector fromto2 = trans.DoTransform(from2); HDebug.Assert(((fromto2 - fromto1).UnitVector() - (to2 - to1).UnitVector()).Dist < 0.000001); } return(trans); } }
public static Tuple <Vector, Vector> LineOnTwoPlanes(Vector norm1, double val1, Vector norm2, double val2) { /// http://intumath.org/Math/Geometry/Analytic%20Geometry/plane-planeinter.html /// if (LineOnTwoPlanes_SelfTest) { LineOnTwoPlanes_SelfTest = false; Vector tn1 = new double[] { 1, 2, 3 }; Vector tn2 = new double[] { 2, 5, 3 }; double td1 = 10; double td2 = 2; LineOnTwoPlanes(tn1, td1, tn2, td2); } Vector norm = LinAlg.CrossProd(norm1, norm2); /// norm1' * pt = -val1 [n1x n1y n1z] [ptx] [-val1] [n1x n1y 0] [ptx] [-val1] /// norm2' * pt = -val2 => [n2x n2y n2z] * [pty] = [-val2] => [n2x n2y 0] * [pty] = [-val2] /// [ptz] [0 ] /// => [n1x n1y] * [ptx] = [-val1] => [n1x n1y] * [ptx] = [-val1] /// [n2x n2y] [pty] [-val2] [n2x n2y] [pty] [-val2] /// => [ptx] = [n1x n1y]-1 [-val1] = [ n2y -n1y] * [-val1] / (n1x*n2y - n1y*n2x) /// [pty] [n2x n2y] * [-val2] [-n2x n1x] [-val2] /// = [ n2y*-val1 + -n1y*-val2 ] / (n1x*n2y - n1y*n2x) /// [-n2x*-val1 + n1x*-val2 ] double n1x = norm1[0], n1y = norm1[1]; double n2x = norm2[0], n2y = norm2[1]; double div = n1x * n2y - n1y * n2x; Vector pt = new double[] { (n2y * -val1 + -n1y * -val2) / div, (-n2x * -val1 + n1x * -val2) / div, 0 }; if (HDebug.IsDebuggerAttached) { Vector dbg_pt; dbg_pt = pt + 1 * norm; HDebug.AssertTolerance(0.00000001, LinAlg.VtV(norm1, dbg_pt) + val1); HDebug.AssertTolerance(0.00000001, LinAlg.VtV(norm2, dbg_pt) + val2); dbg_pt = pt + 2 * norm; HDebug.AssertTolerance(0.00000001, LinAlg.VtV(norm1, dbg_pt) + val1); HDebug.AssertTolerance(0.00000001, LinAlg.VtV(norm2, dbg_pt) + val2); dbg_pt = pt - 2 * norm; HDebug.AssertTolerance(0.00000001, LinAlg.VtV(norm1, dbg_pt) + val1); HDebug.AssertTolerance(0.00000001, LinAlg.VtV(norm2, dbg_pt) + val2); } return(new Tuple <Vector, Vector>(pt, norm)); }
public static double DistancePointLine(Vector point, Vector line1, Vector line2) { // http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html if (DistancePointLine_selftest) { DistancePointLine_selftest = false; Vector tp = new Vector(2, 2, 0); Vector tl1 = new Vector(0, 0, -20); Vector tl2 = new Vector(0, 0, -10); double tdist0 = tp.Dist; double tdist1 = DistancePointLine(tp, tl1, tl2); double tdist2 = (ClosestPointOnLine(tl1, tl2, tp, false) - tp).Dist; HDebug.AssertTolerance(0.00000001, tdist0 - tdist1); HDebug.AssertTolerance(0.00000001, tdist0 - tdist2); } Vector x21 = line2 - line1; Vector x10 = line1 - point; double dist = LinAlg.CrossProd(x21, x10).Dist / x21.Dist; return(dist); }
public static Tuple <double, Vector, bool> MaxCircleBetweenCircles(Vector pt1, double rad1, Vector pt2, double rad2, Vector pt3, double rad3) { /// b:pt3 /// / \ /// / \ /// / \ /// o:pt1 ------ a:pt2 /// /// o : (0 , 0), radii ro /// a : (pax, 0), radii ra /// b : (pbx, pby), radii rb Vector uvec12 = (pt2 - pt1).UnitVector(); Vector uvec23 = (pt3 - pt2).UnitVector(); Vector uvec31 = (pt1 - pt3).UnitVector(); double cos123 = LinAlg.VtV(-uvec12, uvec23); double cos231 = LinAlg.VtV(-uvec23, uvec31); double cos312 = LinAlg.VtV(-uvec31, uvec12); double cos_aob; double ro, ra, rb; Vector po, pa, pb; if (cos123 > 0) { pa = pt1; ra = rad1; po = pt2; ro = rad2; pb = pt3; rb = rad3; cos_aob = cos123; } else if (cos231 > 0) { pa = pt2; ra = rad2; po = pt3; ro = rad3; pb = pt1; rb = rad1; cos_aob = cos231; } else if (cos312 > 0) { pa = pt2; ra = rad2; po = pt1; ro = rad1; pb = pt3; rb = rad3; cos_aob = cos312; } else { throw new Exception("cos123>0 and cos231>0"); } Vector uvec_oa = (pa - po).UnitVector(); Vector uvec_ob = (pb - po).UnitVector(); Vector normal = LinAlg.CrossProd(uvec_oa, uvec_ob); double sin_aob = normal.Dist; double pax = (pa - po).Dist; double pbx = (pb - po).Dist * cos_aob; double pby = (pb - po).Dist * sin_aob; Trans3 trans; { Vector npo = new double[] { 0, 0, 0 }; Vector npa = new double[] { 0, pax, 0 }; Vector npb = new double[] { 0, pbx, pby }; trans = Trans3.GetTransformNoScale(npo, npa, npb, po, pa, pb); if (HDebug.IsDebuggerAttached) { Vector pox = trans.DoTransform(npo); HDebug.AssertTolerance(0.0000001, po - trans.DoTransform(npo)); HDebug.AssertTolerance(0.0000001, pa - trans.DoTransform(npa)); HDebug.AssertTolerance(0.0000001, pb - trans.DoTransform(npb)); } } Tuple <double, Vector, bool> rad_cent_in = MaxCircleBetweenCircles(ro, ra, rb, pax, pbx, pby); if (rad_cent_in == null) { return(null); } double radius = rad_cent_in.Item1; bool cenerInTriangle = rad_cent_in.Item3; Vector center; { HDebug.Assert(rad_cent_in.Item2.Size == 2); center = new double[] { 0, rad_cent_in.Item2[0], rad_cent_in.Item2[1] }; center = trans.DoTransform(center); } if (HDebug.IsDebuggerAttached) { double radx_1 = (center - pt1).Dist - rad1; double radx_2 = (center - pt2).Dist - rad2; double radx_3 = (center - pt3).Dist - rad3; HDebug.AssertTolerance(0.000001, radx_1 - radx_2, radx_2 - radx_3, radx_3 - radx_1); HDebug.AssertTolerance(0.00000001, LinAlg.VtV(normal, pt1 - pt2)); HDebug.AssertTolerance(0.00000001, LinAlg.VtV(normal, pt2 - pt3)); HDebug.AssertTolerance(0.00000001, LinAlg.VtV(normal, pt3 - pt1)); HDebug.AssertTolerance(0.00000001, LinAlg.VtV(normal, pt1 - center)); HDebug.AssertTolerance(0.00000001, LinAlg.VtV(normal, pt2 - center)); HDebug.AssertTolerance(0.00000001, LinAlg.VtV(normal, pt3 - center)); } return(new Tuple <double, Vector, bool>(radius, center, cenerInTriangle)); }
public static void GetTriGeom(Vector pa, Vector pb, Vector pc , out double a, out double b, out double c , out double A, out double B, out double C , out double r , out Vector po ) { Func <Vector, Vector, Vector, double> angle2 = delegate(Vector p1, Vector p2, Vector p3) { Vector v21 = p1 - p2; Vector v23 = p3 - p2; double d21 = v21.Dist; double d23 = v23.Dist; double cos2 = LinAlg.DotProd(v21, v23) / (d21 * d23); double ang2 = Math.Acos(cos2); return(ang2); }; //////////////////////////////////////////////////////////////// // 1 (1,2,3) // /A\ | // / | \ r // c | b | // / o \ origin // /B C\ // 2-----a-----3 // ///////////////////////////////////////////////////////////////// // http://schools-wikipedia.org/wp/t/Trigonometric_functions.htm // a/sinA = b/sinB = c/sinC = 2R Vector pt23 = pb - pc; double dist23 = pt23.Dist; Vector pt31 = pc - pa; double dist31 = pt31.Dist; Vector pt12 = pa - pb; double dist12 = pt12.Dist; a = dist23; // =(pt2-pt3).Dist; // distance between pt2 and pt3 b = dist31; // =(pt3-pt1).Dist; // distance between pt2 and pt3 c = dist12; // =(pt1-pt2).Dist; // distance between pt2 and pt3 A = angle2(pc, pa, pb); // angle A = ∠pt3-pt1(a)-pt2 B = angle2(pa, pb, pc); // angle B = ∠pt1-pt2(b)-pt3 C = angle2(pb, pc, pa); // angle C = ∠pt2-pt3(c)-pt1 r = 0.5 * a / Math.Sin(A); // Barycentric coordinates from cross- and dot-products // http://en.wikipedia.org/wiki/Circumscribed_circle#Barycentric_coordinates_as_a_function_of_the_side_lengths /// po = v1.p1 + v2.p2 + v3.p3 /// v1 = (|p2-p3|^2 * (p1-p2).(p1-p3)) / (2*|(p1-p2)x(p2-p3)|^2) = a*a*Dot( /// v2 = (|p1-p3|^2 * (p2-p1).(p2-p3)) / (2*|(p1-p2)x(p2-p3)|^2) = b*b*Dot( /// v3 = (|p1-p2|^2 * (p3-p1).(p3-p2)) / (2*|(p1-p2)x(p2-p3)|^2) = c*c*Dot( { double div = 2 * LinAlg.CrossProd(pa - pb, pb - pc).Dist2; double v1 = dist23 * dist23 * LinAlg.DotProd(pt12, -pt31) / div; double v2 = dist31 * dist31 * LinAlg.DotProd(-pt12, pt23) / div; double v3 = dist12 * dist12 * LinAlg.DotProd(pt31, -pt23) / div; po = v1 * pa + v2 * pb + v3 * pc; } if (HDebug.IsDebuggerAttached) { double la, lb, lc; double lA, lB, lC; double lr; Vector lpo; Geometry.GetTriGeom(pa, pb, pc, out la, out lb, out lc, out lA, out lB, out lC, out lr, out lpo); HDebug.Assert(la == a, lb == b, lc == c); HDebug.Assert(lA == A, lB == B, lC == C); HDebug.Assert(lr == r); HDebug.Assert(lpo == po); } }
public static double DerivativeOfTriangleRadius(Vector p1, Vector p2, Vector p3, Vector dp1, Vector dp2, Vector dp3) { /// r = |p1-p2|*|p2-p3|*|p3-p1| / (2 area(p1,p2,p3)) /// = |p1-p2|*|p2-p3|*|p3-p1| / (2 |(p1-p2)x(p2-p3)|) /// r2 = ( |p1-p2|*|p2-p3|*|p3-p1| / (2 area(p1,p2,p3)) )^2 /// = |p1-p2|^2 * |p2-p3|^2 * |p3-p1|^2 / (4 |(p1-p2)x(p2-p3)|^2) /// (r+dr*t) = R = |(p1+dp1*t)-(p2+dp2*t)|*|(p2+dp2*t)-(p3+dp3*t)|*|(p3+dp3*t)-(p1+dp1*t)| / (2 area(p1+dp1*t,p2+dp2*t,p3+dp3*t)) /// (r+dr*t)2 = R2 = { |(p1+dp1*t)-(p2+dp2*t)|*|(p2+dp2*t)-(p3+dp3*t)|*|(p3+dp3*t)-(p1+dp1*t)| / (2 area(p1+dp1*t,p2+dp2*t,p3+dp3*t)) }^2 /// /// d(r+dr*t)/dt = dR_dt /// = d(r+dr*t)/d((r+dr*t)^2) * d((r+dr*t)^2)/dt /// = dR_dR2 * dR2_dt /// d(r+dr*t)/d((r+dr*t)^2) = dR_dR2 /// = 1/(2*r) /// d((r+dr*t)^2)/dt = dR2_dt /// = + ( Dotp31dp31 * P12dist2 * P23dist2 /// + Dotp23dp31 * P12dist2 * P31dist2 /// + Dotp12dp12 * P23dist2 * P31dist2 /// )/(2 * Area2) /// - ( DotCroP12P23CroP12Dp23CroDp12P23 * P12dist2 * P23dist2 * P31dist2)/(2 * Area4) /// /// P12dist2 := ((p1x-p2x)^2+(p1y-p2y)^2+(p1z-p2z)^2) = (p1-p2).dist2 /// P23dist2 := ((p2x-p3x)^2+(p2y-p3y)^2+(p2z-p3z)^2) = (p2-p3).dist2 /// P31dist2 := ((p1x-p3x)^2+(p1y-p3y)^2+(p1z-p3z)^2) = (p1-p3).dist2 /// Dotp12dp12 := ((dp1x-dp2x)*(p1x-p2x) + (dp1y-dp2y)*(p1y-p2y) + (dp1z-dp2z)*(p1z-p2z)) /// = [dp1x-dp2x, dp1y-dp2y, dp1z-dp2z] . [p1x-p2x, p1y-p2y, p1z-p2z] /// = (dp1-dp2).(p1-p2) /// Dotp23dp31 := ((dp2x-dp3x)*(p2x-p3x) + (dp2y-dp3y)*(p2y-p3y) + (dp2z-dp3z)*(p2z-p3z)) /// = (dp2-dp3).(p2-p3) /// Dotp31dp31 := ((dp1x-dp3x)*(p1x-p3x) + (dp1y-dp3y)*(p1y-p3y) + (dp1z-dp3z)*(p1z-p3z)) /// = (dp1-dp3).(p1-p3) /// DotCroP12P23CroP12Dp23CroDp12P23 := Dot[Cross[p1-p2,p2-p3],(Cross[p1-p2,dp2-dp3]+Cross[dp1-dp2,p2-p3])] /// = [(p1-p2)x(p2-p3)] . [(p1-p2)x(dp2-dp3) + (dp1-dp2)x(p2-p3)] if (HDebug.Selftest()) #region selftest { Vector lp1 = new double[] { 1, 0, 0 }; Vector lp2 = new double[] { 0, 1, 0 }; Vector lp3 = new double[] { 0, 0, 1 }; Vector ldp1 = new double[] { 0.1, 0.1, 0.1 }; Vector ldp2 = new double[] { 1, 2, 3 }; Vector ldp3 = new double[] { -1, 0, -0.1 }; double r0 = Geometry.RadiusOfTriangle(lp1, lp2, lp3); double dr0 = DerivativeOfTriangleRadius(lp1, lp2, lp3, ldp1, ldp2, ldp3); List <Tuple <double, double, double, double> > drx = new List <Tuple <double, double, double, double> >(); foreach (double dt in new double[] { 0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001 }) { double t00 = -dt; double r00 = Geometry.RadiusOfTriangle(lp1 + t00 * ldp1, lp2 + t00 * ldp2, lp3 + t00 * ldp3); double t01 = +dt; double r01 = Geometry.RadiusOfTriangle(lp1 + t01 * ldp1, lp2 + t01 * ldp2, lp3 + t01 * ldp3); double dr1 = (r01 - r00) / (t01 - t00); double dr2 = (r01 * r01 - r00 * r00) / (t01 - t00); drx.Add(new Tuple <double, double, double, double>(dt, dr1, dr2, (0.5 / r0) * dr2)); } double diff = dr0 - drx.Last().Item2; HDebug.AssertTolerance(0.00000001, diff); } #endregion double P12dist2 = (p1 - p2).Dist2; double P23dist2 = (p2 - p3).Dist2; double P31dist2 = (p1 - p3).Dist2; double Dotp12dp12 = LinAlg.VtV(dp1 - dp2, p1 - p2); double Dotp23dp31 = LinAlg.VtV(dp2 - dp3, p2 - p3); double Dotp31dp31 = LinAlg.VtV(dp1 - dp3, p1 - p3); double DotCroP12P23CroP12Dp23CroDp12P23 = LinAlg.VtV(LinAlg.CrossProd(p1 - p2, p2 - p3) , LinAlg.CrossProd(p1 - p2, dp2 - dp3) + LinAlg.CrossProd(dp1 - dp2, p2 - p3) ); double Area2 = LinAlg.CrossProd(p1 - p2, p2 - p3).Dist2; double Area4 = Area2 * Area2; double Rad2 = P12dist2 * P23dist2 * P31dist2 / (4 * Area2); double Rad = Math.Sqrt(Rad2); HDebug.AssertTolerance(0.00000001, Rad - Geometry.RadiusOfTriangle(p1, p2, p3)); double t = 1; double dR_dR2 = 0.5 / Rad; double dR2_dt = ((t * Dotp31dp31) * P12dist2 * P23dist2 + (t * Dotp23dp31) * P12dist2 * P31dist2 + (t * Dotp12dp12) * P23dist2 * P31dist2) / (2 * Area2) - ((t * DotCroP12P23CroP12Dp23CroDp12P23) * P12dist2 * P23dist2 * P31dist2) / (2 * Area4); double dR_dt = dR_dR2 * dR2_dt; return(dR_dt); }