Develop Reference

SciPy Optimise minimise error - challenge to solve

How do I solve this error?
TypeError: NumPy boolean subtract, the `-` operator, is not supported, use the bitwise_xor, the `^` operator, or the logical_xor function instead.
I have programmed an optimizing program that must minimize the cost of a wall design. The wall is based on 3 parameters, x, k and m. There are constraints to the sizes of x, k and m as shown. Another constraint is that z (or deflection) must be kept under 100mm. The equation for deflection changes based on a certain t (or time) at which the blast wall is experiencing the blast. If t is below a certain time value which is calculated dependent on, x, k and m the equation is as shown. If t is above the same certain time value, the equation for z changes.
Here is the programming... Please help many thanks :)
import numpy as np
from numpy import linspace
from math import cos
from math import sin
from scipy.optimize import minimize
#Function for minimising
def calcCost(c):
k = c[0]
m = c[1]
x = c[2]
Cost = (900 + 825*k**2 - 1725) + (10*m - 200) + ((2400*x**2)/4)
return Cost
#Objective function
def objective(c):
return calcCost(c)
#Defining Variables
def calck(c):
k = c[0]
k=k
k.resize(12,)
return k
def calcm(c):
m = c[1]
m=m
m.resize(12,)
return m
def calcx(c):
x = c[2]
x=x
x.resize(12,)
return x
def calcz(c):
k = c[0]
x = c[1]
m = c[2]
l = linspace(0,140,141)
for t in l:
if t <= ((20 - 0.12*x**2 + 4.2*x)/1000):
deflection = ((((1000+9*x**2-183*x)*1000)/k)*(1-cos(t*((k/m)**0.5))) + (((1000+9*x**2-183*x)*1000)/k*((20 - 0.12*x**2 + 4.2*x)/1000))*((sin(t*((k/m)**0.5))/((k/m)**0.5))-t))*1000
else:
deflection = ((((1000+9*x**2-183*x)*1000)/(k*((k/m)**0.5)*((20 - 0.12*x**2 + 4.2*x)/1000)))*(sin(((k/m)**0.5)*t))-(sin(((k/m)**0.5)*(t-((20 - 0.12*x**2 + 4.2*x)/1000))))-(((1000+9*x**2-183*x)*1000)/k)*cos(((k/m)**0.5)*t))*1000
deflection.resize(12,)
return deflection
#Constraint functions
def kconstraint1(c):
k = c[0]
return k-(1*10**6) >= 0
def kconstraint2(c):
k = c[0]
return k-(7*10**6) <= 0
def mconstraint1(c):
m = c[0]
return m-200 >= 0
def mconstraint2(c):
m = c[0]
return m-1200 <= 0
def xconstraint1(c):
x = c[0]
return x >= 0
def xconstraint2(c):
x = c[0]
return x <= 10
def zconstraint1(c):
k = c[0]
x = c[1]
m = c[2]
l = linspace(0,140,141)
for t in l:
if t <= ((20 - 0.12*x**2 + 4.2*x)/1000):
deflection = ((((1000+9*x**2-183*x)*1000)/k)*(1-cos(t*((k/m)**0.5))) + (((1000+9*x**2-183*x)*1000)/k*((20 - 0.12*x**2 + 4.2*x)/1000))*((sin(t*((k/m)**0.5))/((k/m)**0.5))-t))*1000
else:
deflection = ((((1000+9*x**2-183*x)*1000)/(k*((k/m)**0.5)*((20 - 0.12*x**2 + 4.2*x)/1000)))*(sin(((k/m)**0.5)*t))-(sin(((k/m)**0.5)*(t-((20 - 0.12*x**2 + 4.2*x)/1000))))-(((1000+9*x**2-183*x)*1000)/k)*cos(((k/m)**0.5)*t))*1000
return deflection <= 99.99999999
b = (0.5,1)
be = (0.5,10)
bb = (0.1,2.0)
bnds = (b,be,bb,bb)
con1 = ({'type':'ineq','fun':kconstraint1})
con2 = ({'type':'ineq','fun':kconstraint2})
con3 = ({'type':'ineq','fun':mconstraint1})
con4 = ({'type':'ineq','fun':mconstraint2})
con5 = ({'type':'ineq','fun':xconstraint1})
con6 = ({'type':'ineq','fun':xconstraint2})
con7 = ({'type':'ineq','fun':zconstraint1})
cons = [con1,con2,con3,con4,con5,con6,con7]
xGUESS = 5
kGUESS = 3*10**6
mGUESS = 700
zGUESS = 90
x0 = np.array([xGUESS,kGUESS,mGUESS,zGUESS])
sol = minimize(objective,x0,method='SLSQP',bounds=bnds,constraints=cons,options={'disp':True})
xOpt = sol.x
CostOPT = sol.fun
kOPT = calck(xOpt)
xOPT = calcx(xOpt)
mOPT = calcm(xOpt)
zOPT = calcz(xOpt)
print(str(CostOPT))
print(str(calcx))
print(str(calcm))
print(str(calck))
print(str(calcz))

Rabin-Karp 2D pattern search runs slower than brute force

I have implemented the Rabin-Karp 2D algorithm for pattern searching in python. However, my implementation is slower than the brute force version over a 1000x2000 matrix. Please help me identify the bottle neck. Thanks, and I appreciate your comments.
Note 1: the code is right in finding the position where the pattern matches but runs slower, 1.23s v.s. 0.54s for brute force version on my computer.
Note 2: although one can come up with the worst-case such that Rabin-Karp could be as slow as brute force, the test case given is not designed on purpose to make it O(m(n-m+1)).
Disclaimer : Although this problem is an assignment problem in Algorithms, 4th Edition by Sedgewick and Wayne, it is not my homework. I am learning this algorithm.
Here is the code:
'''
Searches for a 2D pattern in a 2D text. Assumes that both the pattern and the
text are rectangles of characters.
O(Mr * Nr * Nc), where Mr is the pattern row length, Nr is the text row length
and Nc is the text column length
'''
MOD = 10**9+7
class RabinKarp2DV3(object):
def __init__(self, rad, pattern):
#Radix of the alphabet. Assumes ASCII characters
self.RADIX = rad
self.pattern = pattern
self.height = len(pattern)
self.width = len(pattern[0])
self.factors_col = [0]*(self.height)
self.factors_row = [0]*(self.width)
self.factors_col[0] = 1
for i in range(1, len(self.factors_col)):
self.factors_col[i] = (self.RADIX * self.factors_col[i - 1]) % MOD
self.factors_row[0] = 1
for i in range(1, len(self.factors_row)):
self.factors_row[i] = (self.RADIX * self.factors_row[i - 1]) % MOD
hash1d_p = [0]*self.width
self.hash2D(self.pattern, hash1d_p, self.width)
self.patternHash = self.SingleHash(hash1d_p)
def hash2D(self, data, hash1d, hei):
for i in range(hei):
hash1d[i] = 0
for j in range(self.height):
hash1d[i] = (self.RADIX * hash1d[i] + ord(data[j][i])) % MOD
def rehash2D(self, data, hash1d, hei, j):
for i in range(hei):
hash1d[i] = self.RADIX*((hash1d[i] + MOD - self.factors_col[self.height-1]
* ord(data[j][i])%MOD) % MOD) % MOD
hash1d[i] = (hash1d[i] + ord(data[j+self.height][i])) % MOD
def SingleHash(self, hash1d):
res = 0
for i in range(self.width):
res = (self.RADIX * res + hash1d[i]) % MOD
return res
def SingleReHash(self, hash, hash1d, pos):
hash = self.RADIX*((hash + MOD - self.factors_row[self.width-1]*hash1d[pos]%MOD) % MOD) % MOD
hash = (hash + hash1d[pos+self.width]) % MOD
return hash
def check(self, text, i, j):
x, y = i, j
for a in range(self.height):
for b in range(self.width):
if text[x][y] != self.pattern[a][b]:
return False
y += 1
x += 1
y = j
return True
def search(self, text):
hash1d = [0]*len(text[0])
for i in range(len(text)-self.height+1):
if i == 0:
self.hash2D(text, hash1d, len(text[0]))
else:
self.rehash2D(text, hash1d, len(text[0]), i-1)
textHash = 0
for j in range(len(text[0]) - self.width+1):
if j == 0:
textHash = self.SingleHash(hash1d)
else:
textHash = self.SingleReHash(textHash, hash1d, j-1)
#print(i, j, textHash, patternHash)
if textHash == self.patternHash and self.check(text, i, j):
return [i, j]
return None
class BruteForce(object):
def __init__(self, pattern):
self.pattern = pattern
self.height = len(pattern)
self.width = len(pattern[0])
def check(self, text, i, j):
x, y = i, j
for a in range(self.height):
for b in range(self.width):
if text[x][y] != self.pattern[a][b]:
return False
y += 1
x += 1
y = j
return True
def search(self, text):
for i in range(len(text)-self.height+1):
for j in range(len(text[0]) - self.width+1):
if self.check(text, i, j):
return [i, j]
return None
if __name__ == "__main__":
import random
import string
import time
chars = string.ascii_uppercase
im, jm = 1000, 2000
text = []
for i in range(im):
s = ''
for j in range(jm):
s += random.choice(chars)
text.append(s)
pattern = []
for i in range(20):
pattern.append(text[357+i][478:478+40])
start_time = time.time()
matcher = RabinKarp2DV3(256, pattern)
print(matcher.search(text))
print("--- %s seconds ---" % (time.time() - start_time))
start_time = time.time()
matcher = BruteForce(pattern)
print(matcher.search(text))
print("--- %s seconds ---" % (time.time() - start_time))

TypeError: int object is not iterable when trying to use a list of prime numbers

So I have been writing a function to generate a key as a tuple using randomly generated prime numbers, and when I try to run the code it generates the error(s),
PS C:\Users\cinna\workspace\project4> py rsa.py S
Traceback (most recent call last):
File "C:\Users\cinna\workspace\project4\rsa.py", line 104, in <module>
_main()
File "C:\Users\cinna\workspace\project4\rsa.py", line 91, in _main
n, e, d = keygen(25, 100)
File "C:\Users\cinna\workspace\project4\rsa.py", line 10, in keygen
primes = _primes(lo, hi)
File "C:\Users\cinna\workspace\project4\rsa.py", line 69, in _primes
primes += p
TypeError: 'int' object is not iterable
Edit: Here is my code for keygen(), _primes() and main(). Thanks for the patience, still learning StackOverflow etiquette.
def keygen(lo, hi):
primes = _primes(lo, hi)
for i in range(lo, hi):
if _primes(i):
ptemp = stdrandom.uniformInt(0, len(primes))
qtemp = stdrandom.uniformInt(0, len(primes))
p = primes[ptemp]
q = primes[qtemp]
n = p * q
m = (p - 1) * (q - 1)
while True:
e = stdrandom.uniformInt(2, m)
if e % m == 0 and m % e != 0:
break
d = 0
for a in range(1, m):
if (e * a) % m == 1:
d = a
break
return n, e, d
def _primes(lo, hi):
primes = []
for p in range(lo, hi + 1):
j = 2
f = 1
while(j * j <= p):
if(p % j == 0):
f = 0
break
j = j + 1
if(f == 1):
primes += p
return primes
def _main():
x = ord(sys.argv[1])
n, e, d = keygen(25, 100)
encrypted = encrypt(x, n, e)
stdio.writef('encrypt(%c) = %d\n', x, encrypted)
decrypted = decrypt(encrypted, n, d)
stdio.writef('decrypt(%d) = %c\n', encrypted, decrypted)
width = bitLength(x)
stdio.writef('bitLength(%d) = %d\n', x, width)
xBinary = dec2bin(x, width)
stdio.writef('dec2bin(%d) = %s\n', x, xBinary)
stdio.writef('bin2dec(%s) = %d\n', xBinary, bin2dec(xBinary))
if __name__ == '__main__':
_main()

The problem is this expression:primes += p
You can use that operator, but it works like this:
[1,2,3,4] = [1,2,3,4] + x
Now x has to be a list so that this expression works. It just concatenates to lists together.

You are trying to append an int to a list, which is illegal. You can append a list to a list. Try doing primes += [p] or primes.append(p).

Python Linear Diophantine Equation

I am doing the homework for class and I was doing some research. I found the example equation for finding the diophantine equation.
The assignment is given when there is gcd(a, b) == 1, then there is a diophantine equation where
ax + by = 1.
I understood how this equation finds the value for x and y but I am not sure how this function is working. I got the part where there is divmod and recursive method inside the function, but I do not know when does it stop.
sorry for complex and ambiguous questions, but I wanna know how this equation works. I mean, how this equation ends.
For example, when there is given number 43 and 486 then gcd(43, 486) == 1.
That mean there's a equation where 43x + 486y = 1. the solution said 43(-113) + 486(10) = 1. And the function solve got the x and y value as well.
I was trying to follow through the code and see how it process, but I do not understand else: part.
def isolve(a, b):
quotient, remainder = divmod(a, b)
if remainder == 0:
return [0, 1 / b]
else:
sol = isolve(b, remainder)
x = sol[0]
y = sol[1]
return [y, x - quotient * y]

I am not sure I understand exactly what you are after, but let's consider the following modified code:
def simple_linear_diophantine_r(a, b):
q, r = divmod(a, b)
if r == 0:
return (0, b)
else:
x, y = simple_linear_diophantine_r(b, r)
return (y, x - q * y)
a, b = 43, 486
x, y = simple_linear_diophantine_r(a, b)
print(f'({a}) * ({x}) + ({b}) * ({y}) == {a * x + b * y}')
# (43) * (-113) + (486) * (10) == 1
which works as expected. Compared to the original code, I have rewritten the math in a way that only int-safe operations are used (no float division is used).
Additionally, I have renamed the function itself and some of the internal variables.
So far, this is more or less what you knew already.
Now, one way to understand what is happening is to use a Python's debugger.
A simpler to illustrate approach is to place some print() calls in strategic places:
def simple_linear_diophantine_r(a, b):
q, r = divmod(a, b)
print(f'a={a}, b={b}, q={q}, r={r}') # DEBUG
if r == 0:
return (0, b)
else:
x, y = simple_linear_diophantine_r(b, r)
print(f'x={x}, y={y}') # DEBUG
return (y, x - q * y)
a, b = 43, 486
x, y = simple_linear_diophantine_r(a, b)
print(f'(a={a}) * (x={x}) + (b={b}) * (y={y}) == {a * x + b * y}')
# a=43, b=486, q=0, r=43
# a=486, b=43, q=11, r=13
# a=43, b=13, q=3, r=4
# a=13, b=4, q=3, r=1
# a=4, b=1, q=4, r=0
# x=0, y=1, q=3
# x=1, y=-3, q=3
# x=-3, y=10, q=11
# x=10, y=-113, q=0
# -113 10
# (a=43) * (x=-113) + (b=486) * (y=10) == 1
and now you can more easily follow what is happening at each function call.
The same result can be obtained with an iterative function:
def simple_linear_diophantine_i(a, b, debug=False):
qs = []
while True:
q, r = divmod(a, b)
if debug:
print(f'a={a}, b={b}, q={q}, r={r}')
a = b
b = r
if r != 0:
qs.append(q)
else:
break
x, y = b, a
for q in qs[::-1]:
if debug:
print(f'x={x}, y={y}, q={q}')
x, y = y, x - q * y
return x, y
a, b = 43, 486
x, y = simple_linear_diophantine_i(a, b, True)
print(x, y)
# a=43, b=486, q=0, r=43
# a=486, b=43, q=11, r=13
# a=43, b=13, q=3, r=4
# a=13, b=4, q=3, r=1
# a=4, b=1, q=4, r=0
# x=0, y=1, q=3
# x=1, y=-3, q=3
# x=-3, y=10, q=11
# x=10, y=-113, q=0
# (a=43) * (x=-113) + (b=486) * (y=10) == 1
with somewhat similar timing:
a = 123464357645765475246432152143432154321543256432654367547658641353276548767132465498760908567542543215
b = 65432654786531234532634712432
funcs = simple_linear_diophantine_r, simple_linear_diophantine_i
base = funcs[0](a, b)
print(base)
# (-14645224987639174972552062305, 27633958939547408859252562549330013276609719423270432707256961858787144635978588031424076994432005543)
for func in funcs:
res = func(a, b)
is_good = base == res
timed = %timeit -n 128 -r 128 -oq func(a, b)
timing = timed.best * 1e6
print(f"{func.__name__:>24} {is_good} {timing:10.3f} µs")
# simple_linear_diophantine_r True 25.855 µs
# simple_linear_diophantine_i True 22.439 µs

I also wrote a Linear Diophantine program that has stats and is faster than egcd python programs iv'e used so wanted to include it here for others interested in programs that solve these:
def llinear_diophantinex(a, b, divmodx=1, x=1, y=0, withstats=False):
origa, origb = a, b
r=a
q = a//b
prevq=1
if withstats == True:
print(f"a = {a}, b = {b}, q = {q}, r = {r}")
while r != 0:
prevr = r
a,r,b = b, b, r
q,r = divmod(a,b)
x, y = y, x - q * y
if withstats == True:
print(f"a = {a}, b = {b}, q = {q}, r = {r}, x = {x}, y = {y}")
y = 1 - origb*x // origa - 1
x,y=y,x
modx = (-abs(x)*divmodx)%origb
if withstats == True:
print(f"x = {x}, y = {y}, modx = {modx}")
return x, y, modx
In [5410]: llinear_diophantinex(272,1009, withstats=True)
a = 272, b = 1009, q = 0, r = 272
a = 1009, b = 272, q = 3, r = 193, x = 0, y = 1
a = 272, b = 193, q = 1, r = 79, x = 1, y = -1
a = 193, b = 79, q = 2, r = 35, x = -1, y = 3
a = 79, b = 35, q = 2, r = 9, x = 3, y = -7
a = 35, b = 9, q = 3, r = 8, x = -7, y = 24
a = 9, b = 8, q = 1, r = 1, x = 24, y = -31
a = 8, b = 1, q = 8, r = 0, x = -31, y = 272
x = 115, y = -31, modx = 894
Out[5410]: (115, -31, 894)

Sending a Polynomial to PARI/GP from Python (ctypes)

I would like to call nfroots({nf}; x) function of PARI/GP from Python. (see function no 3.13.135.on page 371 in this link:), but the probllem is, I couldn't send the algebraic expression or the polynomial, that need to be send, for example, x^2-7x+12, here is a very simple example of what gp can do with a quartic polynomial:
> V = readvec("coeff.txt");
> print(V)
[1,-7,12]
> P = Pol(V); # I get following error when I use Pol in my code: func=self._FuncPtr((name_or_ordinal, self)) AttributeError: function 'pol' not found
> print(P)
x^2 -7*x +12
> print(nfroots(,P))
>4, 3
From the answer of Stephan Schlecht (click here), I manage to write -
from ctypes import *
pari = cdll.LoadLibrary("C:\\Program Files\\Pari64-2-11-3\\libpari.dll")
pari.stoi.restype = POINTER(c_long)
pari.cgetg.restype = POINTER(POINTER(c_long))
pari.nfroots.restype = POINTER(POINTER(c_long))
pari.pari_init(2 ** 19, 0)
def t_vec(numbers):
l = len(numbers) + 1
p1 = pari.cgetg(c_long(l), c_long(10)) #t_POL = 10,
for i in range(1, l):
p1[i] = pari.stoi(c_long(numbers[i - 1]))
return p1
def main():
h = "x^2-7x+12"
res = pari.nfroots(t_vec(h))
for i in range(1, len(res)):
print(pari.itos(res[i]))
if __name__ == '__main__':
main()
Note that there is specific process to create of PARI objects (see the answer of Stephan Schlecht), I changed the value for t_POL = 10 , but the code didn't work, How can I execute the above PARI/GP code from python?

One solution could be:
use gtopoly, return type is POINTER(c_long)
return type of nfroots is POINTER(POINTER(c_long))
output of result with .pari_printf
Code
from ctypes import *
pari = cdll.LoadLibrary("libpari.so")
pari.stoi.restype = POINTER(c_long)
pari.cgetg.restype = POINTER(POINTER(c_long))
pari.gtopoly.restype = POINTER(c_long)
pari.nfroots.restype = POINTER(POINTER(c_long))
(t_VEC, t_COL, t_MAT) = (17, 18, 19) # incomplete
precision = c_long(38)
pari.pari_init(2 ** 19, 0)
def t_vec(numbers):
l = len(numbers) + 1
p1 = pari.cgetg(c_long(l), c_long(t_VEC))
for i in range(1, l):
p1[i] = pari.stoi(c_long(numbers[i - 1]))
return p1
def main():
V = (1, -7, 12)
P = pari.gtopoly(t_vec(V), c_long(-1))
res = pari.nfroots(None, P)
pari.pari_printf(bytes("%Ps\n", "utf8"), res)
if __name__ == '__main__':
main()
Test
If you run the program you get the desired output in the debug console:
[3, 4]
Conversions
With glength one can determine the length of a vector, see
https://pari.math.u-bordeaux.fr/dochtml/html/Conversions_and_similar_elementary_functions_or_commands.html#length
With itos a long can be returned if the parameter is of type t_INT, see section 4.4.6 of https://pari.math.u-bordeaux.fr/pub/pari/manuals/2.7.6/libpari.pdf.
In code it would look like this:
pari.glength.restype = c_long
pari.itos.restype = c_long
...
print("elements as long (only if of type t_INT): ")
for i in range(1, pari.glength(res) + 1):
print(pari.itos(res[i]))
To GENtostr gives a string representation of the argument. It could be used like so:
pari.GENtostr.restype = c_char_p
...
print("elements as generic strings: ")
for i in range(1, pari.glength(res) + 1):
print(pari.GENtostr(res[i]).decode("utf-8"))
There are many more conversion options, see the two links above.