systemSolverTest.frink

View or download systemSolverTest.frink in plain text format


// Demonstration and test of solving systems of equations.

use systemSolver2.frink
symbolicMode[true]

// Ellipse equations.
ellipse = new System[[x^2/a^2 + y^2/b^2 === 1,
                      e === sqrt[(a^2-b^2)/a^2],
                      area===pi a b],
                     ["pi"]]
println["Ellipse:"]
println[join["\n",ellipse.solveAll[]]]
println[]


println["System of equations with 2 unknowns:"]
simult = new System[[x*y===8,
                     x+y===4]]
println[join["\n",simult.solveAll[]]]
println[]


println["System of equations with 4 unknowns:"]
simult2 = new System[[3a - 2b + c === 3,
                      4a + b - 3c === 10,
                      a + 6b - 2c === 5,
                      d === 4c - 10 + 2b]]
println[join["\n",simult2.solveAll[]]]
println[]


// Rump equation
println["Rump equation:"]
rump = new System[[z === ((333 + 3/4) - x^2) y^6 + x^2 (11x^2 y^2 - 121 y^4 - 2) + (5 + 1/2) y^8 + x/(2y), x===77617, y===33096]]
println[join["\n",rump.solveAll[]]]
println[]

// Cohen, p. 11
/*cc = new System[[d0+d1+d2+d3+d4 === 1,
                 d1+2d2+3d3+4d4 === 2(1-m),
                 3d0-d2+3d4     === 2g20 + g11,
                 theta d0 + phi d1 - phi d3 - theta d4 === m,
                 2 theta d0 + phi d1 + phi d3 + 2 theta d4 === 2 g10],
                 ["g20", "g11", "theta", "phi", "g10", "m"], true]
println[join["\n",cc.solveAll[true]]]
println[] */



// Expansion of the universe
// TODO:  Don't have solvers for exponential functions yet.
println["Expansion of the universe:"]
u = new System[[D0 hubbleconstant^2 e^(hubbleconstant t) === G m / d^2, d === D0,  D0 === 4.3 ly], ["D0", "hubbleconstant", "ly", "G"]]
println[join["\n",u.solveFor["t"]]]
println[]


// Circle
println["Circle:"]
circle = new System[[d === 2 r, c === pi d, a === pi r^2, e===f, g===h], ["pi"]]
println[join["\n",circle.solveAll[]]]
println[]


// See http://answers.yahoo.com/question/index?qid=20091120001614AAInec3
// TODO:
//   eliminate pAprime and pAB, as those are what we want to solve for.
println["Bayes equation:"]
bayes = new System[[pAB === pBA pA / pB,
                    pA === 1 - pAprime,
                    pAB === ( pBA pA ) / ( pBA pA + pBAprime pAprime )],
                   []]
println[join["\n", bayes.solveAll[]]]
println[]


// Cylinder.  See http://ask.metafilter.com/59183/Calculate-length-of-a-pipe-from-the-volume-it-holds
// Basically, we want the solution for "L" given "d" and "v".
println["Cylinder:"]
cyl = new System[[d === 2 r, c === pi d, a === pi r ^2, v === a L], ["pi"]]
println[join["\n", cyl.solveAll[]]]
sols = cyl.solveFor["L"]
println["Solutions for L:\n" + join["\n", sols]]


// Plug in values and solve.
args = [["d", 3/4 inch], ["v", 27 gallons]]
nsols = cyl.solveForValues["L", args]
println["Solutions for L (fully specified, symbolic):\n" + (nsols->"ft")]
println["Solutions for L (evaluated):\n" + (eval[nsols]->"ft")]
println[]

// Not fully specified case.
args = [["d", 3/4 inch]]
nsols = cyl.solveForValues["L", args, false]
println["Solutions for L (not fully specified):\n" + join["\n",nsols]]
println[]

// Phi
println["The golden ratio Phi:"]
phi = new System[[x+1===1/x]]
sols = phi.solveAll[]
println[join["\n", sols]]
println[]


// Test of parsing user-generated systems of equations.  This will generally
// fail with eval because of security constraints on creating objects.
// Thus we're using unsafeEval.  Hopefully in the future this can be done in
// such a way that we can solve user-submitted systems of equations.  Or we
// may just have to do that in an applet or in the Frink UI.  Burn your CPU
// cycles, not mine!
println["User-submitted system:"]
s = unsafeEval["new System[[density === 3.5 oz / (170 yards),v === density], []]"]
println[join["\n", s.solveFor["v"]]]
println[]


// Shweeb collision
println["Shweeb collision"]
phi = new System[[v === a t,
                  d === 1/2 a t^2,
                  E === 1/2 m v^2,
                  E === m gravity h],
                 ["gravity"]]
println[join["\n", phi.solveAll[]]]
args = [["d", 1.2 m], ["v", 30 km/hr], ["gravity", gee]]
println["Acceleration: " + (eval[phi.solveForValues["a", args]]->"gee")]
println["Height: " + (eval[phi.solveForValues["h", args]]->"ft")]
println["Collision time:" + eval[phi.solveForValues["t", args]]]
println[]


// Physical system // Suppose the stone is thrown at an angle of 35.0° below
// the horizontal from the same building (h = 50.0 m) as in the example above.
// If it strikes the ground 60.8 m away, find the following. (Hint: For part
// (a), use the equation for the x-displacement to eliminate v0t from the
// equation for the y-displacement.)
// (a) the time of flight
// (b) the initial speed
// (c) the speed and angle of the velocity vector with respect to the
//    horizontal
println["Ballistics problem:"]
phys = new System[[vx === v0 cos[35 degrees],
                   vy0 === v0 sin[35 degrees],
                   h === h0 - 1/2 g t^2 - vy0 t,
                   x === vx t],
                  ["g", "degrees"]]
println[join["\n", phys.solveAll[]]]
args = [["x", 60.8 m], ["h0", 50 m], ["g", gravity], ["h", 0 m]]
println[join["\n", eval[phys.solveForValues["v0", args]]]]
println[]

// Jupiter gravity
println["Jupiter gravity"]
jup = new System[[ E === m g h,
                   E === 1/2 m v^2],
                  ["g"]]
println[join["\n", jup.solveAll[]]]
println[]


// Lorentz equation
println["Lorentz equation:"]
lorentz = new System[[ gamma === 1/sqrt[1-v^2/c^2],
                       dprime === d / gamma ],
                       ["c"]]
println[join["\n", lorentz.solveAll[]]]

// Solve for when a distance of 5 km is compressed into 1 m
args=[["d", 5 km], ["dprime", 1 m]]
sols = lorentz.solveForValues["v", args]
println[join["\n", sols]]
println["Evaluated: " + eval[sols]]
println[]


// Photon travel from quantum electrodynamic calculations
println["Photon equations:"]
light = new System[[ f === c / lambda,
                     omega === 2 pi f,
                     f === 1/T,
                     d === v t,
                     v === c,
                     phase === omega t],
                     ["c", "pi"]]
println[join["\n", light.solveAll[false]]]
println[]


// Deep fryer.  How much oil do I need to buy to fill a cylinder to the
// specified height?
println["Deep fryer:"]
fryer = new System[[ a === pi r^2,
                     v === a h,
                     d === 2 r ],
                   ["pi"]]
println[join["\n", fryer.solveAll[]]]
args = [["d", 10.5 in], ["h", 7.5 in]]
println[eval[fryer.solveForValues["v",args]] -> "gallons"]
println[]


View or download systemSolverTest.frink in plain text format


This is a program written in the programming language Frink.
For more information, view the Frink Documentation or see More Sample Frink Programs.

Alan Eliasen was born 17983 days, 19 hours, 17 minutes ago.