Develop Reference

Bad floating point accuracy with numpy - python

I have a solution for a mathematical problem that looks like this (sorry for the formatting, that's what PyCharm is doing):
sigma = (wf_s[0] * u ** 4 + wf_s[1] * u ** 3 * v + wf_s[2] * u ** 3 + wf_s[3] * u ** 2 * v ** 2 + wf_s[
4] * u ** 2 * v + wf_s[5] * u ** 2 + wf_s[6] * u * v ** 3 + wf_s[7] * u * v ** 2 + wf_s[8] * u * v + wf_s[
9] * u + wf_s[10] * v ** 4 + wf_s[11] * v ** 3 + wf_s[12] * v ** 2 + wf_s[13] * v + wf_s[14]) / (
wf_s[15] * u ** 4 + wf_s[16] * u ** 3 * v + wf_s[17] * u ** 3 + wf_s[18] * u ** 2 * v ** 2 +
wf_s[19] * u ** 2 * v + wf_s[20] * u ** 2 + wf_s[21] * u * v ** 3 + wf_s[22] * u * v ** 2 +
wf_s[23] * u * v + wf_s[24] * u + wf_s[25] * v ** 4 + wf_s[26] * v ** 3 + wf_s[
27] * v ** 2 + wf_s[28] * v + wf_s[29])
sigma = sqrt(sigma)
x1 = (wf_x1[0] * u ** 2 * sigma + wf_x1[1] * u ** 2 + wf_x1[2] * u * v * sigma + wf_x1[3] * u * v + wf_x1[
4] * u * sigma + wf_x1[5] * u + wf_x1[6] * v ** 2 * sigma + wf_x1[7] * v ** 2 + wf_x1[8] * v * sigma +
wf_x1[9] * v + wf_x1[10] * sigma + wf_x1[11]) / (
wf_x1[12] * u ** 2 + wf_x1[13] * u * v + wf_x1[14] * u + wf_x1[15] * v ** 2 + wf_x1[16] * v +
wf_x1[17])
x2 = (wf_x2[0] * u ** 2 * sigma + wf_x2[1] * u ** 2 + wf_x2[2] * u * v * sigma + wf_x2[3] * u * v + wf_x2[
4] * u * sigma + wf_x2[5] * u + wf_x2[6] * v ** 2 * sigma + wf_x2[7] * v ** 2 + wf_x2[8] * v * sigma +
wf_x2[9] * v + wf_x2[10] * sigma + wf_x2[11]) / (
wf_x2[12] * u ** 2 + wf_x2[13] * u * v + wf_x2[14] * u + wf_x2[15] * v ** 2 + wf_x2[16] * v +
wf_x2[17])
y1 = (wf_y1[0] * u ** 2 * sigma + wf_y1[1] * u ** 2 + wf_y1[2] * u * v * sigma + wf_y1[3] * u * v + wf_y1[
4] * u * sigma + wf_y1[5] * u + wf_y1[6] * v ** 2 * sigma + wf_y1[7] * v ** 2 + wf_y1[8] * v * sigma +
wf_y1[9] * v + wf_y1[10] * sigma + wf_y1[11]) / (
wf_y1[12] * u ** 2 + wf_y1[13] * u * v + wf_y1[14] * u + wf_y1[15] * v ** 2 + wf_y1[16] * v +
wf_y1[17])
y2 = (wf_y2[0] * u ** 2 * sigma + wf_y2[1] * u ** 2 + wf_y2[2] * u * v * sigma + wf_y2[3] * u * v + wf_y2[
4] * u * sigma + wf_y2[5] * u + wf_y2[6] * v ** 2 * sigma + wf_y2[7] * v ** 2 + wf_y2[8] * v * sigma +
wf_y2[9] * v + wf_y2[10] * sigma + wf_y2[11]) / (
wf_y2[12] * u ** 2 + wf_y2[13] * u * v + wf_y2[14] * u + wf_y2[15] * v ** 2 + wf_y2[16] * v +
wf_y2[17])
This calculation is running relatively slow in Python so I wanted to increase the speed using numpy. The result looks like this:
u2 = u ** 2
u3 = u ** 3
u4 = u ** 4
v2 = v ** 2
v3 = v ** 3
v4 = v ** 4
uv_s = np.array((u4, u3 * v, u3, u2 * v2, u2 * v, u2, u * v3, u * v2, u * v, u, v4, v3, v2, v, 1))
sigma = np.dot(wf_s[:15], uv_s) / np.dot(wf_s[15:], uv_s)
sigma = sqrt(sigma)
uv_xy_n = np.array((u2 * sigma, u2, u * v * sigma, u * v, u * sigma, u, v2 * sigma, v2, v * sigma, v, sigma, 1))
uv_xy_d = np.array((u2, u * v, u, v2, v, 1))
x12 = np.dot(wf_x1[:12], uv_xy_n) / np.dot(wf_x1[12:], uv_xy_d)
x22 = np.dot(wf_x2[:12], uv_xy_n) / np.dot(wf_x2[12:], uv_xy_d)
y12 = np.dot(wf_y1[:12], uv_xy_n) / np.dot(wf_y1[12:], uv_xy_d)
y22 = np.dot(wf_y2[:12], uv_xy_n) / np.dot(wf_y2[12:], uv_xy_d)
In theory this works fine and runs 3 times faster than my first method but the accuracy of the results is horrible. In my case, x and y are in the hundreds and the second method produces results that differ up to 0.2 from the real result. This accuracy is of no use in my case. Plotting the results of the first method results in a perfect plot as expected. Plotting the results of the second method results in a super noisy plot.
Why is the accuracy of the numpy version so bad and how can I improve it?

Related

I'm trying to rework program on glDrawArray . If i use justglVertex3feverything is fine and if i useglDrawArrays` for the same values of vertexes i get some random lines in addition to the figure.
with glDrawArrays
ususal glVertex3f as it should look like
And in 50% i get an error
pgl.glDrawArrays(pgl.GL_TRIANGLE_STRIP, 0, array_size)
OSError: exception: access violation reading 0x0CF52000
code (pastbin)
import pyglet
import pyglet.gl as pgl
from pyglet.window import key
import math
import json
import time
win = pyglet.window.Window(1300, 1000, resizable=True)
global_time = time.time()
frame_counter = 0
WINDOW = 1000
tr = 96
tr_temp = 90
INCREMENT = 5
transparant = False
xRotation = -70
zRotation = -30
yRotation = 180
zoom = 1
x = -180
y = 70
z = 0
light = False
param = 0
t_prev = -5
start_loop = False
run_l = False
Texture = False
texture_obj = None
lamp1 = False
lamp2 = False
lamp3 = False
data = {}
with open('PycharmProjects/untitled/data.json') as fp:
data = json.load(fp)
transparant = data['transparant']
xRotation = data['xRotation']
yRotation = data['yRotation']
zRotation = data['zRotation']
zoom = data['zoom']
x = data['x']
y = data['y']
z = data['z']
light = data['light']
param = data['param']
t_prev = data['t_prev']
start_loop = data['start_loop']
run_l = data['run_l']
Texture = data['Texture']
lamp1 = data['lamp1']
lamp2 = data['lamp2']
lamp3 = data['lamp3']
tr = data['tr']
def writeToJSONFile(path, filename, data):
filePathName = path + '.json'
with open(filePathName, 'w') as fp:
json.dump(data,fp)
def run_loop(dt):
on_draw()
def draw_figure():
global texture_obj
angle = 0
t = 0
x = y = z = 0
a = 50
b = 100
array_size = 0
array = []
if Texture:
if texture_obj == None:
texture_obj = pyglet.image.load("PycharmProjects/untitled/test1_texture.bmp").get_texture()
pgl.glBindTexture(pgl.GL_TEXTURE_2D, texture_obj.id)
pgl.glEnable(pgl.GL_TEXTURE_2D)
# pgl.glTexParameterf(pgl.GL_TEXTURE_2D, pgl.GL_TEXTURE_WRAP_T, pgl.GL_REPEAT)
# pgl.glTexParameterf(pgl.GL_TEXTURE_2D, pgl.GL_TEXTURE_MAG_FILTER, pgl.GL_NEAREST)
# #
#
# pgl.glTexEnvi(pgl.GL_TEXTURE_ENV, pgl.GL_TEXTURE_ENV_MODE, pgl.GL_REPLACE)
else:
pgl.glDisable(pgl.GL_TEXTURE_2D)
if not transparant:
pgl.glPolygonMode(pgl.GL_FRONT_AND_BACK, pgl.GL_FILL)
else:
pgl.glPolygonMode(pgl.GL_FRONT_AND_BACK, pgl.GL_LINE)
pgl.glBegin(pgl.GL_TRIANGLE_STRIP)
for i in range(0, tr + 1):
pgl.glColor3ub(0, 0, 0)
if i >= 1:
t1 = a1
t2 = a2
t3 = a3
u = math.cos(i * 2 * math.pi / tr)
v = math.sin(i * 2 * math.pi / tr)
a1 = x + a * u
a2 = y + b * v
a3 = z + 8
if Texture:
pgl.glTexCoord2f(u * 0.5 + 0.5, v * 0.5 + 0.5)
pgl.glVertex3f(a1, a2, a3)
if i >= 1:
pgl.glNormal3f((b2 - t2) * (a3 - b3) - (b3 - t3) * (a2 - b2), (b3 - t3) * (a1 - b1) - (b1 - t1) * (a3 - b3),
(b1 - t1) * (a2 - b2) - (b2 - t2) * (a1 - b1))
b1 = x
b2 = y
b3 = z + 8
if Texture:
pgl.glTexCoord2f(0.5, 0.5)
pgl.glVertex3f(b1, b2, b3)
pgl.glEnd()
for j in range(1, 27):
pgl.glBegin(pgl.GL_TRIANGLE_STRIP)
pgl.glColor3ub(0, 0, 0)
x1 = a * math.cos(0)
y1 = b * math.sin(0)
a1 = x1 * math.cos(t * math.pi / 360) + y1 * math.sin(t * math.pi / 360)
a2 = - x1 * math.sin(t * math.pi / 360) + y1 * math.cos(t * math.pi / 360)
a3 = z + j * 8
if Texture:
pgl.glTexCoord2f(0.0, 0.0)
a01 = a1
a02 = a2
a03 = a3
print(a1,a2,a3)
array.extend([a1,a2,a3])
array_size += 3
# pgl.glVertex3f(a1, a2, a3)
b1 = x1 * math.cos((t + 16) * math.pi / 360) + y1 * math.sin((t + 16) * math.pi / 360)
b2 = - x1 * math.sin((t + 16) * math.pi / 360) + y1 * math.cos((t + 16) * math.pi / 360)
b3 = z + j * 8 + 8
u = math.cos((t + 16) * math.pi / 360) + math.sin((t + 16) * math.pi / 360)
v = (j - 1) / 26
if Texture:
pgl.glTexCoord2f(0.0, 0.0)
array.extend([b1,b2,b3])
print(b1,b2,b3)
array_size += 3
# pgl.glVertex3f(b1, b2, b3)
b01 = b1
b02 = b2
b03 = b3
for i in range(1, tr):
pgl.glColor3ub(0, 0, 0)
x1 = a * math.cos(i * 2 * math.pi / tr)
y1 = b * math.sin(i * 2 * math.pi / tr)
t1 = a1
t2 = a2
t3 = a3
a1 = x1 * math.cos(t * math.pi / 360) + y1 * math.sin(t * math.pi / 360)
a2 = - x1 * math.sin(t * math.pi / 360) + y1 * math.cos(t * math.pi / 360)
a3 = z + j * 8
pgl.glNormal3f((b2 - t2) * (a3 - b3) - (b3 - t3) * (a2 - b2), (b3 - t3) * (a1 - b1) - (b1 - t1) * (a3 - b3),
(b1 - t1) * (a2 - b2) - (b2 - t2) * (a1 - b1))
v = math.cos(t * math.pi / 360) + math.sin(t * math.pi / 360)
if Texture:
pgl.glTexCoord2f((i - 1) / tr, (26 - j) / 26)
array.extend([a1,a2,a3])
print(a1,a2,a3)
array_size += 3
# pgl.glVertex3f(a1, a2, a3)
x1 = a * math.cos(i * 2 * math.pi / tr)
y1 = b * math.sin(i * 2 * math.pi / tr)
b1 = x1 * math.cos((t + 16) * math.pi / 360) + y1 * math.sin((t + 16) * math.pi / 360)
b2 = - x1 * math.sin((t + 16) * math.pi / 360) + y1 * math.cos((t + 16) * math.pi / 360)
b3 = z + j * 8 + 8
v = math.cos((t + 16) * math.pi / 360) + math.sin((t + 16) * math.pi / 360)
if Texture:
pgl.glTexCoord2f((i - 1) / tr, (25 - j) / 26)
array.extend([b1,b2,b3])
print(b1,b2,b3)
array_size += 3
# pgl.glVertex3f(b1, b2, b3)
print(a01,a02,a03)
array.extend([a01,a02,a03])
array_size += 3
# pgl.glVertex3f(a01, a02, a03)
print(b01,b02,b03)
array.extend([b01,b02,b03])
array_size += 3
# pgl.glVertex3f(b01, b02, b03)
t = t + 16
pgl.glEnd()
pgl.glBegin(pgl.GL_TRIANGLE_STRIP)
t = 416
z = z + 144
angle = angle + t
for i in range(0, tr + 1):
pgl.glColor3ub(0, 0, 0)
u = math.cos(i * 2 * math.pi / tr)
v = math.sin(i * 2 * math.pi / tr)
x1 = x + a * u
y1 = y + b * v
x2 = x1 * math.cos(t * math.pi / 360) + y1 * math.sin(t * math.pi / 360)
y2 = - x1 * math.sin(t * math.pi / 360) + y1 * math.cos(t * math.pi / 360)
if i >= 1:
t1 = a1
t2 = a2
t3 = a3
a1 = x2
a2 = y2
a3 = z + 72
if Texture:
pgl.glTexCoord2f(u * 0.5 + 0.5, v * 0.5 + 0.5)
pgl.glVertex3f(a1, a2, a3)
if i >= 1:
pgl.glNormal3f((b2 - t2) * (a3 - b3) - (b3 - t3) * (a2 - b2), (b3 - t3) * (a1 - b1) - (b1 - t1) * (a3 - b3),
(b1 - t1) * (a2 - b2) - (b2 - t2) * (a1 - b1))
b1 = x
b2 = y
b3 = z + 72
if Texture:
pgl.glTexCoord2f(0.5, 0.5)
pgl.glVertex3f(b1, b2, b3)
angle = angle + i
pgl.glEnd()
pgl.glEnableClientState(pgl.GL_VERTEX_ARRAY)
data = (pgl.GLfloat * len(array))(*array)
pgl.glVertexPointer(3, pgl.GL_FLOAT, 0, data)
pgl.glDrawArrays(pgl.GL_TRIANGLE_STRIP, 0, array_size)
pgl.glDisableClientState(pgl.GL_VERTEX_ARRAY)
#win.event
def on_draw():
global x, y, z, start_loop, run_l, param, t_prev, zRotation,frame_counter
start_time = time.time()
pgl.glClearColor(0.0, 0.0, 0.0, 0.0)
pgl.glEnable(pgl.GL_DEPTH_TEST)
if light:
pgl.glEnable(pgl.GL_LIGHTING)
pgl.glLightModelf(pgl.GL_LIGHT_MODEL_TWO_SIDE, pgl.GL_FALSE)
pgl.glEnable(pgl.GL_NORMALIZE)
else:
pgl.glDisable(pgl.GL_LIGHTING)
pgl.glDisable(pgl.GL_NORMALIZE)
pgl.glClear(pgl.GL_COLOR_BUFFER_BIT | pgl.GL_DEPTH_BUFFER_BIT)
pgl.glLoadIdentity()
pgl.glViewport(0, 0, 1300, 1000)
pgl.glMatrixMode(pgl.GL_PROJECTION)
pgl.glLoadIdentity()
pgl.glOrtho(-1300 / 4, 1300 / 4, -1000 / 4, 1000 / 4, -400, 600)
pgl.glMatrixMode(pgl.GL_MODELVIEW)
pgl.glLoadIdentity()
if light:
material_diffuse = [1.0, 1.0, 1.0, 1.0]
pgl.glMaterialfv(pgl.GL_FRONT_AND_BACK, pgl.GL_DIFFUSE,
(pgl.GLfloat * len(material_diffuse))(*material_diffuse))
if lamp1:
light5_diffuse = [1.0, 0.0, 0.0];
light5_position = [0, 0, -1.0, 0];
pgl.glEnable(pgl.GL_LIGHT5);
pgl.glLightfv(pgl.GL_LIGHT5, pgl.GL_DIFFUSE, (pgl.GLfloat * len(light5_diffuse))(*light5_diffuse));
pgl.glLightfv(pgl.GL_LIGHT5, pgl.GL_POSITION, (pgl.GLfloat * len(light5_position))(*light5_position));
pgl.glLightf(pgl.GL_LIGHT5, pgl.GL_CONSTANT_ATTENUATION, 0.0);
pgl.glLightf(pgl.GL_LIGHT5, pgl.GL_LINEAR_ATTENUATION, 0.4);
pgl.glLightf(pgl.GL_LIGHT5, pgl.GL_QUADRATIC_ATTENUATION, 0.8);
else:
pgl.glDisable(pgl.GL_LIGHT5);
if lamp2:
light6_diffuse = [0.0, 1.0, 0.0];
light6_position = [1, 0.5, -1.0, 0];
pgl.glEnable(pgl.GL_LIGHT6);
pgl.glLightfv(pgl.GL_LIGHT6, pgl.GL_DIFFUSE, (pgl.GLfloat * len(light6_diffuse))(*light6_diffuse));
pgl.glLightfv(pgl.GL_LIGHT6, pgl.GL_POSITION, (pgl.GLfloat * len(light6_position))(*light6_position));
pgl.glLightf(pgl.GL_LIGHT6, pgl.GL_CONSTANT_ATTENUATION, 0.0);
pgl.glLightf(pgl.GL_LIGHT6, pgl.GL_LINEAR_ATTENUATION, 0.4);
pgl.glLightf(pgl.GL_LIGHT6, pgl.GL_QUADRATIC_ATTENUATION, 0.8);
else:
pgl.glDisable(pgl.GL_LIGHT6);
if lamp3:
light7_diffuse = [0.0, 0.0, 1.0];
light7_position = [0.5 * math.cos(4 * math.pi / 3), 0.5 * math.sin(4 * math.pi / 3), 1.0, 0];
pgl.glEnable(pgl.GL_LIGHT7);
pgl.glLightfv(pgl.GL_LIGHT7, pgl.GL_DIFFUSE, (pgl.GLfloat * len(light7_diffuse))(*light7_diffuse));
pgl.glLightfv(pgl.GL_LIGHT7, pgl.GL_POSITION, (pgl.GLfloat * len(light7_position))(*light7_position));
pgl.glLightf(pgl.GL_LIGHT7, pgl.GL_CONSTANT_ATTENUATION, 0.0);
pgl.glLightf(pgl.GL_LIGHT7, pgl.GL_LINEAR_ATTENUATION, 0.4);
pgl.glLightf(pgl.GL_LIGHT7, pgl.GL_QUADRATIC_ATTENUATION, 0.8);
else:
pgl.glDisable(pgl.GL_LIGHT7);
pgl.glPolygonMode(pgl.GL_FRONT_AND_BACK, pgl.GL_FILL)
pgl.glPushMatrix()
pgl.glTranslatef(x, y, z)
pgl.glRotatef(xRotation, 1, 0, 0)
pgl.glRotatef(yRotation, 0, 1, 0)
pgl.glRotatef(zRotation, 0, 0, 1)
pgl.glScalef(zoom, zoom, zoom)
draw_figure()
if start_loop:
start_loop = False
run_l = True
x = ((1 - (param / 100)) ** 3) * (-180) + 3 * (param / 100) * ((1 - (param / 100)) ** 2) * (100) + 3 * (
(param / 100) ** 2) * (
1 - (param / 100)) * (0) + ((param / 100) ** 3) * (200)
y = ((1 - (param / 100)) ** 3) * 70 + 3 * (param / 100) * ((1 - (param / 100)) ** 2) * (140) + 3 * (
(param / 100) ** 2) * (
1 - (param / 100)) * (140) + ((param / 100) ** 3) * (
70)
z = ((1 - (param / 100)) ** 3) * 0 + 3 * (param / 100) * ((1 - (param / 100)) ** 2) * (100) + 3 * (
(param / 100) ** 2) * (
1 - (param / 100)) * (100) + ((param / 100) ** 3) * (
0)
elif run_l:
if param < 100 and param > t_prev:
zRotation += INCREMENT
param = param + 1
t_prev = t_prev + 1
if (param == 100):
t_prev = 105
x = ((1 - (param / 100)) ** 3) * (-180) + 3 * (param / 100) * ((1 - (param / 100)) ** 2) * (100) + 3 * (
(param / 100) ** 2) * (1 - (param / 100)) * (0) + ((param / 100) ** 3) * (200)
y = ((1 - (param / 100)) ** 3) * 70 + 3 * (param / 100) * ((1 - (param / 100)) ** 2) * (140) + 3 * (
(param / 100) ** 2) * (1 - (param / 100)) * (140) + ((param / 100) ** 3) * (
70)
z = ((1 - (param / 100)) ** 3) * 0 + 3 * (param / 100) * ((1 - (param / 100)) ** 2) * (100) + 3 * (
(param / 100) ** 2) * (1 - (param / 100)) * (100) + ((param / 100) ** 3) * (
0)
if param > 0 and param < t_prev:
zRotation -= INCREMENT
param = param - 1
t_prev = t_prev - 1
if (param == 0):
t_prev = -5
x = ((1 - (param / 100)) ** 3) * (-180) + 3 * (param / 100) * ((1 - (param / 100)) ** 2) * (100) + 3 * (
(param / 100) ** 2) * (1 - (param / 100)) * (0) + ((param / 100) ** 3) * (200)
y = ((1 - (param / 100)) ** 3) * 70 + 3 * (param / 100) * ((1 - (param / 100)) ** 2) * (140) + 3 * (
(param / 100) ** 2) * (1 - (param / 100)) * (140) + ((param / 100) ** 3) * (
70)
z = ((1 - (param / 100)) ** 3) * 0 + 3 * (param / 100) * ((1 - (param / 100)) ** 2) * (100) + 3 * (
(param / 100) ** 2) * (1 - (param / 100)) * (100) + ((param / 100) ** 3) * (
0)
frame_counter +=1
# print("FPS: ", 1.0 / (time.time() - start_time))
pgl.glPopMatrix()
#win.event
def on_text_motion(motion):
global xRotation, yRotation, INCREMENT
if motion == key.UP:
xRotation -= INCREMENT
elif motion == key.DOWN:
xRotation += INCREMENT
elif motion == key.LEFT:
yRotation -= INCREMENT
elif motion == key.RIGHT:
yRotation += INCREMENT
#win.event
def on_key_press(symbol, modifiers):
global transparant, data, tr, x, y, z, INCREMENT, zRotation, light, t, start_loop, run_l, Texture, tr_temp
global xRotation, yRotation, zRotation,zoom, t_prev, texture_obj, lamp1, lamp2, lamp3, global_time, frame_counter
if symbol == key.T and not transparant:
transparant = True
elif symbol == key.T and transparant:
transparant = False
elif symbol == key.W:
x += 2.5
elif symbol == key.S:
x -= 2.5
elif symbol == key.A:
y -= 2.5
elif symbol == key.D:
y += 2.5
elif symbol == key.Q:
z -= 2.5
elif symbol == key.E:
z += 2.5
elif symbol == key.L:
light = not light
lamp1 = True
lamp2 = True
lamp3 = True
elif symbol == key.Z:
zRotation += INCREMENT
elif symbol == key.X:
zRotation -= INCREMENT
elif symbol == key.ESCAPE:
path = 'PycharmProjects/untitled/data'
fileName = 'data'
data['transparant'] = transparant
data['xRotation'] = xRotation
data['yRotation'] = yRotation
data['zRotation'] = zRotation
data['zoom'] = zoom
data['x'] = x
data['y'] = y
data['z'] = z
data['light'] = light
data['param'] = param
data['t_prev'] = t_prev
data['start_loop'] = start_loop
data['run_l'] = run_l
data['Texture'] = Texture
data['lamp1'] = lamp1
data['lamp2'] = lamp2
data['lamp3'] = lamp3
data['tr'] = tr
data['tr_temp'] = tr_temp
writeToJSONFile(path, fileName, data)
pyglet.app.exit()
elif symbol == key.P:
tr += 5
elif symbol == key.O:
if tr > 6:
tr -= 5
elif symbol == key.SPACE:
if not run_l:
tr_temp = tr
tr = 6
start_loop = True
else:
run_l = False
tr = tr_temp
elif symbol == key.M:
print("pressed")
Texture = not Texture
elif symbol == key._1:
lamp1 = not lamp1
elif symbol == key._2:
lamp2 = not lamp2
elif symbol == key._3:
lamp3 = not lamp3
elif symbol == key.F:
print("FPS: ", frame_counter / (time.time() - global_time))
frame_counter = 0
global_time = time.time()
#win.event
def on_mouse_scroll(x, y, scroll_x, scroll_y):
global zoom
if scroll_y < 0:
zoom += 0.1
elif scroll_y > 0 and zoom - 0.1 > 0:
zoom -= 0.1
#win.event
def on_mouse_press(x, y, button, modifiers):
if button == pyglet.window.mouse.LEFT:
print(x, y)
pyglet.clock.schedule_interval(run_loop, 0.1)
pyglet.app.run()
(for the first launch turn off reading from json file, then after first closing using esc the programme will read saved parameters)
Troubles in draw_figure

The major issue is, that GL_TRIANGLE_STRIP can not be connected arbitrarily:
1 3 5
+-----+-----+
| \ | \ |
| \ | \ |
+-----+-----+
0 2 4
7 9 11
+-----+-----+
| \ | \ |
| \ | \ |
+-----+-----+
6 8 10
If the above strips are join directly, then this would generate the triangles 4 - 5 - 6 and 5 - 6 -7, which are not wanted.
But this can be avoided by simple trick. You've to add duplicate vertices. Note if 2 points of triangle are equal, the area of the triangle is zero.
If the vertices 5 and 6 would be add twice, then the strips are concatenated by the triangles 4 - 5 - 5, 5 - 5 - 6, 5 - 6 - 6 and 6 - 6 - 7. Each of this triangles has no size.
I recommend to store the vertex coordinates and attributes to lists:
vertex = []
color = []
normal = []
textcoord = []
Define a function which extends the lists by coordinates and attributes:
def add_vertex(v, c, t, n):
global vertex, color, normal, textcoord
vertex.extend(v)
color.extend(c)
textcoord.extend(t)
normal.extend(n)
Define a function which duplicates the last coordinates and attributes in the list, which can be used for the concatenation of triangle strips:
def repeat_vertex():
add_vertex(vertex[-3:], color[-3:], textcoord[-2:], normal[-3:])
Define another function, which constructs the shape (figure). The function has to define all the attributes (color, texture coordinates and normal vector), regardless if they are used later:
def construct_figure():
angle = 0
t = 0
x = y = z = 0
a = 50
b = 100
for i in range(0, tr + 1):
if i >= 1:
t1, t2, t3 = a1, a2, a3
u, v = math.cos(i * 2 * math.pi / tr), math.sin(i * 2 * math.pi / tr)
a1, a2, a3 = x + a * u, y + b * v, z + 8
add_vertex([a1, a2, a3],
[u * 0.5 + 0.5, 0, v * 0.5 + 0.5],
[u * 0.5 + 0.5, v * 0.5 + 0.5],
[0, 0, -1])
b1, b2, b3 = x, y, z + 8
add_vertex([b1, b2, b3], [0.5, 0, 0.5], [0.5, 0.5], normal[-3:])
repeat_vertex()
for j in range(1, 27):
x1, y1 = a * math.cos(0), b * math.sin(0)
a1 = x1 * math.cos(t * math.pi / 360) + y1 * math.sin(t * math.pi / 360)
a2 = - x1 * math.sin(t * math.pi / 360) + y1 * math.cos(t * math.pi / 360)
a3 = z + j * 8
a01, a02, a03 = a1, a2, a3
add_vertex([a1, a2, a3], [0, 0, 0], [0, 0], normal[-3:])
repeat_vertex()
b1 = x1 * math.cos((t + 16) * math.pi / 360) + y1 * math.sin((t + 16) * math.pi / 360)
b2 = - x1 * math.sin((t + 16) * math.pi / 360) + y1 * math.cos((t + 16) * math.pi / 360)
b3 = z + j * 8 + 8
u = math.cos((t + 16) * math.pi / 360) + math.sin((t + 16) * math.pi / 360)
v = (j - 1) / 26
add_vertex([b1, b2, b3], color[-3:], [0, 0], normal[-3:])
b01, b02, b03 = b1, b2, b3
for i in range(1, tr):
x1 = a * math.cos(i * 2 * math.pi / tr)
y1 = b * math.sin(i * 2 * math.pi / tr)
t1, t2, t3 = a1, a2, a3
a1 = x1 * math.cos(t * math.pi / 360) + y1 * math.sin(t * math.pi / 360)
a2 = - x1 * math.sin(t * math.pi / 360) + y1 * math.cos(t * math.pi / 360)
a3 = z + j * 8
v = math.cos(t * math.pi / 360) + math.sin(t * math.pi / 360)
add_vertex([a1, a2, a3],
[math.cos(i * 2 * math.pi / tr)*0.5 + 0.5, j/27, math.sin(i * 2 * math.pi / tr)*0.5 + 0.5],
[(i - 1) / tr, (26 - j) / 26],
[(b2 - t2) * (a3 - b3) - (b3 - t3) * (a2 - b2), (b3 - t3) * (a1 - b1) - (b1 - t1) * (a3 - b3),
(b1 - t1) * (a2 - b2) - (b2 - t2) * (a1 - b1)])
x1 = a * math.cos(i * 2 * math.pi / tr)
y1 = b * math.sin(i * 2 * math.pi / tr)
b1 = x1 * math.cos((t + 16) * math.pi / 360) + y1 * math.sin((t + 16) * math.pi / 360)
b2 = - x1 * math.sin((t + 16) * math.pi / 360) + y1 * math.cos((t + 16) * math.pi / 360)
b3 = z + j * 8 + 8
v = math.cos((t + 16) * math.pi / 360) + math.sin((t + 16) * math.pi / 360)
add_vertex([b1, b2, b3], color[-3:], [(i - 1) / tr, (25 - j) / 26], normal[-3:])
add_vertex([a01, a02, a03], color[-3:], textcoord[-2:], normal[-3:])
add_vertex([b01, b02, b03], color[-3:], textcoord[-2:], normal[-3:])
t = t + 16
repeat_vertex()
t = 416
z = z + 144
angle = angle + t
for i in range(0, tr + 1):
u, v = math.cos(i * 2 * math.pi / tr), math.sin(i * 2 * math.pi / tr)
x1, y1 = x + a * u, y + b * v
x2 = x1 * math.cos(t * math.pi / 360) + y1 * math.sin(t * math.pi / 360)
y2 = - x1 * math.sin(t * math.pi / 360) + y1 * math.cos(t * math.pi / 360)
if i >= 1:
t1, t2, t3 = a1, a2, a3
a1, a2, a3 = x2, y2, z + 72
add_vertex([a1, a2, a3],
[u * 0.5 + 0.5, 1, v * 0.5 + 0.5],
[u * 0.5 + 0.5, v * 0.5 + 0.5],
[0, 0, 1])
if i == 0:
repeat_vertex()
b1, b2, b3 = x, y, z +72
add_vertex([b1, b2, b3], [0.5, 1, 0.5], [0.5, 0.5], normal[-3:])
angle = angle + i
repeat_vertex()
Now the shape can be either drawn by glBegin/glEnd sequnces or glDrawArrays:
draw_array = True # False
def draw_figure():
# [...]
if not draw_array:
pgl.glBegin(pgl.GL_TRIANGLE_STRIP)
for i in range(len(vertex)//3):
if Texture:
pgl.glTexCoord2f(textcoord[i*2], textcoord[i*2+1])
else:
pgl.glColor3f(color[i*3], color[i*3+1], color[i*3+2])
pgl.glNormal3f(normal[i*3], normal[i*3+1], normal[i*3+2])
pgl.glVertex3f(vertex[i*3], vertex[i*3+1], vertex[i*3+2])
pgl.glEnd()
else:
pgl.glEnableClientState(pgl.GL_VERTEX_ARRAY)
data = (pgl.GLfloat * len(vertex))(*vertex)
pgl.glVertexPointer(3, pgl.GL_FLOAT, 0, data)
pgl.glDrawArrays(pgl.GL_TRIANGLE_STRIP, 0, len(vertex) // 3)
pgl.glDisableClientState(pgl.GL_VERTEX_ARRAY)
The shape can be constructed at the begin of the application:
construct_figure()
pyglet.clock.schedule_interval(run_loop, 0.1)
pyglet.app.run()

I am a beginner in python. I have a problem with 2 ODEs that are second order and they are coupled. I want to solve it with Runge Kutta 4th order. I have made 2 matrices.[A] and [B] that V' = A*C + B . But I couldn't get the answer. Can anyone help me?
This is equations
Equations
this is my code:
import numpy as np
from math import sqrt
from sympy import *
import matplotlib.pyplot as plt
x,v1, v2, v3, v4, dv1, dv2, dv3, dv4, t = symbols('x v1 v2 v3 v4 dv1 dv2 dv3 dv4 t')
# Parameters
mr =
m =
c =
k =
F =
# Equations:
A = Matrix([[0, 0, 1, 0], [0, 0, 0, 1], [-k / mr, k / mr, -c / mr, c / mr], [k / m, -k / m, c / m, -c / m]])
B = Matrix([0, 0, 0, -F])
dv1 = diff(v1, t)
dv2 = diff(v2, t)
dv3 = diff(v3, t)
dv4 = diff(v4, t)
C = Matrix([v1,v2,v3,v4])
def V(v1,v2,v3,v4,t):
V = A*C+B
return V
def rk4(f, v1, v2, v3 ,v4 , x0 , x1 , n):
k11 = [0] * (n + 1)
k21 = [0] * (n + 1)
k31 = [0] * (n + 1)
k41 = [0] * (n + 1)
k12 = [0] * (n + 1)
k22 = [0] * (n + 1)
k32 = [0] * (n + 1)
k42 = [0] * (n + 1)
k13 = [0] * (n + 1)
k23 = [0] * (n + 1)
k33 = [0] * (n + 1)
k43 = [0] * (n + 1)
k14 = [0] * (n + 1)
k24 = [0] * (n + 1)
k34 = [0] * (n + 1)
k44 = [0] * (n + 1)
h = (x1 - x0) / n
for i in range(1, n + 1):
k11 = h * f(v1, v2, v3, v4, t)
k21 = h * f(v1, v2, v3, v4, t)
k31 = h * f(v1, v2, v3, v4, t)
k41 = h * f(v1, v2, v3, v4, t)
k12 = h * f(v1 + 0.5 * h, v2 + 0.5 * h, v3 + 0.5 * h, v4 + 0.5 * h, t + 0.5 * k11)
k22 = h * f(v1 + 0.5 * h, v2 + 0.5 * h, v3 + 0.5 * h, v4 + 0.5 * h, t + 0.5 * k21)
k32 = h * f(v1 + 0.5 * h, v2 + 0.5 * h, v3 + 0.5 * h, v4 + 0.5 * h, t + 0.5 * k31)
k42 = h * f(v1 + 0.5 * h, v2 + 0.5 * h, v3 + 0.5 * h, v4 + 0.5 * h, t + 0.5 * k41)
k13 = h * f(v1 + 0.5 * h, v2 + 0.5 * h, v3 + 0.5 * h, v4 + 0.5 * h, t + 0.5 * k12)
k23 = h * f(v1 + 0.5 * h, v2 + 0.5 * h, v3 + 0.5 * h, v4 + 0.5 * h, t + 0.5 * k22)
k33 = h * f(v1 + 0.5 * h, v2 + 0.5 * h, v3 + 0.5 * h, v4 + 0.5 * h, t + 0.5 * k32)
k43 = h * f(v1 + 0.5 * h, v2 + 0.5 * h, v3 + 0.5 * h, v4 + 0.5 * h, t + 0.5 * k42)
k14 = h * f(v1 + h, v2 + h, v3 + h, v4 + h, t + k13)
k24 = h * f(v1 + h, v2 + h, v3 + h, v4 + h, t + k23)
k34 = h * f(v1 + h, v2 + h, v3 + h, v4 + h, t + k33)
k44 = h * f(v1 + h, v2 + h, v3 + h, v4 + h, t + k43)
t[i] = t + i * h
jv1[i] = v1 + (k11 + k12 + k12 + k13 + k13 + k14) / 6
jv2[i] = v2 + (k21 + k22 + k22 + k23 + k23 + k24) / 6
jv3[i] = v3 + (k31 + k32 + k32 + k33 + k33 + k34) / 6
jv4[i] = v4 + (k41 + k42 + k42 + k43 + k43 + k44) / 6
return jv1, jv2 , jv3, jv4
jv1, jv2 , jv3 , jv4 = rk4(V, 0, 0, 1, 1 , 0 , 1 , 10)
plt.plot(jv1, jv2 , jv3 , jv4 , t)
plt.grid('on')
plt.show()

Cutting away unused and contradicting variables and statements a running reduction and correction of your code is
import numpy as np
from math import sqrt
import matplotlib.pyplot as plt
# Parameters
mr = 2
m = 1
c = 5
k = 36
F = 3
# Equations:
def V(u,t):
x1, x2, v1, v2 = u
dx = x2-x1;
dv = v2-v1;
return np.array([ v1, v2, (c*dv+k*dx)/mr, -(F+c*dv+k*dx)/m ])
def rk4(f, u0, t0, tf , n):
t = np.linspace(t0, tf, n+1)
u = np.array((n+1)*[u0])
h = t[1]-t[0]
for i in range(n):
k1 = h * f(u[i], t[i])
k2 = h * f(u[i] + 0.5 * k1, t[i] + 0.5*h)
k3 = h * f(u[i] + 0.5 * k2, t[i] + 0.5*h)
k4 = h * f(u[i] + k3, t[i] + h)
u[i+1] = u[i] + (k1 + 2*(k2 + k3) + k4) / 6
return u, t
u, t = rk4(V, np.array([0., 0., 1., 1.]) , 0. , 1. , 10)
x1, x2, v1, v2 = u.T
plt.plot(t, x1, t, x2)
plt.grid('on')
plt.show()
If that is in any way a correct result is up to you to determine.

I need to solve task, there is a condition:
There is a a sequence of 17 consecutive natural numbers starting with N. For any number a of this sequence there is another number b from this sequence, such that GCD (a, b)> 1. Find the minimal N with this condition.
I use this code
for i in range(2, 100000000):
not_division = 0
lst = list(range(i, i+17))
#print(lst)
for j in lst:
counter = 0
for k in lst[1:]:
if gcd_iterative(j, k) > 1 and gcd_iterative(j, k) != k:
counter += 1
if counter == 0:
not_division += 1
#print('%s have no delimiter' % j)
if not_division == 0:
print('%s SUCCESS' % str(lst))
But there is not sequence.
Maybe I do smth wrong.

I would try to tackle this with a less brute-force approach.
Some thought experiment first. Every other number will have the factor 2 in common. For the remaining 8 or 9, you need more factors. So for example you could have a factor of 3 common to some of them. Then another factor, and so on, e.g.:
2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2
* 3 * * 3 * * 3 * * 3 * * 3 * * 3
* * * 5 * * * * 5 * * * * 5 * * *
^ ^ ^ ^
So now do this in a more systematic way. Consider all prime factors smaller than 17. Try each combination of those, and for each combination each possible offset (but only those with at least 2 occurrences in the sequence). See which of these lead to a situation where every number has at least one partner. Then find the corresponding sequence using the Chinese remainder theorem.
Actually there are only 2 candidates:
2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2
3 * * 3 * * 3 * * 3 * * 3 * * 3 *
* 5 * * * * 5 * * * * 5 * * * * 5
7 * * * * * * 7 * * * * * * 7 * *
* * * * * 11 * * * * * * * * * * 11
13 * * * * * * * * * * * * 13 * * *
which is characterized by the first number x satisfying these constraints:
x mod 2 = 0
x mod 3 = 0
x mod 5 = 4
x mod 7 = 0
x mod 11 = 6
x mod 13 = 0
⇒ x mod 30030 = 2184
(computed using Sage function crt) and the mirror image of the above
2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2
* 3 * * 3 * * 3 * * 3 * * 3 * * 3
5 * * * * 5 * * * * 5 * * * * 5 *
* * 7 * * * * * * 7 * * * * * * 7
11 * * * * * * * * * * 11 * * * * *
* * * 13 * * * * * * * * * * * * 13
characterized by
y mod 2 = 0
y mod 3 = 1
y mod 5 = 0
y mod 7 = 5
y mod 11 = 0
y mod 13 = 10
⇒ y mod 30030 = 7810
which is greater, so 2184 … 2200 is the first sequence satisfying your requirements:
2184 = 23 × 3 × 7 × 13
2185 = 5 × 19 × 23
2186 = 2 × 1093
2187 = 37
2188 = 22 × 547
2189 = 11 × 199
2190 = 2 × 3 × 5 × 73
2191 = 7 × 313
2192 = 24 × 137
2193 = 3 × 17 × 43
2194 = 2 × 1097
2195 = 5 × 439
2196 = 22 × 32 × 61
2197 = 133
2198 = 2 × 7 × 157
2199 = 3 × 733
2200 = 23 × 52 × 11
Which should be in range for your loop. Actually it should have been enough to loop up to 30030, the product of the primes up to 17. So if your loop really did finish, but miss this sequence, then there must be a mistake somewhere and knowing the sequence might help you debug that.

I have a problem while solving a physical Problem in Python.
It is an ODE System. ODE System
At certain time points some dosis has to be injected to raise the value A.
I have to solve this with the Runge Kutta Method of 4th Order.
I thought i got it but an Calculation Error apperes every time.
RuntimeWarning: overflow encountered
After a short calc time the values get up to infinity....
Another problem is that in the 3th loop Tr gets a neg value what physicaly cant be.
Here's my code:
a = 10.
v = 8.
x = 0.8
p = 1.02
u1 = 0.2
u2 = 0.1
ur = 0.25
c = 0.0001
N_0 = a
T1_0 = 0.001
T2_0 = 0.0001
Tr_0 = 0.001
A_0 = 0.
t = 0.
h = 1.
while (t <= int(np.amax(time))):
for i in range(len(time)):
if t == time[i]:
A_0 = A_0 + dosis[i]
print('INITAL VALUE: ',' t =', t,' A =', A_0,' N =', N_0,' T1 =', T1_0,' T2 =', T2_0,' Tr =', Tr_0)
a1 = -(A_0) * (T1_0 + T2_0 + Tr_0)
b1 = -(N_0) + a - (N_0 * A_0 * ((T1_0 / (1. + u2 * T2_0)) + c))-(p * N_0 * A_0 * (T2_0 + c)) - (x * N_0 * A_0 *(Tr_0 + c))
c1 = -(T1_0) + ((v * N_0 * A_0) / (1. + ur * Tr_0)) * ((T1_0 / (1. + u2 * T2_0)) + c)
d1 = -(T2_0) + (p * ((v * N_0 * A_0) / (1. + ur * Tr_0)) * ((T2_0 + c) / (1. + u1 * (T1_0 / (1. + u2 * T2_0)))))
e1 = -(Tr_0) + (x * v * N_0 * A_0 * (Tr_0 + c))
A_1 = A_0 + (h / 2.) * a1
N_1 = N_0 + (h / 2.) * b1
T1_1 = T1_0 + (h / 2.) * c1
T2_1 = T2_0 + (h / 2.) * d1
Tr_1 = Tr_0 + (h / 2.) * e1
a2 = -(A_1) * (T1_1 + T2_1 + Tr_1)
b2 = -(N_1) + a - (N_1 * A_1 * ((T1_1 / (1. + u2 * T2_1)) + c))-(p * N_1 * A_1 * (T2_1 + c)) - (x * N_1 * A_1 *(Tr_1 + c))
c2 = -(T1_1) + ((v * N_1 * A_1) / (1. + ur * Tr_1)) * ((T1_1 / (1. + u2 * T2_1)) + c)
d2 = -(T2_1) + (p * ((v * N_1 * A_1) / (1. + ur * Tr_1)) * ((T2_1 + c) / (1. + u1 * (T1_1 / (1. + u2 * T2_1)))))
e2 = -(Tr_1) + (x * v * N_1 * A_1 * (Tr_1 + c))
A_2 = A_0 + (h / 2.) * a2
N_2 = N_0 + (h / 2.) * b2
T1_2 = T1_0 + (h / 2.) * c2
T2_2 = T2_0 + (h / 2.) * d2
Tr_2 = Tr_0 + (h / 2.) * e2
a3 = -(A_2) * (T1_2 + T2_2 + Tr_2)
b3 = -(N_2) + a - (N_2 * A_2 * ((T1_2 / (1. + u2 * T2_2)) + c))-(p * N_2 * A_2 * (T2_2 + c)) - (x * N_2 * A_2 *(Tr_2 + c))
c3 = -(T1_2) + ((v * N_2 * A_2) / (1. + ur * Tr_2)) * ((T1_2 / (1. + u2 * T2_2)) + c)
d3 = -(T2_2) + (p * ((v * N_2 * A_2) / (1. + ur * Tr_2)) * ((T2_2 + c) / (1. + u1 * (T1_2 / (1. + u2 * T2_2)))))
e3 = -(Tr_2) + (x * v * N_2 * A_2 * (Tr_2 + c))
A_3 = A_0 + h * a3
N_3 = N_0 + h * b3
T1_3 = T1_0 + h * c3
T2_3 = T2_0 + h * d3
Tr_3 = Tr_0 + h * e3
a4 = -(A_3) * (T1_3 + T2_3 + Tr_3)
b4 = -(N_3) + a - (N_3 * A_3 * ((T1_3 / (1. + u2 * T2_3)) + c))-(p * N_3 * A_3 * (T2_3 + c)) - (x * N_3 * A_3 *(Tr_3 + c))
c4 = -(T1_3) + ((v * N_3 * A_3) / (1. + ur * Tr_3)) * ((T1_3 / (1. + u2 * T2_3)) + c)
d4 = -(T2_3) + (p * ((v * N_3 * A_3) / (1. + ur * Tr_3)) * ((T2_3 + c) / (1. + u1 * (T1_3 / (1. + u2 * T2_3)))))
e4 = -(Tr_3) + (x * v * N_3 * A_3 * (Tr_3 + c))
t = t + h
A_0 = A_0 + (h / 6.) * (a1 + (2. * a2) + (2. * a3) + a4)
N_0 = N_0 + (h / 6.) * (b1 + (2. * b2) + (2. * b3) + b4)
T1_0 = T1_0 + (h / 6.) * (c1 + (2. * c2) + (2. * c3) + c4)
T2_0 = T2_0 + (h / 6.) * (d1 + (2. * d2) + (2. * d3) + d4)
Tr_0 = Tr_0 + (h / 6.) * (e1 + (2. * e2) + (2. * e3) + e4)
And here is the current output:
INITAL VALUE: t = 0.0 A = 0.0 N = 10.0 T1 = 0.001 T2 = 0.0001 Tr = 0.001
INITAL VALUE: t = 1.0 A = 0.1 N = 10.0 T1 = 0.0003750000000000001 T2 = 3.7500000000000003e-05 Tr = 0.0003750000000000001
INITAL VALUE: t = 2.0 A = 0.2975779058326524 N = 9.9799116753568 T1 = 0.09021366809218588 T2 = 0.029730294675718548 Tr = 0.04000932816912045
INITAL VALUE: t = 3.0 A = 0.20021726558830752 N = 9.428758582263455 T1 = 4.6119100465532386 T2 = 3.8633993244370335 Tr = -7.920033484370073
INITAL VALUE: t = 4.0 A = 40682939.2164535 N = 737615666179.137 T1 = -32.736202523709856 T2 = 265493.88168389443 Tr = -5887693774039.941
INITAL VALUE: t = 5.0 A = inf N = nan T1 = -inf T2 = inf Tr = -inf
INITAL VALUE: t = 6.0 A = nan N = nan T1 = nan T2 = nan Tr = nan
INITAL VALUE: t = 7.0 A = nan N = nan T1 = nan T2 = nan Tr = nan
INITAL VALUE: t = 8.0 A = nan N = nan T1 = nan T2 = nan Tr = nan
INITAL VALUE: t = 9.0 A = nan N = nan T1 = nan T2 = nan Tr = nan
INITAL VALUE: t = 10.0 A = nan N = nan T1 = nan T2 = nan Tr = nan
I hope anyone has a idea what could help me
Thanks for your Time!!!

I could fix the Problem finally.
But I have to put the Step size to h=0.001 so that it doesnt become an error.
This takes the programm to 3 hours of computing...
can I pimp the while loop to make it a bit faster?

I am trying to plot two solutions on the same graph while only changing the initial condition of these solutions. I want the initial conditions to be one value of y = 0 and another value of y = -pi/2. I am not sure how I get them to be on the same graph without copying and pasting everything over again and creating a new array.
import numpy as np
import matplotlib.pyplot as plt
t = 0.0
y = 0.0
u = 0.0
F = 1.073
Wd = 2*np.pi
w0 = 1.5*Wd
b = w0/4
ts =[]
ys =[]
h= 0.001
while (t <= 30):
m1 = u
k1 = (-w0**2)*np.sin(y) + u*(-2*b) + F*(w0**2)*np.cos(Wd*t)
m2 = u + (h / 2.) * k1
t_2 = t + (h / 2.)
y_2 = y +(h / 2.) * m1
u_2 = m2
k2 = (-w0**2)*np.sin(y_2) + u_2*(-2*b) + F*(w0**2)*np.cos(Wd*t_2)
m3 = u + (h / 2.) * k2
t_3 = t + (h / 2.)
y_3 = y + (h / 2.) * m2
u_3 = m3
k3 = (-w0**2)*np.sin(y_3) + u_3*(-2*b) + F*(w0**2)*np.cos(Wd*t_3)
m4 = u + h * k3
t_4 = t + h
y_4 = y + h * m3
u_4 = m4
k4 = (-w0**2)*np.sin(y_4) + u_4*(-2*b) + F*(w0**2)*np.cos(Wd*t_4)
t = t + h
y = y + (h / 6.) * (m1 + (2 * m2) + (2 * m3) + m4)
u = u + (h / 6.) * (k1 + (2 * k2) + (2 * k3) + k4)
ts.append(t)
ys.append(y)
plt.plot(ts,ys)
plt.xlabel('$t$',fontsize=18)
plt.ylabel('$\phi$',fontsize=18)
plt.axhline(y=0, color = 'black')
plt.show()

import numpy as np
import matplotlib.pyplot as plt
def plotit(y):
t = 0.0
#y = 0.0
u = 0.0
F = 1.073
Wd = 2*np.pi
w0 = 1.5*Wd
b = w0/4
ts =[]
ys =[]
h= 0.001
while (t <= 30):
m1 = u
k1 = (-w0**2)*np.sin(y) + u*(-2*b) + F*(w0**2)*np.cos(Wd*t)
m2 = u + (h / 2.) * k1
t_2 = t + (h / 2.)
y_2 = y +(h / 2.) * m1
u_2 = m2
k2 = (-w0**2)*np.sin(y_2) + u_2*(-2*b) + F*(w0**2)*np.cos(Wd*t_2)
m3 = u + (h / 2.) * k2
t_3 = t + (h / 2.)
y_3 = y + (h / 2.) * m2
u_3 = m3
k3 = (-w0**2)*np.sin(y_3) + u_3*(-2*b) + F*(w0**2)*np.cos(Wd*t_3)
m4 = u + h * k3
t_4 = t + h
y_4 = y + h * m3
u_4 = m4
k4 = (-w0**2)*np.sin(y_4) + u_4*(-2*b) + F*(w0**2)*np.cos(Wd*t_4)
t = t + h
y = y + (h / 6.) * (m1 + (2 * m2) + (2 * m3) + m4)
u = u + (h / 6.) * (k1 + (2 * k2) + (2 * k3) + k4)
ts.append(t)
ys.append(y)
plt.plot(ts,ys)
plt.xlabel('$t$',fontsize=18)
plt.ylabel('$\phi$',fontsize=18)
plt.axhline(y=0, color = 'black')
plotit(y=0)
plotit(y=-np.pi/2.0)
plt.show()