ultimately want to discover n roots programatically
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import fsolve
In this small equation, x should correctly equal 5.
f(x) is a coded representation of the written problem.
f(x) takes a possible numeric solution as its only argument.
if f(x) ever returns 2, then the guess is correct.
f = lambda x: -3 + x
First, I will solve for x with brute force guessing by passing various guesses into f(x) in form of array.
xGuesses = np.array([1,2,3,4,5,6,7,8,9,10])
print("func results:", f(xGuesses))
Array output may shows the sequence of answers with respect to the input order
this will become the y position on the plot
plt.plot(xGuesses, f(xGuesses))
plt.plot(5, 2, 'o')
plt.xlabel("guess")
plt.ylabel("func return")
plt.grid()
plt.show()
The grid shows that 5 intersects with 2. Since our desired output is 2, 5 is my answer.
Another way to discover a solution is to use scipy numerical solver to find the roots
Instead of visually hunting for the answer in a grid, one can simply be given a solution in plain text.
As far as I know, scipy.fsolve thinks that when a function returns "zero", then that is the correct solution Therefore, I must modify the equation to equal zero instead of 2.
f = lambda x: -3 + x -2
initial_guess = 1
solution = fsolve(f, initial_guess)
print ("The solution is x = %f" % solution)
This is very similar to the homebrew brute force, except the scipy lib has some optimizations that are helpful.
im not very good at this yet
so I was unable to figure out how to graph this problem in an intelligible way. I did figure out how to create a matrix with all possible combinations which allowed me to use the same f(numpy.array) strategy. I thought that the matrix should be called a permutation matrix, however, there already seems to be some advanced terminology that uses the same word for a different meaning. I recall it saying "permute this matrix". I am still unsure what this means.
I am going to convert the equation to equal zero, so that i can use uniform solutions across differing equations
$$ A = 2y−3x+27 = 0 $$$$ B = 5y+3x-6 = 0 $$f = lambda x, y: (2*y) - (3*x) + 27
g = lambda x, y: (5*y) + (3*x) - 6
possibleRange = list(range(-5, 10))
# n^r (permutations)
guessMatrix = np.array([np.repeat(possibleRange, len(possibleRange)),
np.tile(possibleRange, len(possibleRange))])
def findAnswers (f, matrix):
matches = [i for i, x in enumerate(f(*matrix).tolist()) if x == 0]
answers = []
for i in matches:
answers.append(str([matrix[0][i], matrix[1][i]]))
return answers
A = findAnswers(f, guessMatrix)
B = findAnswers(g, guessMatrix)
print(A); print(B)
print(set(A).intersection(B))
python's set class object is very useful for finding differences in collections. I had to serialize the return results so that the set.intersection comparison could be made. Fortunately for me, the set.intersection also returns all points, unlike the list.index
A matrix solution I found that did not work as expected was:
guessMatrix = np.array(np.meshgrid([1, 2, 3], [4, 5], [6, 7])).T.reshape(-1,3))
[1, 4, 6]
[1, 5, 6]
[2, 4, 6]
[2, 5, 6]
[3, 4, 6]
[3, 5, 6]
[1, 4, 7]
[1, 5, 7]
[2, 4, 7]
[2, 5, 7]
[3, 4, 7]
[3, 5, 7]
The np.array(np.meshgrid([-5...10], [-5...10])).T.reshape(-1,2))
created the correct number of matches as:
[1, 4]
[1, 5]
[2, 4]
[2, 5]
[3, 4]
[3, 5]
but since I needed the array to be in pivoted form of:
[1,1,2,2,3,3]
[4,5,4,5,4,5]
I attempted to pivot the array using reshape(2,-1)
with unexpected results:
[1, 4, 1, 5, 2, 4]
[2, 5, 3, 4, 3, 5]
The was expecting a perfect pivot:
[1, 1, 2, 2, 3, 3]
[4, 5, 4, 5, 4, 5]
Even though there may be a way to use these methods to achieve what i am looking for, ultimately it became unreadable and i lost my way.
Brent suggested looking up matrix transformations