Download or view Solver.frink in plain text format
use derivatives.frink
use integrals.frink
use solvingTransformations.frink
use powerTransformations.frink
// This class solves a system of equations. It contains a graph of
// EquationNodes. Each EquationNode represents an equation in the system.
// These nodes are connected by Edges which indicate that various
// equations are interrelated by containing the same variables.
class Solver
{
// This is an array of EquationNodes that make up the graph.
var equationNodes
// This is a set of strings indicating the variables that we are not going
// to solve for.
var ignoreSet
// Boolean flag indicating if we have done phase 1 simplifications
var initialized
// The cached final solutions for each variable, keyed by variable name
var finalSolutions
// A (currently-unused) set of aliases that will simplify equations.
var aliases
// Create a new Solver.
new[eqs, ignoreList=[]] :=
{
ignoreSet = new set
equationNodes = new array
finalSolutions = new dict
for i = ignoreList
ignoreSet.put[i]
for eq = eqs
addEquation[eq]
initialized = false
}
// Add an equation to the system. This creates a new EquationNode and
// automatically connects it to all of the other EquationNodes in the
// system that share its equations.
//
// If index is undef. this will push the node onto the end of the list.
// if index is a number, this will replace the specified node.
//
// (public)
addEquation[eq, index=undef] :=
{
// THINK ABOUT: Call transformExpression to canonicalize first?
// Check for duplicate equations.
for n = equationNodes
if structureEquals[eq, n.getOriginalEquation[]]
{
println["Eliminating duplicate equation $eq"]
return
}
reducedUnknowns = setDifference[getSymbols[eq], ignoreSet]
if length[reducedUnknowns] == 0
println["WARNING: Equation $eq has no unknowns!"]
node = new EquationNode[eq, reducedUnknowns]
// If replacing, disconnect the other node
if index != undef
remove[index]
for other = equationNodes
{
// THINK ABOUT: Should we check to see if one equation is a proper
// subset of the variables of the other and push the simpler into
// the more complex right now?
// This is a set of shared variables between the two equations.
sharedVars = intersection[reducedUnknowns, other.getUnknowns[]]
for varName = sharedVars
connect[node, other, varName]
}
if index == undef
equationNodes.push[node]
else
equationNodes.insert[index, node]
// Discard any previously-found solutions
finalSolutions = new dict
initialized = false
}
// Method to initialize and simplify the system.
initialize[] :=
{
if ! initialized
{
pushSimpler[]
// draw[]
changed = solveSimultaneous[]
// draw[]
// pushAliases[]
// draw[]
if changed
pushSimpler[]
initialized = true
}
}
// Removes the specified node from the graph. This removes all connections
// to the specified node.
// (public)
remove[index] :=
{
node = equationNodes.remove[index]
disconnect[node]
initialized = false
finalSolutions = new dict // Discard any previously-found solutions.
}
// Disconnect the specified node from the graph.
// (private)
disconnect[node] :=
{
node.disconnectAllEdges[]
}
// Connect the two specified equations by the specified variable.
// (private)
connect[n1 is EquationNode, n2 is EquationNode, varName is string] :=
{
e = new Edge[n1, n2, varName]
n1.addEdge[e]
n2.addEdge[e]
}
// Return a count of the EquationNodes in the system
// (public)
getEquationCount[] := length[equationNodes]
// Returns the EquationNode with the specified index
// (public)
getEquationNode[index] := equationNodes@index
// Returns an array with each element in the array being an array
// [ unknowns, index ]
// of the equations in the system, ordered with the simplest equations
// (those with the fewest unknowns) first. Unknowns is a set.
getEquationsSortedByComplexity[] :=
{
list = new array
i = 0
last = length[equationNodes] - 1
for i = 0 to last
list.push[[equationNodes@i.getUnknowns[], i]]
sort[list, {|a,b| length[a@0] <=> length[b@0]}]
return list
}
// Returns the unknowns for the specified index.
getUnknowns[index] := equationNodes@index.getUnknowns[]
// Prints out the state of the solver for debugging.
// (public)
dump[] :=
{
last = getEquationCount[]-1
for i = 0 to last
{
node = getEquationNode[i]
print["$i\t" + node.getOriginalEquation[] + "\t"]
for e = node.getEdges[]
{
other = e.getOtherNode[node]
print["[" + e.getVariableName[] + "," + getNodeIndex[other] +"] "]
}
println[]
}
println[]
}
// Draw a representation of the system.
draw[g is graphics, left=0, top=0, right=1, bottom=2] :=
{
last = getEquationCount[]-1
width = right-left
height = bottom-top
g.font["Serif", "italic", height/30]
g.color[0,0,0]
cy = top + height/2
w = 0.7 width/20;
for i = 0 to last
{
node = getEquationNode[i]
[x,y] = getPosition[i, left, top, right, bottom]
for e = node.getEdges[]
{
oi = getNodeIndex[e.getOtherNode[node]]
if (i < oi)
{
[ox, oy] = getPosition[oi, left, top,right,bottom]
g.color[0,0,0]
g.line[x+randomFloat[-w,w],y+randomFloat[-w,w],ox+randomFloat[-w, w],oy+randomFloat[-w,w]]
}
}
g.color[.9,.9,.9]
g.fillEllipseCenter[x,y,width/10, height/2/10]
g.color[0,0,0]
g.drawEllipseCenter[x,y,width/10, height/2/10]
g.text[i,x,y,"center","center"]
g.text["$i: " + node.getOriginalEquation[], left, i * height/20 + cy, "left", "top"]
}
}
// Calculates the center of the specified node in the graph.
getPosition[index, left, top, right, bottom] :=
{
phase = circle / getEquationCount[]
width = right-left
height = bottom-top
cx = left + width/2
cy = top + height/4
radius = 1/2 (.9) width
x = radius sin[index phase] + cx
y = radius * -cos[index phase] + cy
return [x,y]
}
draw[] :=
{
g = new graphics
draw[g]
g.show[]
}
// Gets the node index given the node.
getNodeIndex[node is EquationNode] :=
{
last = length[equationNodes]
for i=0 to last
if equationNodes@i == node
return i
return "Node not found!"
}
// Keep replacing simpler variables until we're done.
pushSimpler[] :=
{
// dump[]
while pushSimplerOnce[]
{
// dump[]
}
}
// Pushes the simpler equations into the more complex
// equations. This returns true if changes were made to the system,
// false otherwise.
pushSimplerOnce[] :=
{
sortedEqs = getEquationsSortedByComplexity[]
last = length[sortedEqs]-1
for i=0 to last-1
{
[unknownsI, nodeI] = sortedEqs@i
JLOOP:
for j=i+1 to last
{
[unknownsJ, nodeJ] = sortedEqs@j
if isProperSubset[unknownsI, unknownsJ]
{
// println["Node $nodeI is a proper subset of $nodeJ"]
simpleVarList = pickSimplestVariable[nodeI, nodeJ]
for [simpleVar, count] = simpleVarList
{
sols = equationNodes@nodeI.getSolutions[simpleVar]
if length[sols] < 1
{
println["Ugh. Has " + length[sols] + " solutions in pushSimplerOnce. Maybe improve pickSimplestVariable? Solutions are: $sols, equations are " + equationNodes@nodeI.getOriginalEquation[] + ", " + equationNodes@nodeJ.getOriginalEquation[] ]
next
} else
{
origEq = equationNodes@nodeJ.getOriginalEquation[]
// println["Removing node $nodeJ"]
remove[nodeJ]
if (length[sols] > 1)
println["Warning: pushSimplerOnce split into " + length[sols] + " solutions: $sols"]
for sol = sols
{
// println["Replacing $simpleVar in $origEq with " + child[sol,1]]
newEq = replaceVar[origEq, simpleVar, child[sol,1]]
[newEq, fullyReduced] = prettify[newEq]
if !fullyReduced
newEq = transformExpression[newEq]
addEquation[newEq]
}
return true
}
}
}
}
}
return false // We made no changes.
}
// Pushes aliases like a == b or a == 2 b around the system so that
// the system is as simple and disconnected as possible.
pushAliases[] :=
{
size = length[equationNodes]
i = 0
while i<size
{
node = equationNodes@i
eq = equationNodes@i.getOriginalEquation[]
left = child[eq, 0]
lu = getSymbols[left]
lu = setDifference[lu, ignoreSet]
if length[lu] == 1
{
right = child[eq, 1]
ru = getSymbols[right]
ru = setDifference[ru, ignoreSet]
if length[ru] == 1
{
ls = array[lu]@0
rs = array[ru]@0
first = ls > rs ? ls : rs
sols = node.getSolutions[first]
if length[sols] != 1
{
println["Ugh. Has " + length[sols] + " solutions in pushAliases. Solutions are:\n" + sols]
} else
{
println["Replacing " + sols@0]
replaceAll[sols@0, i]
remove[i]
i = i - 1 // Don't increment i
size = size - 1
}
}
}
i = i + 1
}
}
// Simplifies an equation to the form a === 10 if only one variable
// remains.
// returns [equation, remainingSymbol, reduced]
// where reduced is a boolean flag indicating if the equation has been
// simplified to the form above.
prettify[eq] :=
{
reduced = false
solvedUnknowns = getSymbols[eq]
solvedUnknowns = setDifference[solvedUnknowns, ignoreSet]
remainingSymbol = undef
if length[solvedUnknowns] == 1
{
remainingSymbol = array[solvedUnknowns]@0
prettified = array[solveSingle[eq, remainingSymbol]]
if length[prettified] == 1
{
reduced = true
eq = prettified@0
} else
eq = transformExpression[eq]
}
return [eq, reduced]
}
// Picks the simplest variable shared by nodes 1 and 2. Node 1 should be
// the simpler node. Returns a string.
pickSimplestVariable[index1, index2] :=
{
node1 = equationNodes@index1
node2 = equationNodes@index2
u1 = node1.getUnknowns[]
u2 = node2.getUnknowns[]
intersection = intersection[u1, u2]
results = new array
sortedUnknowns = getSymbolsByComplexity[node1.getOriginalEquation[]]
//println["Sorted unknowns is $sortedUnknowns"]
for [unknown, count] = sortedUnknowns
if intersection.contains[unknown]
results.push[[unknown, count]]
sortedUnknowns = getSymbolsByComplexity[node2.getOriginalEquation[]]
for [unknown, count] = sortedUnknowns
if intersection.contains[unknown]
for i = 0 to length[results]-1
if results@i@0 == unknown
results@i@1 = results@i@1 + count
sort[results, {|a,b| a@1 <=> b@1}]
return results
}
// Returns true if the node at index 1 contains unknowns which are a
// proper subset of the unknowns in index 2. This means that node 1
// is a "simpler" version of equation 2, and its values should be
// substituted into equation 2.
isSimpler[index1, index2] :=
{
return isProperSubset[equationNodes@index1.getUnknowns[],
equationNodes@index2.getUnknowns[]]
}
// Eliminate simultaneous equations in the system.
// returns true if the system has been changed.
solveSimultaneous[] :=
{
changed = false
// TODO: Sort by simplest equations?
size = length[equationNodes]
for i=0 to size-2
{
JLOOP:
for j = i+1 to size-1
{
nodeI = equationNodes@i
nodeJ = equationNodes@j
ui = nodeI.getUnknowns[]
uj = nodeJ.getUnknowns[]
sharedUnknowns = intersection[ui, uj]
// println[nodeI.getOriginalEquation[]]
// println[nodeJ.getOriginalEquation[]]
// println["$i: $ui\t$j: $uj"]
// println["$i $j Shared unknowns are $sharedUnknowns"]
if length[sharedUnknowns] >= 2
{
varsToReplace = pickSimplestVariable[i, j]
// println["varsToReplace is $varsToReplace"]
for [varToReplace, count] = varsToReplace
{
skipNode = i
solution = nodeI.getSolutions[varToReplace]
if length[solution] != 1
{
// Didn't find single solution, try solving
// and replacing from the other node.
solution = nodeJ.getSolutions[varToReplace]
skipNode = j
}
if length[solution] == 1
{
replaceAll[solution@0, skipNode]
// dump[]
changed = true
break JLOOP
}
}
println["Ugh. SolveSimultaneous fell through without replacing. Equations were " + nodeI.getOriginalEquation[] + " and " + nodeJ.getOriginalEquation[]]
}
}
}
return changed
}
// Replace the specified symbol, recursively, in all equations except
// the index specified.
// (private)
replaceAll[solution, skipIndex] :=
{
size = length[equationNodes]
sym = child[solution,0]
rep = child[solution,1] // Right-hand-side of solution
// Substitute result into other equations.
for k = 0 to size-1
if k != skipIndex
{
orig = equationNodes@k.getOriginalEquation[]
subst = substituteExpression[orig, sym, rep]
// println["orig is $orig, sym is $sym, solution is $solution, rep is $rep, subst is $subst"]
if orig != subst // and length[getSymbols[subst]] <= length[getSymbols[orig]]
{
[subst, eqSolved] = prettify[subst]
subst2 = transformExpression[subst] // THINK ABOUT: Do this?
if structureEquals[_a === _b, subst2] // and structureEquals[child[subst2,0],sym] and ! expressionContains[child[subst2,1], sym]
subst = subst2
else
println["Warning: In replaceAll, did not get solution. Input was $solution, output was $subst2"]
// println["Substituted $sym to " + rep + " in $orig, result is $subst"]
addEquation[subst, k] // Replace equation.
if eqSolved
{
// println["Going to recursively replace $sym"]
replaceAll[subst, k] // Recursively replace others
}
}
}
}
// Return a set of all unknowns in the system.
getAllUnknowns[] :=
{
allUnknowns = new set
for node = equationNodes
allUnknowns = union[allUnknowns, node.getUnknowns[]]
return allUnknowns
}
// Solves for all variables in the system.
solveAll[] :=
{
allUnknowns = getAllUnknowns[]
results = new array
for u = allUnknowns
{
res = solveFor[u]
for eq = res
results.push[eq]
}
return results
}
// Solves the system for the specified variable name.
// (public)
solveFor[varName] :=
{
if !initialized
initialize[]
cached = finalSolutions@varName
if cached
return cached
results = new array
size = getEquationCount[]
for i=0 to size-1
{
if getUnknowns[i].contains[varName]
{
partialResults = solveNodeForVariable[i, varName]
for r = partialResults
results.push[r]
}
}
// Cache results.
finalSolutions@varName = results
return results
}
// Solve for the specified variable name, substituting the list of
// arguments. Args is an array of ["varname", value] pairs.
// The answer will be returned symbolically as an equation in the form
// varName === solution
// with constants and units still intact.
solveForSymbolic[varName, args] :=
{
results = new array
sols = solveFor[varName]
for sol = sols
{
for [arg, val] = args
{
sym = constructExpression["Symbol", arg]
sol = substituteExpression[sol, sym, val]
}
// THINK ABOUT: Transform expression here to simplify?
// res = transformExpression[res]
results.push[eval[sol]]
}
return eliminateOverconstrained[results, false, false]
}
// Solve for the specified variable name, substituting the list of
// arguments. The result is a list of evaluated solutions.
solveFor[varName, args] :=
{
sols = solveForSymbolic[varName, args]
results = new array
for sol = sols
{
right = child[sol,1]
final = eval[right]
exists = false
CHECKDUPLICATES:
for r = results
if (final conforms r) and (final == r)
{
exists = true
break CHECKDUPLICATES
}
if ! exists
results.push[final]
}
return results
}
// Recursive method to find the solutions for the specified variable
// starting from the specified node. This recursively enumerates all
// of the permutations of substitutions in the system.
// This method just sets up parameters for the recursive call.
// (Private method)
solveNodeForVariable[index, varName, cachedSolutions = undef] :=
{
if cachedSolutions == undef
cachedSolutions = new dict
node = getEquationNode[index]
sols = node.getSolutions[varName]
// println["Solutions for $varName are $sols"]
results = solveNodeForVariable[node, varName, sols, new set, cachedSolutions]
results = transformExpression[results]
// return results
return eliminateOverconstrained[results, true, false]
}
// The recursive (private) call to solve for the particular variable.
solveNodeForVariable[node, varName, inEqs, usedEdges, cachedSolutions] :=
{
// print["Solving for $varName in " + getNodeIndex[node] + ", {"]
// for e = usedEdges
// print[e.getVariableName[] + " "]
// println["}"]
// Return partial solution from cache if possible.
if cachedSolutions.containsKey[node]
{
varDict = cachedSolutions@node
if varDict.containsKey[varName]
{
edgeDict = varDict@varName
if edgeDict.containsKey[usedEdges]
return edgeDict@usedEdges
}
}
results = inEqs.shallowCopy[]
edges = setDifference[node.getEdges[], usedEdges]
for e = edges
if e.getVariableName[] == varName
edges.remove[e]
len = length[edges]
if (len == 0) // No more replacements to do.
{
putCache[cachedSolutions, node, varName, usedEdges, results]
return results
}
// Set up states array to enumerate through permutations.
states = new array
for i=0 to len-2
states@i = false
states@(len-1) = true // Skip all-false state (no replacements)
i = len-1
edgeArray = array[edges]
//newUsedEdges = union[node.getEdges[], usedEdges]
while i >= 0
{
newUsedEdges = usedEdges.shallowCopy[]
for j = 0 to len-1
if states@j
newUsedEdges.put[edgeArray@j]
// Perform replacements on each edge
EDGELOOP:
for j = 0 to len-1
{
edge = edgeArray@j
// newUsedEdges.put[edge] // Mark this edge as used.
replacingVar = edge.getVariableName[]
if states@j
{
replacingSymbol = edge.getSymbol[]
otherNode = edge.getOtherNode[node]
// newGlobalUsedNodes.put[newUsedNodesHere]
// Recursively solve the other node for the variable
// represented by this edge.
repList = solveNodeForVariable[otherNode,
replacingVar,
otherNode.getSolutions[replacingVar],
newUsedEdges,
cachedSolutions ]
// println["repList is $repList"]
for repWithFull = repList
{
repWith = child[repWithFull, 1] // Get right-hand-side
for eq = inEqs
{
res = substituteExpression[eq, replacingSymbol, repWith]
// println["Replacing $replacingVar with $repWith in $eq, result is $res"]
// Check to see if the variable we're solving for occurs on the right
rightSyms = getSymbols[child[res,1]]
if rightSyms.contains[varName]
{
//println["WARNING: Right side contains $varName in $res"]
res2 = solveSingle[res, varName]
//println["Re-solving: $res2"]
// TODO: This may return a whole lot of solutions.
// We need to evaluate each one and push them all
// onto the solutions list.
varSymbol = constructExpression["Symbol", varName]
for subR = array[res2]
if structureEquals[_a === _b, subR] and structureEquals[child[subR,0],varSymbol] and ! expressionContains[child[subR,1], varSymbol]
{
//println["Re-solving successful."]
results.push[subR]
} else
{
// println["WARNING: Right side contains $varName in $res"]
println["Re-solving FAILED: $res2"]
// println["Re-solving FAILED."]
}
} else
{
// res = transformExpression[res]
results.push[res]
}
}
}
}
}
// Advance to next binary state
flipped = false
i = len-1
while i>=0 and !flipped
{
// Enter next state
if states@i == false
{
states@i = true
flipped = true
} else
{ // Carry
states@i = false
i = i - 1
}
}
// i now contains the last index flipped. If i < 0, we're done
}
results = eliminateOverconstrained[results, true, false]
putCache[cachedSolutions, node, varName, usedEdges, results]
return results
}
// This function eliminates overconstrained equations. For example, a
// system containing the solutions a===1/2 c r and a===c d^-1 r^2 is
// overconstrained because a value can always be obtained with the first
// equation. The second is not necessary, and could lead to
// inconsistent results. This method ignores any symbols listed in the
// ignoreSymbols list, (these are probably units,) eliminating them from
// the equations.
eliminateOverconstrained[eqArray, dupsOnly, debug=false] :=
{
size = length[eqArray]
unknowns = new array
lefts = new array
for i = 0 to size-1
{
lefts@i = child[eqArray@i, 0]
unknowns@i = setDifference[getSymbols[child[eqArray@i,1]], ignoreSet]
}
res = new array
// Check for duplicates.
for i=0 to size-1
{
remove = false
j = 0
do
{
if i != j and structureEquals[lefts@i, lefts@j]
{
remove = (i<j and structureEquals[eqArray@i, eqArray@j]) or ((! dupsOnly) and isProperSubset[unknowns@j, unknowns@i])
if remove
if debug
println[eqArray@j + " is a proper subset or match of " + eqArray@i]
}
j=j+1
} while (j < size) and ! remove
if (! remove)
res.push[eqArray@i] // If we got here, no j is a proper subset of i.
}
return res
}
// Puts the specified values into the cache.
class putCache[cachedSolutions, node, varName, usedEdges, vals] :=
{
if ! cachedSolutions.containsKey[node]
{
nodeDict = new dict
cachedSolutions@node = nodeDict
} else
nodeDict = cachedSolutions@node
if ! nodeDict.containsKey[varName]
{
varDict = new dict
nodeDict@varName = varDict
} else
varDict = nodeDict@varName
varDict@usedEdges = vals
}
// This is an experimental function that uses Frink's multi-input capability
// to interactively plug numbers into a solution.
interact[] :=
{
allUnknowns = sort[array[getAllUnknowns[]]]
opts = new array
for u = allUnknowns
{
sols = solveFor[u]
println["$u:\t$sols"]
if length[sols] != 1
opts.push[u]
}
vals = input["Enter values: ", opts]
}
}
// This is a node in the graph that represents an equation. It stores various
// information about the variables stored in the equation and its solutions
// for those variables. Users will not create these directly, but rather
// call methods on the System class to create these nodes and connect them
// properly.
class EquationNode
{
// The original equation
var origEq
// A set of unknowns in the equation.
var unknowns
// An set of edges that connect this node to other nodes.
var edges
// This is a dictionary whose key is the variable name (as a string)
// and the value is an object of type SolutionPart.
// If this is undef, it means that the equation has not
var solvedDict
// Create a new equation. The equation should contain a === expression.
// The set reducedUnknowns is the unknowns with the ignoreSet removed.
new[eq, reducedUnknowns is set] :=
{
origEq = eq
unknowns = reducedUnknowns
edges = new set
solvedDict = new dict
}
// Add a new edge that connects to another node
addEdge[e is Edge] :=
{
edges.put[e]
}
// Returns the primary equation for this node.
getOriginalEquation[] := origEq
// Return the set of unknowns in this equation.
getUnknowns[] := unknowns
// Disconnect any edges that connect this node to other nodes.
disconnectAllEdges[] :=
{
for e = edges
{
other = e.getOtherNode[this]
other.removeEdgesTo[this]
}
edges = new set
}
// Remove any edges that connect to the specified EquationNode.
// This NOT recursive and should only be called from disconnectAllEdges
// (private method)
removeEdgesTo[node is EquationNode] :=
{
for e = edges
if e.connectsTo[node]
edges.remove[e]
}
// Returns a set of all Edge objects.
getEdges[] := edges
// Gets the solutions to this equation for the specified variable.
// This will fetch the value from the cache if it exists, otherwise it
// will solve for it.
getSolutions[varName] :=
{
if ! solvedDict.containsKey[varName]
{
solution = solveSingle[origEq, varName]
addSolutions[varName, solution]
}
return solvedDict@varName.solutions
}
// Add one or more solutions for the specified variable to a node.
// The equation may be a single equation or a list of equations.
// This checks to ensure that the equations are properly solved for the
// variable.
addSolutions[varName, equation] :=
{
if solvedDict.containsKey[varName]
sp = solvedDict@varName
else
{
sp = new SolutionPart[varName]
solvedDict@varName = sp
}
sym = sp.symbol
for eq = flatten[array[equation]]
{
// Make sure that the solution was properly solved for the variable.
// this ensures that the equation is of the form var == solution
// where solution does not contain the variable.
if structureEquals[_a === _b, eq] and structureEquals[child[eq,0],sym] and ! expressionContains[child[eq,1], sym]
sp.addSolution[eq]
else
println["Could not solve $origEq for $varName! Solution was $eq"]
}
}
}
// This represents an edge between two EquationNodes in a graph. It
// contains a variable name which defines the variable that connects the
// two nodes. Users will not create these directly, but rather
// call methods on the System class to create these nodes and connect them
// properly.
class Edge
{
// A string containing the name of the variable that connects the two
// EquationNodes
var varName
// A symbol representing the symbol.
var varSymbol
// One of the EquationNodes that this connects.
var node1
// The other one of the EquationNodes that this connects.
var node2
// Create a new Edge that connects the specified EquationNodes.
new[n1 is EquationNode, n2 is EquationNode, name is string] :=
{
node1 = n1
node2 = n2
varName = name
varSymbol = constructExpression["Symbol", name]
}
// Returns a string containing the variable name which indicates the
// variable name that connects the two Nodes by this edge
getVariableName[] := varName
// Returns a symbol representing the variable.
getSymbol[] := varSymbol
// Returns the other node of this edge.
getOtherNode[oneNode is EquationNode] :=
{
if oneNode == node1
return node2
else
if oneNode == node2
return node1
else
{
println["getOtherNode: Matching node not found!"]
return undef
}
}
// Returns true if this Edge connects to the specified node.
connectsTo[node is EquationNode] :=
{
return node == node1 or node == node2
}
}
// This is a helper class that contains the solutions for a particular
// variable.
class SolutionPart
{
var symbol // The variable stored as a symbol.
var solutions // An array of solutions in the form
// a === b + c
// Construct a new SolutionPart given the string that represents the
// variable.
new[symbolString] :=
{
symbol = constructExpression["Symbol", symbolString]
solutions = new array
}
// Adds a solution to the list. This does not do any checking; that is
// performed by EquationNode.addSolution.
addSolution[eq] :=
{
solutions.push[eq]
}
}
// Solve a single equation for the specified symbol.
// TODO: Verify that the equation was solved appropriately?
solveSingle[eq, symbol] :=
{
xSymbol = constructExpression["Symbol", symbol]
// We could use this in symbolic mode, otherwise it warns.
// solveEq = solve[eq, xSymbol]
solveEq = constructExpression["FunctionCall", ["solve", eq, xSymbol]]
return transformExpression[solveEq]
}
// Replace a variable in the specified equation with the specified value.
// You should probably wrap the "eq" and "value" in a noEval[] block if
// you're not passing them in from a variable.
replaceVar[eq, varName, value] :=
{
sym = constructExpression["Symbol", varName]
res = substituteExpression[eq, sym, value]
// THINK ABOUT: Transform expression here to simplify?
// res = transformExpression[res]
return res
}
Download or view Solver.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 20217 days, 16 hours, 1 minutes ago.