def get_position(): # type: () -> PositionType
T = h5_dict['State Vectors Times'] # in seconds relative to ref time
T += ref_time_offset
Pos = h5_dict['ECEF Satellite Position']
Vel = h5_dict['ECEF Satellite Velocity'] # for cross validation
# Let's perform polynomial fitting for the position with cross validation for overfitting checks
deg = 1
prev_vel_error = numpy.inf
P_x, P_y, P_z = None, None, None
while deg < min(6, Pos.shape[0]):
# fit position
P_x = polynomial.polyfit(T, Pos[:, 0], deg=deg)
P_y = polynomial.polyfit(T, Pos[:, 1], deg=deg)
P_z = polynomial.polyfit(T, Pos[:, 2], deg=deg)
# extract estimated velocities
Vel_est = numpy.stack(
(polynomial.polyval(T, polynomial.polyder(P_x)),
polynomial.polyval(T, polynomial.polyder(P_y)),
polynomial.polyval(T, polynomial.polyder(P_z))), axis=-1)
# check our velocity error
vel_err = Vel_est - Vel
cur_vel_error = numpy.sum((vel_err*vel_err))
deg += 1
# stop if the error is not smaller than at the previous step
if cur_vel_error >= prev_vel_error:
break
return PositionType(ARPPoly=XYZPolyType(X=P_x, Y=P_y, Z=P_z))
def make_Zernike_grads(mask, roi = None, max_order = 100, return_grids = False, return_basis = False, yx_bounds = None, test = False):
if return_grids :
basis, basis_grid, y, x = make_Zernike_basis(mask, roi, max_order, return_grids, yx_bounds, test)
else :
basis = make_Zernike_basis(mask, roi, max_order, return_grids, yx_bounds, test)
# calculate the x and y gradients
from numpy.polynomial import polynomial as P
# just a list of [(grad_ss, grad_fs), ...] where the grads are in a polynomial basis
grads = [ (P.polyder(b, axis=0), P.polyder(b, axis=1)) for b in basis ]
if return_grids :
# just a list of [(grad_ss, grad_fs), ...] where the grads are evaluated on a y, x grid
grad_grids = [(P.polygrid2d(y, x, g[0]), P.polygrid2d(y, x, g[1])) for g in grads]
if return_basis :
return grads, grad_grids, basis, basis_grid
else :
return grads, grad_grids
else :
if return_basis :
return grads, basis
else :
return grads
def acceleration_at(self, t):
vel_coef_x = poly.polyder(self.coef_x)
vel_coef_y = poly.polyder(self.coef_y)
acc_coef_x = poly.polyder(vel_coef_x)
acc_coef_y = poly.polyder(vel_coef_y)
acc_x = poly.polyval(t, acc_coef_x)
acc_y = poly.polyval(t, acc_coef_y)
return (acc_x, acc_y)
def constrnp(pars):
if orderp > 0:
return (-1) * Arange**(-ordern - 1) * polyval(
Arange, polyder(pars[1:ordern + 1], m=1)) + polyval(
Arange, polyder(pars[ordern + 1:], m=1))
else:
return (-1) * Arange**(-ordern - 1) * polyval(
Arange, polyder(pars[1:ordern + 1], m=1))
def get_der_rational(num, den):
dnum = poly.polyder(num)
dden = poly.polyder(den)
dnum_den = poly.polymul(dnum, den)
dden_num = poly.polymul(num, dden)
num_new = poly.polysub(dnum_den, dden_num)
den_new = poly.polymul(den, den)
return (num_new, den_new)
def test_polyder_axis(self):
# check that axis keyword works
c2d = np.random.random((3, 4))
tgt = np.vstack([poly.polyder(c) for c in c2d.T]).T
res = poly.polyder(c2d, axis=0)
assert_almost_equal(res, tgt)
tgt = np.vstack([poly.polyder(c) for c in c2d])
res = poly.polyder(c2d, axis=1)
assert_almost_equal(res, tgt)
def test_polyder_axis(self):
# check that axis keyword works
c2d = np.random.random((3, 4))
tgt = np.vstack([poly.polyder(c) for c in c2d.T]).T
res = poly.polyder(c2d, axis=0)
assert_almost_equal(res, tgt)
tgt = np.vstack([poly.polyder(c) for c in c2d])
res = poly.polyder(c2d, axis=1)
assert_almost_equal(res, tgt)
def getXs(cxy, x, y):
f = polyval2d(x, y, cxy)
fx = polyval2d(x, y, polyder(cxy, axis=0))
fy = polyval2d(x, y, polyder(cxy, axis=1))
fxx = polyval2d(x, y, polyder(polyder(cxy, axis=0), axis=0))
fxy = polyval2d(x, y, polyder(polyder(cxy, axis=0), axis=1))
fyy = polyval2d(x, y, polyder(polyder(cxy, axis=1), axis=1))
return f, fx, fy, fxx, fxy, fyy
def _set_sicd(self, the_sicd):
# type : (SICDType) -> None
if the_sicd is None:
self._sicd = None
return
if not isinstance(the_sicd, SICDType):
raise TypeError(
'the_sicd must be an insatnce of SICDType, got type {}'.format(
type(the_sicd)))
self._sicd = the_sicd
row_delta_kcoa_poly, self._row_fft_sgn = _get_deskew_params(
the_sicd, 0)
col_delta_kcoa_poly, self._col_fft_sgn = _get_deskew_params(
the_sicd, 1)
if self.dimension == 0:
self._delta_kcoa_poly_axis = row_delta_kcoa_poly
delta_kcoa_poly_int = polynomial.polyint(row_delta_kcoa_poly,
axis=0)
self._delta_kcoa_poly_off_axis = _add_poly(
-polynomial.polyder(delta_kcoa_poly_int, axis=1),
col_delta_kcoa_poly)
else:
self._delta_kcoa_poly_axis = col_delta_kcoa_poly
delta_kcoa_poly_int = polynomial.polyint(col_delta_kcoa_poly,
axis=1)
self._delta_kcoa_poly_off_axis = _add_poly(
-polynomial.polyder(delta_kcoa_poly_int, axis=0),
row_delta_kcoa_poly)
self._row_shift = the_sicd.ImageData.SCPPixel.Row - the_sicd.ImageData.FirstRow
self._row_mult = the_sicd.Grid.Row.SS
self._col_shift = the_sicd.ImageData.SCPPixel.Col - the_sicd.ImageData.FirstCol
self._col_mult = the_sicd.Grid.Col.SS
self._row_pad = max(
1., 1. / (the_sicd.Grid.Row.SS * the_sicd.Grid.Row.ImpRespBW))
self._row_weight = the_sicd.Grid.Row.WgtFunct.copy(
) if the_sicd.Grid.Row.WgtFunct is not None else None
self._col_pad = max(
1., 1. / (the_sicd.Grid.Col.SS * the_sicd.Grid.Col.ImpRespBW))
self._col_weight = the_sicd.Grid.Col.WgtFunct.copy(
) if the_sicd.Grid.Col.WgtFunct is not None else None
self._is_normalized = is_normalized(the_sicd, self.dimension)
self._is_not_skewed_row = is_not_skewed(the_sicd, 0)
self._is_not_skewed_col = is_not_skewed(the_sicd, 1)
self._is_uniform_weight_row = is_uniform_weight(the_sicd, 0)
self._is_uniform_weight_col = is_uniform_weight(the_sicd, 1)
def grad(self, point):
'''
Evaluates the gradient of the polynomial at the given point.
Parameters
----------
point : array-like
the point at which to evaluate the polynomial
Returns
-------
out : ndarray
Gradient of the polynomial at the given point.
'''
super(MultiPower, self).__call__(point)
out = np.empty(self.dim, dtype="complex_")
if self.jac is None:
jac = list()
for i in range(self.dim):
jac.append(poly.polyder(self.coeff, axis=i))
self.jac = jac
spot = 0
for i in self.jac:
out[spot] = polyvalnd(point, i)
spot += 1
return out
def deskewmem(input_data,
DeltaKCOAPoly,
dim0_coords_m,
dim1_coords_m,
dim,
fft_sgn=-1):
"""Performs deskew (centering of the spectrum on zero frequency) on a complex dataset.
INPUTS:
input_data: Complex FFT Data
DeltaKCOAPoly: Polynomial that describes center of frequency support of data.
dim0_coords_m: Coordinate of each "row" in dimension 0
dim1_coords_m: Coordinate of each "column" in dimension 1
dim: Dimension over which to perform deskew
fft_sgn: FFT sign required to transform data to spatial frequency domain
OUTPUTS:
output_data: Deskewed data
new_DeltaKCOAPoly: Frequency support shift in the non-deskew dimension
caused by the deskew.
"""
# Integrate DeltaKCOA polynomial (in meters) to form new polynomial DeltaKCOAPoly_int
DeltaKCOAPoly_int = polynomial.polyint(DeltaKCOAPoly, axis=dim)
# New DeltaKCOAPoly in other dimension will be negative of the derivative of
# DeltaKCOAPoly_int in other dimension (assuming it was zero before).
new_DeltaKCOAPoly = -polynomial.polyder(DeltaKCOAPoly_int, axis=dim - 1)
# Apply phase adjustment from polynomial
[dim1_coords_m_2d, dim0_coords_m_2d] = np.meshgrid(dim1_coords_m,
dim0_coords_m)
output_data = np.multiply(
input_data,
np.exp(1j * fft_sgn * 2 * np.pi * polynomial.polyval2d(
dim0_coords_m_2d, dim1_coords_m_2d, DeltaKCOAPoly_int)))
return output_data, new_DeltaKCOAPoly
def __call__(self, i, x, p = 0):
"""
k is degree is 0+
0 <= i < len(t)
t[0] <= x <= t[-1]
p < k
"""
t = self._t
jj = np.where(np.logical_and(x >= t[:-1], x < t[1:]))[0]
if len(jj) == 0:
if x == t[-1]:
j = self._n + self._k - 2
else:
return 0
else:
j = jj[0]
if self._derivatives:
k = self._k - p
a = self._a[i, j, k, :k+1]
else:
a = self._a[i, j, -1]
if p > 0:
a = polyder(a, p)
return polyval(x, a)
def drawCriticalLines2():
eps3 = 1e-1
derivative = npp.polyder(f_as_poly)
criticalPoints = npp.polyroots(derivative)
#phase = (lambda v: np.angle(npp.polyval(v[0]+1j*v[1],f_as_poly)))
phase = np.angle(values)
#hessian = nd.Hessian(phase)
for z0 in criticalPoints:
z1 = z0 + eps3
z2 = z0 + eps3
z3 = z0 - eps3
z4 = z0 - eps3
draw_contour_from(z1, eps3)
draw_contour_from(z2, -eps3)
draw_contour_from(z3, eps3)
draw_contour_from(z4, -eps3)
(x0, y0) = complex_to_pixel(z0)
pg.draw.circle(window, (255, 0, 0), (x0, y0), circle_size, 0)
pg.draw.circle(window, (0, 0, 0), (x0, y0), circle_size, 3)
def poly_lagrange(i, alldata: pd.DataFrame):
if i < 3 or i > len(alldata):
logging.warning('"outside fit interval"')
data = alldata.iloc[i - 3:i + 5, :]
mid = data.iloc[3, :]
scale = data.iloc[7, :] - data.iloc[0, :]
scaled_data = (data - mid) / scale
polys_svid = {}
vel_svid = {}
time_col = scaled_data.iloc[:, 0]
for dfcol in scaled_data.columns:
if dfcol != 'UTC Time':
coefs = (P.Polynomial(
lagrange(np.array(time_col),
np.array(scaled_data[dfcol]))).coef)[::-1]
polys_svid[dfcol] = coefs
vel_svid[dfcol] = P.polyder(coefs)
return {
i: {
'mid': mid,
'scale': scale,
'polys_svid': polys_svid,
'vel_svid': vel_svid
}
}
def generate(self):
self.compute_polynomials(self.tridiag_matrices[0])
self.frozen_spectral_w = [self.spectral_weight(self.eigen_values[0][i]) for i in range(self.n_traj)]
for sample in range(1, self.n_samples+1):
self.compute_polynomials(self.tridiag_matrices[sample-1])
self.compute_brownians()
d_A = 0
for i in range(self.n_traj):
lbda_i = self.eigen_values[sample-1][i]
G_i = self.compute_G(lbda_i, self.tridiag_matrices[sample-1])
eigen_values_list = [lbda for lbda in list(self.eigen_values[sample - 1]) if lbda != lbda_i]
sum_term = sum([(1 / (lbda_i - lbda_k)) for lbda_k in eigen_values_list])
d_A -= (self.brownians[sample][i] + self.dt*(-lbda_i/2 + sum_term))*(self.frozen_spectral_w[i]**2)*G_i
#print(d_A)
d_P = 0
for i in range(0, self.dim):
lbda_i = self.eigen_values[sample-1][i]
for k in range(0, self.dim):
for l in range(0, self.dim):
add = P.polyval(lbda_i, self.p[k]) * P.polyval(lbda_i, P.polyder(self.p[l])) + P.polyval(lbda_i, P.polyder(self.p[k])) * P.polyval(lbda_i, self.p[l])
d_P -= 0.5 * self.frozen_spectral_w[i]**2 * add * self.compute_G_kl(k, l, self.tridiag_matrices[sample-1], self.eigen_values[sample-1]) * self.dt
draw_A = self.tridiag_matrices[sample-1] + d_A + d_P
#print(d_P)
#print(draw_A)
self.tridiag_matrices.append(draw_A)
self.eigen_values.append(sorted(np.linalg.eigvalsh(self.tridiag_matrices[sample]), reverse=True))
print(eigen_values_list)
def jointPieces(Dt, Nsamples, polys, der_list):
# Number of derivates to evaluate
numDer = len(der_list)
# Number of pieces to join
numPieces = len(Dt)
# Time offsets
toff = np.zeros(numPieces + 1)
toff[1: numPieces + 1] = \
np.matmul(np.tril(np.ones((numPieces, numPieces)), 0), np.array(Dt))
# Matrix of time and output vector to represent the pieces
t = np.zeros((numPieces, Nsamples))
y = np.zeros((numPieces, Nsamples))
# The overall time vector to include all the pieces
T = np.zeros((numPieces * Nsamples))
Y = np.zeros((numDer, numPieces * Nsamples))
# Evaluation
for i in range(len(Dt)):
dt = Dt[i] / Nsamples
t[i, :] = np.arange(0, Nsamples) * dt
for j in range(numDer):
# Evaluate the polynomial
pder = pl.polyder(polys[i, :], der_list[j])
y[i, :] = pl.polyval(t[i, :], pder)
# Compose the single vectors
Y[j, i * Nsamples:(i + 1) * Nsamples] = y[i, :]
T[i * Nsamples:(i + 1) * Nsamples] = t[i, :] + toff[i]
return (T, Y)
def solve_polyfit(xarr, yarr, degree, weight, deriv=None):
# Obtain solution using polyfit
z = P.polyfit(xarr, yarr, deg=degree, w=weight)
if deriv is not None:
z = P.polyder(z, m=deriv)
return z
def _get_sensitivity_mean_coefficients(self, header_specifier: str, all_temperatures: List[List[float]],
coefficients_list: Tuple[List[List[float]], List[List[float]]],
indexes: List[int], headers: List[str], type_specifier: str, units: str):
if len(all_temperatures[0]) < 3:
return
for header in headers:
fbg_name = fbg_name_from_header(header)
master_temperatures = _get_master_temperatures(all_temperatures)
mean_column_name = "{} Mean {}".format(fbg_name, header_specifier)
y_values = self.calibration_data_frame[mean_column_name][1:]
mean_temperature_column_name = "Mean Temperature (K)"
x_values = self.calibration_data_frame[mean_temperature_column_name][1:]
coefficients = []
for order in range(1, 4):
coefficients = poly.polyfit(x_values, y_values, order)
error = np.sum((poly.polyval(x_values, coefficients) - y_values)**2)
if error <= 10**-6:
break
derivative_coefficients = poly.polyder(coefficients)
sensitivity_column_name = "{} {} Sensitivity {}".format(fbg_name, type_specifier, units)
scalar = 1000 if type_specifier == "Wavelength" else 1
results = poly.polyval(master_temperatures, derivative_coefficients)
self.calibration_data_frame[sensitivity_column_name] = results
self.calibration_data_frame[sensitivity_column_name] *= scalar
coefficients_list[0].append(list(reversed(coefficients)))
coefficients_list[1].append(list(reversed(derivative_coefficients)))
self._add_deviation_index(sensitivity_column_name, indexes)
def smoothing_poly_lnprior(poly, degree, xmin, xmax, gamma=1):
"""
A smoothing prior that suppresses higher order derivatives of a polynomial,
poly = a + b x + c x*x + ..., described by a vector of its coefficients,
[a, b, c, ...].
Functional form is:
ln p(poly coeffs) =
-gamma * integrate( (diff(poly(x), x, degree))^2, x, xmin, xmax)
So it takes the `degree`th derivative of the polynomial, squares it,
integrates that from xmin to xmax, and scales by -gamma.
"""
# Take the `degree`th derivative of the polynomial.
poly_diff = P.polyder(poly, m=degree)
# Square the polynomial.
poly_diff_sq = P.polypow(poly_diff, 2)
# Take the indefinite integral of the polynomial.
poly_int_indef = P.polyint(poly_diff_sq)
# Evaluate the integral at xmin and xmax to get the definite integral.
poly_int_def = (
P.polyval(xmax, poly_int_indef) - P.polyval(xmin, poly_int_indef)
)
# Scale by -gamma to get the log prior
lnp = -gamma * poly_int_def
return lnp
def NewtonRaphson(self, L, initial_guess, max_iterations,
accuracy): # NewtonRaphson function takes 5 arguments
# L is the co-efficient list, e.g.,-
# If the polynomial is x^2-9x+14, then-
# L=[14,-9,1]
# initial_guess is the starting value, e.g.-
# initial_guess=8
# max_iterations is the maximum allowed number of iterations
# accuracy is the desired Accuracy
self.co_eff = L
self.initial_guess = initial_guess
self.max_iterations = max_iterations
self.accuracy = accuracy
derivative = P.polyder(
self.co_eff) # calculating derivative of polynomial
x = self.initial_guess # variable to store initial guess
count = 0 # variable to count iterations
while (count < self.max_iterations):
y = x - (P.polyval(x, self.co_eff) / P.polyval(x, derivative)
) # calculating next value
if (abs(P.polyval(y, self.co_eff)) <=
self.accuracy): # terminal condition
return (y) # return value
x = y # preparing for next iteration
count += 1
return ("Iterations exceed limit")
def Lagrange(L,M):
polylist=[]
n=len(L)
w=(-1*L[0],1)
for i in range(1,n):
w=P.polymul(w,(-1*L[i],1))
result=array([0.0 for i in range(len(w)-1)])
derivative=P.polyder(w)
for i in range(n):
polylist.append((P.polydiv(w,(-1*L[i],1))[0]*M[i])/P.polyval(L[i],derivative))
result+=polylist[-1]
polynomial=""
for i in range(len(result)-1,0,-1):
if(result[i]!=0):
if(result[i]>0 and i!=(len(result)-1)):
polynomial+=" + "+str(result[i])+"x^"+str(i)+" "
elif(result[i]>0 and i==(len(result)-1)):
polynomial+=str(result[i])+"x^"+str(i)+" "
else:
polynomial+=" - "+str(-1*result[i])+"x^"+str(i)+" "
if(result[0]!=0):
polynomial+=" + "+str(result[0]) if result[0]>0 else " - "+str(-1*result[0])
plot(L,M,polylist,result)
return (polynomial)
def poly_solve(poly, tau, line, terminate):
# Derivative
if poly.size > 3 and np.abs(poly[-1]) < np.finfo(float).eps:
poly[-1] = 0.0
der = p.polyder(poly)
# Stationary Points
stat_x = p.polyroots(der)
stat_f = p.polyval(stat_x, poly)
stat_x_feasible = stat_x[terminate.feasible(line, stat_x, stat_f)]
stat_f_feasible = stat_f[terminate.feasible(line, stat_x, stat_f)]
# Bounds Extrema
bound_x = tau
bound_f = p.polyval(bound_x, poly)
bound_x_feasible = bound_x[terminate.feasible(line, bound_x, bound_f)]
bound_f_feasible = bound_f[terminate.feasible(line, bound_x, bound_f)]
# Termination Extrema
term_x = terminate.extrema(line, poly)
if term_x.size > 0:
term_f = p.polyval(term_x, poly)
else:
term_f = np.array([])
# Combine
comb_x = np.concatenate((stat_x_feasible, bound_x_feasible, term_x))
comb_f = np.concatenate((stat_f_feasible, bound_f_feasible, term_f))
# Bounds Filter
comb_final_x = comb_x[np.logical_and(bound_x[0] <= comb_x, comb_x <= bound_x[1])]
comb_final_f = comb_f[np.logical_and(bound_x[0] <= comb_x, comb_x <= bound_x[1])]
# Return Result
if comb_final_x.size == 0:
return None
else:
return comb_final_x[np.argmin(comb_final_f)]
def smoothing_poly_lnprior(poly, degree, xmin, xmax, gamma=1):
"""
A smoothing prior that suppresses higher order derivatives of a polynomial,
poly = a + b x + c x*x + ..., described by a vector of its coefficients,
[a, b, c, ...].
Functional form is:
ln p(poly coeffs) =
-gamma * integrate( (diff(poly(x), x, degree))^2, x, xmin, xmax)
So it takes the `degree`th derivative of the polynomial, squares it,
integrates that from xmin to xmax, and scales by -gamma.
"""
# Take the `degree`th derivative of the polynomial.
poly_diff = P.polyder(poly, m=degree)
# Square the polynomial.
poly_diff_sq = P.polypow(poly_diff, 2)
# Take the indefinite integral of the polynomial.
poly_int_indef = P.polyint(poly_diff_sq)
# Evaluate the integral at xmin and xmax to get the definite integral.
poly_int_def = (P.polyval(xmax, poly_int_indef) -
P.polyval(xmin, poly_int_indef))
# Scale by -gamma to get the log prior
lnp = -gamma * poly_int_def
return lnp
def combine_quadrupole_plate(c, intfun, cP, intfunP):
x_cder = polynomial.polyder(c, axis=0)
x_cPder = polynomial.polyder(cP, axis=0)
y_cder = polynomial.polyder(c, axis=1)
y_cPder = polynomial.polyder(cP, axis=1)
Ex = lambda x, y, z: (intfunP(z) * polynomial.polyval2d(x, y, x_cPder) +
intfun(z) * polynomial.polyval2d(x, y, x_cder)) / 100
Ey = lambda x, y, z: (intfunP(z) * polynomial.polyval2d(x, y, y_cPder) +
intfun(z) * polynomial.polyval2d(x, y, y_cder)) / 100
Ez = lambda x, y, z: (intfunP.derivative()(z) * polynomial.polyval2d(
x, y, cP) + intfun.derivative()
(z) * polynomial.polyval2d(x, y, c)) / 100
Emag = lambda x, y, z: np.sqrt(
Ex(x, y, z)**2 + Ey(x, y, z)**2 + Ez(x, y, z)**2)
return Ex, Ey, Ez, Emag
def deskewmem(input_data, DeltaKCOAPoly, dim0_coords_m, dim1_coords_m, dim, fft_sgn=-1):
"""
Performs deskew (centering of the spectrum on zero frequency) on a complex dataset.
Parameters
----------
input_data : numpy.ndarray
Complex FFT Data
DeltaKCOAPoly : numpy.ndarray
Polynomial that describes center of frequency support of data.
dim0_coords_m : numpy.ndarray
dim1_coords_m : numpy.ndarray
dim : int
fft_sgn : int|float
Returns
-------
Tuple[numpy.ndarray, numpy.ndarray]
* `output_data` - Deskewed data
* `new_DeltaKCOAPoly` - Frequency support shift in the non-deskew dimension caused by the deskew.
"""
# Integrate DeltaKCOA polynomial (in meters) to form new polynomial DeltaKCOAPoly_int
DeltaKCOAPoly_int = polynomial.polyint(DeltaKCOAPoly, axis=dim)
# New DeltaKCOAPoly in other dimension will be negative of the derivative of
# DeltaKCOAPoly_int in other dimension (assuming it was zero before).
new_DeltaKCOAPoly = - polynomial.polyder(DeltaKCOAPoly_int, axis=dim-1)
# Apply phase adjustment from polynomial
dim1_coords_m_2d, dim0_coords_m_2d = np.meshgrid(dim1_coords_m, dim0_coords_m)
output_data = np.multiply(input_data, np.exp(1j * fft_sgn * 2 * np.pi *
polynomial.polyval2d(
dim0_coords_m_2d,
dim1_coords_m_2d,
DeltaKCOAPoly_int)))
return output_data, new_DeltaKCOAPoly
def solve_leastsq(yarr, ycov, vander, vanderT, deriv=None):
ycovinv = inv(ycov)
prefactor = inv(np.dot(np.dot(vanderT, ycovinv), vander))
postfactor = np.dot(np.dot(vanderT, ycovinv), yarr)
z = np.dot(prefactor, postfactor)
if deriv is not None:
z = P.polyder(z, m=deriv)
return z
def deriv(self):
""" compute first derivative
Returns
-------
dPP : PseudoPolynomial
d(PP)/dx represented as a PseudoPolynomial
"""
dp = pol.polyder(self.p)
dq = pol.polyder(self.q)
p = pol.polysub(pol.polymul((1, 0, -1), dp),
pol.polymul((0, 2 * self.r), self.p))
q = pol.polysub(pol.polymul((1, 0, -1), dq),
pol.polymul((0, 2 * self.r + 1), self.q))
r = self.r - 1
return PseudoPolynomial(p=remove_zeros(p), q=remove_zeros(q), r=r)
def combine_quadrupole_plate_factor(c, intfun, cP, intfunP, factor):
"""
Change the homogeneous field strenght by a factor
"""
x_cder = polynomial.polyder(c, axis=0)
x_cPder = polynomial.polyder(cP, axis=0)
y_cder = polynomial.polyder(c, axis=1)
y_cPder = polynomial.polyder(cP, axis=1)
Ex = lambda x, y, z: (factor * (intfunP(z) * polynomial.polyval2d(
x, y, x_cPder)) + intfun(z) * polynomial.polyval2d(x, y, x_cder)) / 100
Ey = lambda x, y, z: (factor * (intfunP(z) * polynomial.polyval2d(
x, y, y_cPder)) + intfun(z) * polynomial.polyval2d(x, y, y_cder)) / 100
Ez = lambda x, y, z: (factor * (intfunP.derivative()(z) * polynomial.
polyval2d(x, y, cP)) + intfun.derivative()
(z) * polynomial.polyval2d(x, y, c)) / 100
Emag = lambda x, y, z: np.sqrt(
Ex(x, y, z)**2 + Ey(x, y, z)**2 + Ez(x, y, z)**2)
return Ex, Ey, Ez, Emag
def __init__(self,
z_values_range_params,
c_values_range_params,
dimension_params,
formula_params,
max_iterations=None):
super().__init__(z_values_range_params, c_values_range_params,
dimension_params, formula_params, max_iterations)
self._coefficient_array_deriv = polyder(
self._formula_params.coefficient_array)
def calculate_t5(x, wf):
sample_i = np.indices(wf.shape)[-1]
peakpos = np.argmax(wf, axis=1).astype(np.intp)
t = np.zeros(wf.shape[0])
for i, w in enumerate(wf):
start = peakpos[i] - 3
end = peakpos[i] + 3
c = npp.polyfit(x[start:end], w[start:end], 2)
dc = npp.polyder(c)
t[i] = -dc[0] / dc[1]
return t
def newtReconstructHessian(freqs,locations, spectrum, numPts):
"""
:param freqs:
:param locations:
:param spectrum:
:param numPts:
:return:
"""
deriv=poly.polyder(spectrum,m=2,axis=0)
return genericNewtVal(locations,deriv)
def newtReconstructDerivative(freqs, locations, spectrum, numPts):
"""
:param freqs:
:param locations:
:param spectrum:
:param numPts:
:return: derivative of iFFT of the spectrum as an array with shape (Npts, Ncomponent) or (Ncomponent,) if 1-d
"""
deriv=poly.polyder(spectrum, axis=0)
return genericNewtVal(locations, deriv)
def eval(self, t, der=np.array([0])):
"""
Evaluate the piecewise polynomial
Args:
t vector of time instants
der derivative to evaluate
"""
# Check whether the evaluation is requested on a scalar or on an
# iterable
try:
# Iterable: t is a vector
t = np.array(t)
_ = iter(t)
nsamples = t.size
if (t[0] < 0.0) or (t[nsamples - 1] > self.knots[-1]):
print("PwPoly.eval(): Trying to evaluate outside " +
"the time support of the piecewise polynomial\n" +
"t_max = {}, t = {}".format(self.knots[-1], t[nsamples -
1]))
# Allocate the variable
yout = np.zeros((nsamples), dtype=float)
for (k, t_) in enumerate(t):
i = self.find_piece(t_)
# Evaluate the required polynomial derivative
pder = pl.polyder(self.coeff_m[i, :], der)
yout[k] = pl.polyval(t_ - self.knots[i], pder)
except TypeError:
# Non iterable: t is a single value
if (t < 0.0) or (t > self.knots[-1]):
print("PwPoly.eval(): Trying to evaluate outside " +
"the time support of the piecewise polynomial\n" +
"t_max = {}, t = {}".format(self.knots[-1], t))
i = self.find_piece(t)
pder = pl.polyder(self.coeff_m[i, :], der)
yout = pl.polyval(t - self.knots[i], pder)
return yout
def newton_zero(p, lo, hi, acc=1E-5):
ylo = pol.polyval(lo, p)
yhi = pol.polyval(hi, p)
x0 = linzero(lo, hi, ylo, yhi)
dp = pol.polyder(p)
f = lambda x, p=p: pol.polyval(x, p)
df = lambda x, dp=dp: pol.polyval(x, dp)
return newton(f, x0, fprime=df)
def test_polyder(self) :
# check exceptions
assert_raises(ValueError, poly.polyder, [0], -1)
# check that zeroth deriviative does nothing
for i in range(5) :
tgt = [1] + [0]*i
res = poly.polyder(tgt, m=0)
assert_equal(trim(res), trim(tgt))
# check that derivation is the inverse of integration
for i in range(5) :
for j in range(2,5) :
tgt = [1] + [0]*i
res = poly.polyder(poly.polyint(tgt, m=j), m=j)
assert_almost_equal(trim(res), trim(tgt))
# check derivation with scaling
for i in range(5) :
for j in range(2,5) :
tgt = [1] + [0]*i
res = poly.polyder(poly.polyint(tgt, m=j, scl=2), m=j, scl=.5)
assert_almost_equal(trim(res), trim(tgt))
def Lagrange(self,A,B):
from numpy import array
from numpy.polynomial import polynomial as P
n=len(A)
w=(-1*A[0],1)
for i in range(1,n):
w=P.polymul(w,(-1*A[i],1))
result=array([0.0 for i in range(len(w)-1)])
derivative=P.polyder(w)
for i in range(n):
result+=(P.polydiv(w,(-1*A[i],1))[0]*B[i])/P.polyval(A[i],derivative)
s=self.plot(list(result),A,B)
return s
def findderivative(x,y,derivorder=1):
window_len=25
# if spectrum.ndim != 1:
# raise ValueError, "smooth only accepts 1 dimension arrays."
#
# if spectrum.size < window_len:
# raise ValueError, "Input vector needs to be bigger than window size."
retval = numpy.ndarray(y.shape)
for i in range(y.size):
i_min = max(0,i-window_len/2)
i_max = min( i+window_len/2-1, y.size)
fit = pf(x[i_min:i_max+1],y[i_min:i_max+1],min(5,window_len))
retval[i] = polyval(x[i],polyder(fit,derivorder),tensor=False)
return retval
def Lagrange(self,U,V):
n=len(U)
w=(-1*U[0],1)
for i in range(1,n):
w=P.polymul(w,(-1*U[i],1))
result=array([0.0 for i in range(len(w)-1)])
derivative=P.polyder(w)
for i in range(n):
result+=(P.polydiv(w,(-1*U[i],1))[0]*V[i])/P.polyval(U[i],derivative)
temp=list(result);
cofficient=temp
l=len(cofficient);
temp=[];
for i in range(l-1):
temp.append(str(cofficient[l-(i+1)])+'x^'+str(l-(i+1))+str('+'))
temp.append(str(cofficient[0])+'x^'+str(0));
str1=''.join(temp)
return(str1)
def __call__(self, i, x, p = 0):
"""
k is degree is 0+
0 <= i < len(t)
t[0] <= x <= t[-1]
p < k
NumPy vectorized version.
"""
_x = x
if np.isscalar(x):
x = (x,)
if not isinstance(x, np.ndarray):
x = np.array(x)
w = np.zeros_like(x)
t = self._t
for j in range(self._k, self._n + self._k - 1):
if j == self._n + self._k - 2:
jj = np.where(np.logical_and(x >= t[j], x <= t[j + 1]))[0]
else:
jj = np.where(np.logical_and(x >= t[j], x < t[j + 1]))[0]
if self._derivatives:
k = self._k - p
a = self._a[i, j, k]
else:
a = self._a[i, j, -1]
if p > 0:
a = polyder(a, p)
w[jj] = polyval(x[jj], a)
if np.isscalar(_x):
w = w[0]
return w
import numpy as np
from numpy.polynomial import polynomial as P
import matplotlib.pyplot as plt
x = np.linspace(0, 8 * np.pi, 50)
y1 = np.cos(x)
y2 = np.sin(x - np.pi)
# Fitting data
coeff, stats = P.polyfit(x, y1, 20, full=True)
roots = np.real(P.polyroots(coeff))
fit = P.Polynomial(coeff)
yf1 = fit(x)
# Differentiating fitted polynomial
new_coeff = P.polyder(coeff)
dfit = P.Polynomial(new_coeff)
yf2 = dfit(x)
# Plotting results for illustration
fig = plt.figure(figsize=(8,6))
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212)
ax1.set_title('Data and fitting')
ax2.set_title('Differentiation')
ax1.set_xlim(0, x.max())
ax2.set_xlim(0, x.max())
ax1.set_ylim(-1.25, 1.25)
ax2.set_ylim(-1.25, 1.25)
def polyder(cs, m=1, scl=1):
from numpy.polynomial.polynomial import polyder
return polyder(cs, m, scl)
def _derivative(c, m):
return polynomial.polyder(c, m)
# -*- coding: utf-8 -*- #Na ravnoj podlozi projekti je ispaljen pod kutem od 45 stupnjeva i pao #je 580 m dalje. Procijenite maksimalnu visinu koju je projektil postigao. from numpy import * from numpy.polynomial import polynomial as p import pylab M1=array([[1,0,0],[0,1,0],[1,580,580**2]]) M2=array([0,1,0]) a=linalg.solve(M1,M2) #Funkcija koja daje interpolacijski polinom # U slucaju da moramo provjeriti rezultate: print p.polyval(0.,a) #provjera p(0)=0 print p.polyval(0.,p.polyder(a)) #provjera p'(0)=1 :Za deriviranu vrijednost print p.polyval(580.,a) #provjera p(580)=0 print 'Maksimalna visina je', p.polyval(580./2,a),'metara.' #Crtanje funkcije: x=linspace(0-0.5,580+0.5,100) y=p.polyval(x,a) pylab.plot(x,y) pylab.show()
def get_generalized_curvature(signal_in, total_points, deg):
"""
Calculate curvature of n-dimensional trajectory, signal_in of shape (t, n)
Use total_points adjacent points to fit a polynomial of degree deg
Then calculate generalized curvature explicitly from the polynomial
total_points: ~11
deg: ~5
Args:
signal_in: (T, n)
total_points: number of points to use, ~11
deg: degree of polynomial, ~5
Returns:
k_t: curvatures
e_t: frenet frames
"""
def dt_id1(a, ap):
"""
derivative of a/norm(a)
input: a and da/dt, a and da/dt are n-dim vectors
output: d/dt ( a/norm(a) )
"""
return ap/np.linalg.norm(a) - np.dot(ap, a)*a/(np.dot(a, a)**(1.5))
def dt_id2(a, b, ap, bp):
"""
derivative of inner(a, b)*b
input: a, b, da/dt, db/dt, each an n-dim vector
output: d/dt ( inner(a, b)*b )
"""
return (np.dot(ap, b) + np.dot(a, bp))*b + np.dot(a, b)*bp
total_curvatures = np.min((signal_in.shape[1]-1, deg-1)) # have many curvatures to calculate
k_t = np.zeros((signal_in.shape[0], total_curvatures)) # initialize curvatures, k
e_t = np.zeros(signal_in.shape+(total_curvatures+1,)) # frenet frames, (t, n, curvatures+1)
half = np.floor(total_points/2).astype(int)
for t in range(half, signal_in.shape[0] - half): # end point correct?
times = np.arange(t-half, t+half+1)
times_local = times - t # will always be -half:half
tmid = times_local[half] # tmid = 0
p = P.polyfit(times_local, signal_in[times], deg)
pp = [] # coefficients of polynomial (and its derivatives)
pt = [] # polynomial (and its derivs) evaluated at time t
for deriv in range(deg+2): # +2 because there are deg+1 nonzero derivatives of the polynomial, and +1 because of range()
pp.append(P.polyder(p, deriv))
pt.append(P.polyval(tmid, pp[-1]).T) # evaluate at 0
e = [] # frenet basis, e1, e2, ... at time t
ep = [] # derivatives, e1', e2', ...
e_ = [] # unnormalized es
e_p = [] # unnormalized (e')s
k = [] # generalized curvature at time t
# first axis of frenet frame
e.append(pt[1]/np.linalg.norm(pt[1]))
ep.append(dt_id1(pt[1], pt[2]))
for dim in range(2, total_curvatures+2):
# Start gram-schmidt orthogonalization on e:
e_.append(pt[dim])
e_p.append(pt[dim+1])
for j in range(dim-1):
e_[-1] = e_[-1] - np.dot(pt[dim], e[j])*e[j] # orthogonalize relative to every other e
e_p[-1] = e_p[-1] - dt_id2(pt[dim], e[j], pt[dim+1], ep[j]) # derivative of e_
e.append(e_[-1]/np.linalg.norm(e_[-1])) # normalize e_ to get e
ep.append(dt_id1(e_[-1], e_p[-1])) # derivative of e
k.append(np.dot(ep[-2], e[-1])/np.linalg.norm(pt[1]))
k_t[t, :] = np.array(k)
e_t[t, :, :] = np.array(e).T
return k_t, e_t
