Euler beam, solving differential equation in python - python-3.x
I must solve the Euler Bernoulli differential beam equation which is:
w’’’’(x) = q(x)
and boundary conditions:
w(0) = w(l) = 0
and
w′′(0) = w′′(l) = 0
The beam is as shown on the picture below:
beam
The continious force q is 2N/mm.
I have to use shooting method and scipy.integrate.odeint() func.
I can't even manage to start as i do not understand how to write the differential equation as a system of equation
Can someone who understands solving of differential equations with boundary conditions in python please help!
Thanks :)
The shooting method
To solve the fourth order ODE BVP with scipy.integrate.odeint() using the shooting method you need to:
1.) Separate the 4th order ODE into 4 first order ODEs by substituting:
u = w
u1 = u' = w' # 1
u2 = u1' = w'' # 2
u3 = u2' = w''' # 3
u4 = u3' = w'''' = q # 4
2.) Create a function to carry out the derivation logic and connect that function to the integrate.odeint() like this:
function calc(u, x , q)
{
return [u[1], u[2], u[3] , q]
}
w = integrate.odeint(calc, [w(0), guess, w''(0), guess], xList, args=(q,))
Explanation:
We are sending the boundary value conditions to odeint() for x=0 ([w(0), w'(0) ,w''(0), w'''(0)]) which calls the function calc which returns the derivatives to be added to the current state of w. Note that we are guessing the initial boundary conditions for w'(0) and w'''(0) while entering the known w(0)=0 and w''(0)=0.
Addition of derivatives to the current state of w occurs like this:
# the current w(x) value is the previous value plus the current change of w in dx.
w(x) = w(x-dx) + dw/dx
# others are calculated the same
dw(x)/dx = dw(x-dx)/dx + d^2w(x)/dx^2
# etc.
This is why we are returning values [u[1], u[2], u[3] , q] instead of [u[0], u[1], u[2] , u[3]] from the calc function, because u[1] is the first derivative so we add it to w, etc.
3.) Now we are able to set up our shooting method. We will be sending different initial boundary values for w'(0) and w'''(0) to odeint() and then check the end result of the returned w(x) profile to determine how close w(L) and w''(L) got to 0 (the known boundary conditions).
The program for the shooting method:
# a function to return the derivatives of w
def returnDerivatives(u, x, q):
return [u[1], u[2], u[3], q]
# a shooting funtion which takes in two variables and returns a w(x) profile for x=[0,L]
def shoot(u2, u4):
# the number of x points to calculate integration -> determines the size of dx
# bigger number means more x's -> better precision -> longer execution time
xSteps = 1001
# length of the beam
L= 1.0 # 1m
xSpace = np.linspace(0, L, xSteps)
q = 0.02 # constant [N/m]
# integrate and return the profile of w(x) and it's derivatives, from x=0 to x=L
return odeint(returnDerivatives, [ 0, u2, 0, u4] , xSpace, args=(q,))
# the tolerance for our results.
tolerance = 0.01
# how many numbers to consider for u2 and u4 (the guess boundary conditions)
u2_u4_maxNumbers = 1327 # bigger number, better precision, slower program
# you can also divide into separate variables like u2_maxNum and u4_maxNum
# these are already tested numbers (the best results are somewhere in here)
u2Numbers = np.linspace(-0.1, 0.1, u2_u4_maxNumbers)
# the same as above
u4Numbers = np.linspace(-0.5, 0.5, u2_u4_maxNumbers)
# result list for extracted values of each w(x) profile => [u2Best, u4Best, w(L), w''(L)]
# which will help us determine if the w(x) profile is inside tolerance
resultList = []
# result list for each U (or w(x) profile) => [w(x), w'(x), w''(x), w'''(x)]
resultW = []
# start generating numbers for u2 and u4 and send them to odeint()
for u2 in u2Numbers:
for u4 in u4Numbers:
U = []
U = shoot(u2,u4)
# get only the last row of the profile to determine if it passes tolerance check
result = U[len(U)-1]
# only check w(L) == 0 and w''(L) == 0, as those are the known boundary cond.
if (abs(result[0]) < tolerance) and (abs(result[2]) < tolerance):
# if the result passed the tolerance check, extract some values from the
# last row of the w(x) profile which we will need later for comaprisons
resultList.append([u2, u4, result[0], result[2]])
# add the w(x) profile to the list of profiles that passed the tolerance
# Note: the order of resultList is the same as the order of resultW
resultW.append(U)
# go through the resultList (list of extracted values from last row of each w(x) profile)
for i in range(len(resultList)):
x = resultList[i]
# both boundary conditions are 0 for both w(L) and w''(L) so we will simply add
# the two absolute values to determine how much the sum differs from 0
y = abs(x[2]) + abs(x[3])
# if we've just started set the least difference to the current
if i == 0:
minNum = y # remember the smallest difference to 0
index = 0 # remember index of best profile
elif y < minNum:
# current sum of absolute values is smaller
minNum = y
index = i
# print out the integral for w(x) over the beam
sum = 0
for i in resultW[index]:
sum = sum + i[0]
print("The integral of w(x) over the beam is:")
print(sum/1001) # sum/xSteps
This outputs:
The integral of w(x) over the beam is:
0.000135085272117
To print out the best profile for w(x) that we found:
print(resultW[index])
which outputs something like:
# w(x) w'(x) w''(x) w'''(x)
[[ 0.00000000e+00 7.54147813e-04 0.00000000e+00 -9.80392157e-03]
[ 7.54144825e-07 7.54142917e-04 -9.79392157e-06 -9.78392157e-03]
[ 1.50828005e-06 7.54128237e-04 -1.95678431e-05 -9.76392157e-03]
...,
[ -4.48774290e-05 -8.14851572e-04 1.75726275e-04 1.01560784e-02]
[ -4.56921910e-05 -8.14670764e-04 1.85892353e-04 1.01760784e-02]
[ -4.65067671e-05 -8.14479780e-04 1.96078431e-04 1.01960784e-02]]
To double check the results from above we will also solve the ODE using the numerical method.
The numerical method
To solve the problem using the numerical method we first need to solve the differential equations. We will get four constants which we need to find with the help of the boundary conditions. The boundary conditions will be used to form a system of equations to help find the necessary constants.
For example:
w’’’’(x) = q(x);
means that we have this:
d^4(w(x))/dx^4 = q(x)
Since q(x) is constant after integrating we have:
d^3(w(x))/dx^3 = q(x)*x + C
After integrating again:
d^2(w(x))/dx^2 = q(x)*0.5*x^2 + C*x + D
After another integration:
dw(x)/dx = q(x)/6*x^3 + C*0.5*x^2 + D*x + E
And finally the last integration yields:
w(x) = q(x)/24*x^4 + C/6*x^3 + D*0.5*x^2 + E*x + F
Then we take a look at the boundary conditions (now we have expressions from above for w''(x) and w(x)) with which we make a system of equations to solve the constants.
w''(0) => 0 = q(x)*0.5*0^2 + C*0 + D
w''(L) => 0 = q(x)*0.5*L^2 + C*L + D
This gives us the constants:
D = 0 # from the first equation
C = - 0.01 * L # from the second (after inserting D=0)
After repeating the same for w(0)=0 and w(L)=0 we obtain:
F = 0 # from first
E = 0.01/12.0 * L^3 # from second
Now, after we have solved the equation and found all of the integration constants we can make the program for the numerical method.
The program for the numerical method
We will make a FOR loop to go through the entire beam for every dx at a time and sum up (integrate) w(x).
L = 1.0 # in meters
step = 1001.0 # how many steps to take (dx)
q = 0.02 # constant [N/m]
integralOfW = 0.0; # instead of w(0) enter the boundary condition value for w(0)
result = []
for i in range(int(L*step)):
x= i/step
w = (q/24.0*pow(x,4) - 0.02/12.0*pow(x,3) + 0.01/12*pow(L,3)*x)/step # current w fragment
# add up fragments of w for integral calculation
integralOfW += w
# add current value of w(x) to result list for plotting
result.append(w*step);
print("The integral of w(x) over the beam is:")
print(integralOfW)
which outputs:
The integral of w(x) over the beam is:
0.00016666652805511192
Now to compare the two methods
Result comparison between the shooting method and the numerical method
The integral of w(x) over the beam:
Shooting method -> 0.000135085272117
Numerical method -> 0.00016666652805511192
That's a pretty good match, now lets see check the plots:
From the plots it's even more obvious that we have a good match and that the results of the shooting method are correct.
To get even better results for the shooting method increase xSteps and u2_u4_maxNumbers to bigger numbers and you can also narrow down the u2Numbers and u4Numbers to the same set size but a smaller interval (around the best results from previous program runs). Keep in mind that setting xSteps and u2_u4_maxNumbers too high will cause your program to run for a very long time.
You need to transform the ODE into a first order system, setting u0=w one possible and usually used system is
u0'=u1,
u1'=u2,
u2'=u3,
u3'=q(x)
This can be implemented as
def ODEfunc(u,x): return [ u[1], u[2], u[3], q(x) ]
Then make a function that shoots with experimental initial conditions and returns the components of the second boundary condition
def shoot(u01, u03): return odeint(ODEfunc, [0, u01, 0, u03], [0, l])[-1,[0,2]]
Now you have a function of two variables with two components and you need to solve this 2x2 system with the usual methods. As the system is linear, the shooting function is linear as well and you only need to find the coefficients and solve the resulting linear system.
Related
Canonical correlation analysis on covariance matrices instead of raw data
Due to privacy issues I don't have the original raw data matrices, but instead I can have covariance matrices of x and y (x'x, y'y, x'y) datasets or the correlation matrix between the two of them (or any other sort of matrix that is not the original data matrix). I need to find a way to apply canonical correlation analysis directly on those matrices. Browsing the net I didn't find any solution to my problem. I want to ask if there is already an implemented algorithm able to work on these data, in R would be the best, but other languages are ok Example from the tutorial in R for cca package: (https://stats.idre.ucla.edu/r/dae/canonical-correlation-analysis/) mm <- read.csv("https://stats.idre.ucla.edu/stat/data/mmreg.csv") colnames(mm) <- c("Control", "Concept", "Motivation", "Read", "Write", "Math", "Science", "Sex") You divide the dataset into x and y : x <- mm[, 1:3] y <- mm[, 4:8] Then the function works taking as input these two datasets: cc(x,y) (note that the function standardizes the data by itself). What I want to know if there is a way to perform cca starting by centering matrices around the mean: x = scale(x, scale = F) y = scale(Y, scale = F) An then computing the covariance matrices x'x, y'y, xy'xy: cvx = crossprod(x); cvy = crossprod(y); cvxy = crossprod(x,y) And the algorithm should take in input those matrices to work and compute the canonical variates and correlation coefficients like: f(cvx, cvy, cvxy) In this article is written a solution starting from covariance matrices for example, but I don't if it is just theory or someone has actually implemented it http://graphics.stanford.edu/courses/cs233-20-spring/ReferencedPapers/CCA_Weenik.pdf I hope to be exhaustive enough!
In short: the correlation are using internally in most (probably all) CCA analysis. In long: you will need to work out a bit how to do that depending on the case. Let me show you below a example. What is Canonical-correlation analysis (CCA)? Canonical-correlation analysis (CCA): help you to identify the best possible linear relations you could create between two datasets. See wikipedia. See references for examples. I will follow this post for the data and use libraries. Set up libraries, upload the data, select some variables, removed nans, estandarizad the data. import pandas as pd import numpy as np df = pd.read_csv('2016 School Explorer.csv') # choose relevant features df = df[['Rigorous Instruction %', 'Collaborative Teachers %', 'Supportive Environment %', 'Effective School Leadership %', 'Strong Family-Community Ties %', 'Trust %','Average ELA Proficiency', 'Average Math Proficiency']] df.corr() # drop missing values df = df.dropna() # separate X and Y groups X = df[['Rigorous Instruction %', 'Collaborative Teachers %', 'Supportive Environment %', 'Effective School Leadership %', 'Strong Family-Community Ties %', 'Trust %' ]] Y = df[['Average ELA Proficiency', 'Average Math Proficiency']] for col in X.columns: X[col] = X[col].str.strip('%') X[col] = X[col].astype('int') # Standardise the data from sklearn.preprocessing import StandardScaler sc = StandardScaler(with_mean=True, with_std=True) X_sc = sc.fit_transform(X) Y_sc = sc.fit_transform(Y) What are Correlations? I am pausing here to talk about the idea and the implementation. First of all CCA analysis is naturally based on that idea however for the numerical resolution there are different ways to do that. The definition from wikipedia. See the pic: I am talking about this because I am going to modify a function of that library and I want you to really pay attention to that. See Eq 4 in Bilenko et al 2016. But you need to be really careful with how to place that well. Notice that strictly speaking you do not need the correlations. Let me show the the function that is working out that expression, in pyrrcca library here def kcca(data, reg=0., numCC=None, kernelcca=True, ktype='linear', gausigma=1.0, degree=2): """Set up and solve the kernel CCA eigenproblem """ if kernelcca: kernel = [_make_kernel(d, ktype=ktype, gausigma=gausigma, degree=degree) for d in data] else: kernel = [d.T for d in data] nDs = len(kernel) nFs = [k.shape[0] for k in kernel] numCC = min([k.shape[1] for k in kernel]) if numCC is None else numCC # Get the auto- and cross-covariance matrices crosscovs = [np.dot(ki, kj.T) for ki in kernel for kj in kernel] # Allocate left-hand side (LH) and right-hand side (RH): LH = np.zeros((sum(nFs), sum(nFs))) RH = np.zeros((sum(nFs), sum(nFs))) # Fill the left and right sides of the eigenvalue problem for i in range(nDs): RH[sum(nFs[:i]) : sum(nFs[:i+1]), sum(nFs[:i]) : sum(nFs[:i+1])] = (crosscovs[i * (nDs + 1)] + reg * np.eye(nFs[i])) for j in range(nDs): if i != j: LH[sum(nFs[:j]) : sum(nFs[:j+1]), sum(nFs[:i]) : sum(nFs[:i+1])] = crosscovs[nDs * j + i] LH = (LH + LH.T) / 2. RH = (RH + RH.T) / 2. maxCC = LH.shape[0] r, Vs = eigh(LH, RH, eigvals=(maxCC - numCC, maxCC - 1)) r[np.isnan(r)] = 0 rindex = np.argsort(r)[::-1] comp = [] Vs = Vs[:, rindex] for i in range(nDs): comp.append(Vs[sum(nFs[:i]):sum(nFs[:i + 1]), :numCC]) return comp The output from here the Canonical Covariates (comp), those are a and b in Eq4 in Bilenko et al 2016. I just want you to pay attention to this: # Get the auto- and cross-covariance matrices crosscovs = [np.dot(ki, kj.T) for ki in kernel for kj in kernel] That is exactly the place where that operation happens. Notice that is not exactly the definition from Wikipedia, however is mathematically equivalent. Calculation of the correlations I am going to calculate the correlations as in wikipedia but later I will modify that function, so it is going to bit a couple of details, to make sure this is answering the original questions clearly. # Get the auto- and cross-covariance matrices crosscovs = [np.dot(ki, kj.T) for ki in kernel for kj in kernel] print(crosscovs) [array([[1217. , 746.04496925, 736.14178336, 575.21073838, 517.52474332, 641.25363806], [ 746.04496925, 1217. , 732.6297358 , 1094.38480773, 572.95747557, 1073.96490387], [ 736.14178336, 732.6297358 , 1217. , 559.5753228 , 682.15312862, 774.36607617], [ 575.21073838, 1094.38480773, 559.5753228 , 1217. , 495.79248754, 1047.31981248], [ 517.52474332, 572.95747557, 682.15312862, 495.79248754, 1217. , 632.75610906], [ 641.25363806, 1073.96490387, 774.36607617, 1047.31981248, 632.75610906, 1217. ]]), array([[367.74099904, 391.82683717], [348.78464015, 355.81358426], [440.88117453, 514.22183796], [326.32173163, 311.97282341], [216.32441793, 269.72859023], [288.27601974, 304.20209135]]), array([[367.74099904, 348.78464015, 440.88117453, 326.32173163, 216.32441793, 288.27601974], [391.82683717, 355.81358426, 514.22183796, 311.97282341, 269.72859023, 304.20209135]]), array([[1217. , 1139.05867099], [1139.05867099, 1217. ]])] Have a look to the output, I am going to change that a bit so is between -1 and 1. Again, this modification is minor. Following the definition from wikipedia the authors just care about the numerator, and I am just going to include now the denominator. max_unit = 0 for crosscov in crosscovs: max_unit = np.max([max_unit,np.max(crosscov)]) """I normalice""" crosscovs_new = [] for crosscov in crosscovs: crosscovs_new.append(crosscov/max_unit) print(crosscovs_new) [array([[1. , 0.6130197 , 0.60488232, 0.47264646, 0.4252463 , 0.52691342], [0.6130197 , 1. , 0.6019965 , 0.89924799, 0.47079497, 0.88246911], [0.60488232, 0.6019965 , 1. , 0.45979895, 0.56052024, 0.63629094], [0.47264646, 0.89924799, 0.45979895, 1. , 0.40738906, 0.86057503], [0.4252463 , 0.47079497, 0.56052024, 0.40738906, 1. , 0.51993107], [0.52691342, 0.88246911, 0.63629094, 0.86057503, 0.51993107, 1. ]]), array([[0.30217009, 0.32196125], [0.28659379, 0.29236942], [0.36226884, 0.42253232], [0.26813618, 0.25634579], [0.17775219, 0.22163401], [0.2368743 , 0.24996063]]), array([[0.30217009, 0.28659379, 0.36226884, 0.26813618, 0.17775219, 0.2368743 ], [0.32196125, 0.29236942, 0.42253232, 0.25634579, 0.22163401, 0.24996063]]), array([[1. , 0.93595618], [0.93595618, 1. ]])] For clarity I will show you in a slightly different way to see that the numbers and indeed correlations of the original data. df.corr() Average ELA Proficiency Average Math Proficiency Average ELA Proficiency 1.000000 0.935956 Average Math Proficiency 0.935956 1.000000 That is a way to see as well the variables name. I just want to show you that the numbers above make sense, and are what you are calling correlations. Calculations of the CCA So now I will just modify a bit the function kcca from pyrrcca. The idea is for that function to accept the previously calculated correlations matrixes. from rcca import _make_kernel from scipy.linalg import eigh def kcca_working(data, reg=0., numCC=None, kernelcca=False, ktype='linear', gausigma=1.0, degree=2, crosscovs=None): """Set up and solve the kernel CCA eigenproblem """ if kernelcca: kernel = [_make_kernel(d, ktype=ktype, gausigma=gausigma, degree=degree) for d in data] else: kernel = [d.T for d in data] nDs = len(kernel) nFs = [k.shape[0] for k in kernel] numCC = min([k.shape[1] for k in kernel]) if numCC is None else numCC if crosscovs is None: # Get the auto- and cross-covariance matrices crosscovs = [np.dot(ki, kj.T) for ki in kernel for kj in kernel] # Allocate left-hand side (LH) and right-hand side (RH): LH = np.zeros((sum(nFs), sum(nFs))) RH = np.zeros((sum(nFs), sum(nFs))) # Fill the left and right sides of the eigenvalue problem for i in range(nDs): RH[sum(nFs[:i]) : sum(nFs[:i+1]), sum(nFs[:i]) : sum(nFs[:i+1])] = (crosscovs[i * (nDs + 1)] + reg * np.eye(nFs[i])) for j in range(nDs): if i != j: LH[sum(nFs[:j]) : sum(nFs[:j+1]), sum(nFs[:i]) : sum(nFs[:i+1])] = crosscovs[nDs * j + i] LH = (LH + LH.T) / 2. RH = (RH + RH.T) / 2. maxCC = LH.shape[0] r, Vs = eigh(LH, RH, eigvals=(maxCC - numCC, maxCC - 1)) r[np.isnan(r)] = 0 rindex = np.argsort(r)[::-1] comp = [] Vs = Vs[:, rindex] for i in range(nDs): comp.append(Vs[sum(nFs[:i]):sum(nFs[:i + 1]), :numCC]) return comp, crosscovs Let run the function: comp, crosscovs = kcca_working([X_sc, Y_sc], reg=0., numCC=2, kernelcca=False, ktype='linear', gausigma=1.0, degree=2, crosscovs = crosscovs_new) print(comp) [array([[-0.00375779, 0.0078263 ], [ 0.00061439, -0.00357358], [-0.02054012, -0.0083491 ], [-0.01252477, 0.02976148], [ 0.00046503, -0.00905069], [ 0.01415084, -0.01264106]]), array([[ 0.00632283, 0.05721601], [-0.02606459, -0.05132531]])] So I take the original function, and make possible to introduce the correlations, I also output that just for checking. I print the Canonical Covariates (comp), those are a and b in Eq4 in Bilenko et al 2016. Comparing results Now I am going to compare results from the original and the modified function. I will show you that the results are equivalent. I could obtain the original results this way. With crosscovs = None, so it is calculated as originally, instead of us introducing it: comp, crosscovs = kcca_working([X_sc, Y_sc], reg=0., numCC=2, kernelcca=False, ktype='linear', gausigma=1.0, degree=2, crosscovs = None) print(comp) [array([[-0.13109264, 0.27302457], [ 0.02143325, -0.12466608], [-0.71655285, -0.2912628 ], [-0.43693303, 1.03824477], [ 0.01622265, -0.31573818], [ 0.49365965, -0.44098996]]), array([[ 0.2205752 , 1.99601077], [-0.90927705, -1.79051045]])] I print the Canonical Covariates (comp), those are a' and b' in Eq4 in Bilenko et al 2016. a, b and a', b' are different but they are just different in the scale, so for all purpose they are equivalent. This is because of the correlations definitions. To show that let me pick up numbers from each case and calculate the ratio: print(0.00061439/-0.00375779) -0.16349769412340764 print(0.02143325/-0.13109264) -0.16349697435340382 They are the same result. When that is modified you could just build in the top of that. References: Cool post with example and explanations in Python, using library pyrcca: https://towardsdatascience.com/understanding-how-schools-work-with-canonical-correlation-analysis-4c9a88c6b913 Bilenko, Natalia Y., and Jack L. Gallant. "Pyrcca: regularized kernel canonical correlation analysis in python and its applications to neuroimaging." Frontiers in neuroinformatics 10 (2016): 49. Paper in which pyrcca is explained: https://www.frontiersin.org/articles/10.3389/fninf.2016.00049/full
Solving vector second order differential equation while indexing into an array
I'm attempting to solve the differential equation: m(t) = M(x)x'' + C(x, x') + B x' where x and x' are vectors with 2 entries representing the angles and angular velocity in a dynamical system. M(x) is a 2x2 matrix that is a function of the components of theta, C is a 2x1 vector that is a function of theta and theta' and B is a 2x2 matrix of constants. m(t) is a 2*1001 array containing the torques applied to each of the two joints at the 1001 time steps and I would like to calculate the evolution of the angles as a function of those 1001 time steps. I've transformed it to standard form such that : x'' = M(x)^-1 (m(t) - C(x, x') - B x') Then substituting y_1 = x and y_2 = x' gives the first order linear system of equations: y_2 = y_1' y_2' = M(y_1)^-1 (m(t) - C(y_1, y_2) - B y_2) (I've used theta and phi in my code for x and y) def joint_angles(theta_array, t, torques, B): phi_1 = np.array([theta_array[0], theta_array[1]]) phi_2 = np.array([theta_array[2], theta_array[3]]) def M_func(phi): M = np.array([[a_1+2.*a_2*np.cos(phi[1]), a_3+a_2*np.cos(phi[1])],[a_3+a_2*np.cos(phi[1]), a_3]]) return np.linalg.inv(M) def C_func(phi, phi_dot): return a_2 * np.sin(phi[1]) * np.array([-phi_dot[1] * (2. * phi_dot[0] + phi_dot[1]), phi_dot[0]**2]) dphi_2dt = M_func(phi_1) # (torques[:, t] - C_func(phi_1, phi_2) - B # phi_2) return dphi_2dt, phi_2 t = np.linspace(0,1,1001) initial = theta_init[0], theta_init[1], dtheta_init[0], dtheta_init[1] x = odeint(joint_angles, initial, t, args = (torque_array, B)) I get the error that I cannot index into torques using the t array, which makes perfect sense, however I am not sure how to have it use the current value of the torques at each time step. I also tried putting odeint command in a for loop and only evaluating it at one time step at a time, using the solution of the function as the initial conditions for the next loop, however the function simply returned the initial conditions, meaning every loop was identical. This leads me to suspect I've made a mistake in my implementation of the standard form but I can't work out what it is. It would be preferable however to not have to call the odeint solver in a for loop every time, and rather do it all as one. If helpful, my initial conditions and constant values are: theta_init = np.array([10*np.pi/180, 143.54*np.pi/180]) dtheta_init = np.array([0, 0]) L_1 = 0.3 L_2 = 0.33 I_1 = 0.025 I_2 = 0.045 M_1 = 1.4 M_2 = 1.0 D_2 = 0.16 a_1 = I_1+I_2+M_2*(L_1**2) a_2 = M_2*L_1*D_2 a_3 = I_2 Thanks for helping!
The solver uses an internal stepping that is problem adapted. The given time list is a list of points where the internal solution gets interpolated for output samples. The internal and external time lists are in no way related, the internal list only depends on the given tolerances. There is no actual natural relation between array indices and sample times. The translation of a given time into an index and construction of a sample value from the surrounding table entries is called interpolation (by a piecewise polynomial function). Torque as a physical phenomenon is at least continuous, a piecewise linear interpolation is the easiest way to transform the given function value table into an actual continuous function. Of course one also needs the time array. So use numpy.interp1d or the more advanced routines of scipy.interpolate to define the torque function that can be evaluated at arbitrary times as demanded by the solver and its integration method.
Scipy Optimize Basin Hopping fails
I am working on a cost minimizing function to help with allocation/weights in a portfolio of stocks. I have the following code for the "Objective Function". This works when I tried it with 15 variables(stocks). However, when I tried it with 55 stocks it failed. I have tried it with a smaller sample of stocks(15) and it works fine. The num_assets variable below is the number of stocks in the portfolio. def get_metrics(weights): weights = np.array(weights) returnsR = np.dot(returns_annualR, weights ) volatilityR = np.sqrt(np.dot(weights.T, np.dot(cov_matrixR, weights))) sharpeR = returnsR / volatilityR drawdownR = np.multiply(weights, dailyDD).sum(axis=1, skipna = True).min() drawdownR = f(drawdownR) calmarR = returnsR / drawdownR results = (sharpeR * 0.3) + (calmarR * 0.7) return np.array([returnsR, volatilityR, sharpeR, drawdownR, calmarR, results]) def objective(weights): # the number 5 is the index from the get_metrics array return get_metrics(weights)[5] * -1 def check_sum(weights): #return 0 if sum of the weights is 1 return np.sum(weights)-1 bound = (0.0,1.0) bnds = tuple(bound for x in range (num_assets)) bx = list(bnds) """ Custom step-function """ class RandomDisplacementBounds(object): """random displacement with bounds: see: https://stackoverflow.com/a/21967888/2320035 Modified! (dropped acceptance-rejection sampling for a more specialized approach) """ def __init__(self, xmin, xmax, stepsize=0.5): self.xmin = xmin self.xmax = xmax self.stepsize = stepsize def __call__(self, x): """take a random step but ensure the new position is within the bounds """ min_step = np.maximum(self.xmin - x, -self.stepsize) max_step = np.minimum(self.xmax - x, self.stepsize) random_step = np.random.uniform(low=min_step, high=max_step, size=x.shape) xnew = x + random_step return xnew bounded_step = RandomDisplacementBounds(np.array([b[0] for b in bx]), np.array([b[1] for b in bx])) minimizer_kwargs = {"method":"L-BFGS-B", "bounds": bnds} globmin = sco.basinhopping(objective, x0=num_assets*[1./num_assets], minimizer_kwargs=minimizer_kwargs, take_step=bounded_step, disp=True) The output should be an array of numbers that add up to 1 or 100%. However, this is not happening.
This function is a failure on my end as well. It failed to choose values which were lower -- ie., regardless of output from optimization function (negative or positive), it persisted until the parameter I was optimizing was as bad as it could possibly be. I suspect that since the function violates function encapsulation and relies on "function attributes" to adjust stepsize, the developer may not have respected encapsulated function scope elsewhere, and surprising behavior is happening as a result. Regardless, in terms of theory, anything else is just a (dubious) estimated numerical partial second derivative (numerical Hessian, or "estimated curvature" for us mere mortals) based "performance" "gain", which reduces to a randomly-biased annealer in discrete, chaotic (phase space, continuous) or mixed (continuous and discrete) search spaces with volatile curvatures or planar areas (due to numerical underflow and loss of precision). Anyways, import the following: scipy.optimize.dual_anneal dual anneal
Karatsuba recursive code is not working correctly
I want to implement Karatsuba multiplication algorithm in python.But it is not working completely. The code is not working for the values of x or y greater than 999.For inputs below 1000,the program is showing correct result.It is also showing correct results on base cases. #Karatsuba method of multiplication. f = int(input()) #Inputs e = int(input()) def prod(x,y): r = str(x) t = str(y) lx = len(r) #Calculation of Lengths ly = len(t) #Base Case if(lx == 1 or ly == 1): return x*y #Other Case else: o = lx//2 p = ly//2 a = x//(10*o) #Calculation of a,b,c and d. b = x-(a*10*o) #The Calculation is done by c = y//(10*p) #calculating the length of x and y d = y-(c*10*p) #and then dividing it by half. #Then we just remove the half of the digits of the no. return (10**o)*(10**p)*prod(a,c)+(10**o)*prod(a,d)+(10**p)*prod(b,c)+prod(b,d) print(prod(f,e)) I think there are some bugs in the calculation of a,b,c and d.
a = x//(10**o) b = x-(a*10**o) c = y//(10**p) d = y-(c*10**p) You meant 10 to the power of, but wrote 10 multiplied with. You should train to find those kinds of bugs yourself. There are multiple ways to do that: Do the algorithm manually on paper for specific inputs, then step through your code and see if it matches Reduce the code down to sub-portions and see if their expected value matches the produced value. In your case, check for every call of prod() what the expected output would be and what it produced, to find minimal input values that produce erroneous results. Step through the code with the debugger. Before every line, think about what the result should be and then see if the line produces that result.
Generate a random point on an elliptical curve
I'm writing a program which randomly chooses two integers within a certain interval. I also wrote a class (which I didn't add below) which uses two numbers 'a' and 'b' and creates an elliptical curve of the form: y^2 = x^3 + ax + b I've written the following to create the two random numbers. def numbers(): n = 1 while n>0: a = random.randint(-100,100) b = random.randint(-100,100) if -16 * (4 * a ** 3 + 27 * b ** 2) != 0: result = [a,b] return result n = n+1 Now I would like to generate a random point on this elliptical curve. How do I do that?
The curve has an infinite length, as for every y ϵ ℝ there is at least one x ϵ ℝ so that (x, y) is on the curve. So if we speak of a random point on the curve we cannot hope to have a homogeneous distribution of the random point over the whole curve. But if that is not important, you could take a random value for y within some range, and then calculate the roots of the following function: f(x) = x3 + ax + b - y2 This will result in three roots, of which possibly two are complex (not real numbers). You can take a random real root from that. This will be the x coordinate for the random point. With the help of numpy, getting the roots is easy, so this is the function for getting a random point on the curve, given values for a and b: def randomPoint(a, b): y = random.randint(-100,100) # Get roots of: f(x) = x^3 + ax + b - y^2 roots = numpy.roots([1, 0, a, b - y**2]) # 3 roots are returned, but ignore potential complex roots # At least one will be real roots = [val.real for val in roots if val.imag == 0] # Choose a random root among those real root(s) x = random.choice(roots) return [x, y] See it run on repl.it.