def make_nodes(n, p, a, b):
mu_list = np.array(make_mu_k(n, p, a, b), dtype=np.float64)
left_part = np.array([mu_list[i:n+i][::-1] for i in range(n)], dtype=np.float64)
right_part = -1 * mu_list[n:]
coef = solve(left_part, right_part)
coef = np.append(coef[::-1], 1)
w = Polynomial(coef)
return w.roots()
def solve_root(coefficients, ploting=True):
f = Polynomial(list(reversed(coefficients)))
# Solve f(x) == 0.
X, Y = [], []
roots = f.roots()
"""
print("polynomial: ", f)
print("roots: ", roots)
"""
result = areRootsRealNegative(roots)
return result, roots
from numpy.polynomial.polynomial import Polynomial import math import sympyExercise # 2次方程式 #################################### f = Polynomial([24, -10, 1]) print(f.roots()) # 連立方程式 #################################### from numpy.linalg import solve left = [[1, 1, 1], [1, 3, 4], [2, 2, 1]] right = [3, 13, 4] print(solve(left, right)) # 順列 組み合わせ #################################### from itertools import permutations, combinations balls = [1, 2, 3] print(list(permutations(balls, 2))) #順列 print(list(combinations(balls, 2))) #組み合わせ # 集合 #################################### a = set([1, 2, 3, 4, 5]) b = set([1, 4]) print(a >= b) print(a | b) print(a & b)
coef = [a[n] * (-1)**(N - n) for n in range(len(a))]
print(np.array(coef))
from functools import reduce
print(
np.array([reduce(lambda a, b: a * x + b, coef) for x in range(1, 21)]))
print(
np.array([
reduce(lambda a, b: a * x * 1.0 + b, coef) for x in range(1, 21)
]))
coef.reverse()
w = Polynomial(np.array(coef, dtype=np.float))
# have to explicitly specify dtype,
# otherwise root finder doesn't work
print([w(x) for x in range(1, 21)])
print(w.roots())
# This uses eigenvalues of the companion matrix for roots
from scipy.optimize import root
print(root(w, 21.0))
# This uses Optimization method root finding
for delta in (1e-8, 1e-6, 1e-4, 1e-2):
coef[20] = 1 + delta
w = Polynomial(np.array(coef, dtype=np.float))
print(root(w, 21.0))
coef[20] = 1
coef[19] = -210 - 2**(-23)
w = Polynomial(np.array(coef, dtype=np.float))
print(root(w, 16.1))
print(root(w, 17.1))
print(w.roots())
coef[19] = -210
#!/usr/bin/env python
"""polynomial.py: Demonstrate equation solvers of SciPy.
"""
from numpy.polynomial.polynomial import Polynomial
# pylint: disable=invalid-name
# Define a polynomial x^3 - 2 x^2 + x - 2.
f = Polynomial([-2, 1, -2, 1])
print("polynomial: ", f)
# Solve f(x) == 0.
print("roots: ", f.roots())
def pointToPointMetrics(
start_point_indices: np.ndarray,
end_point_indices: np.ndarray,
point_values: np.ndarray,
point_times: np.ndarray,
endpoint_value_fractions: np.
ndarray # don't include a 1.0 case since we always perform this
) -> Dict:
num_metrics_to_compute = len(
endpoint_value_fractions) + 1 # +1 for 100% case we always perform
num_point_values = len(start_point_indices)
metrics = np.zeros(shape=(num_metrics_to_compute, num_point_values),
dtype=np.float32)
normalized_metrics = metrics.copy()
metric_failure_counter = np.zeros(shape=(num_metrics_to_compute),
dtype=np.float32)
for point_index in range(len(start_point_indices)):
start_point_index = start_point_indices[point_index]
end_point_index = end_point_indices[point_index] + 1
# shift times and values to 0 start/reference
points_to_fit_poly_at = point_times[
start_point_index:end_point_index] - point_times[start_point_index]
value_of_points_to_fit = point_values[
start_point_index:end_point_index] - point_values[start_point_index]
# the time to 100% (endpoint_value_fractions = 1.0) can just be read from the data.
# a polynomial fit to estimate this time can be wrong because end points for the fit
# don't always go through the real end points. plus it's a waste of compute time.
start_point_time = points_to_fit_poly_at[0]
end_point_time = points_to_fit_poly_at[-1]
metrics[-1, point_index] = end_point_time
end_point_value = value_of_points_to_fit[-1]
normalized_metrics[
-1, point_index] = end_point_time / np.abs(end_point_value)
num_points_for_fit = len(points_to_fit_poly_at)
min_points_for_3rd_deg_poly = 6 # arbitrary value. empirically determine on a small data set.
if num_points_for_fit >= min_points_for_3rd_deg_poly:
polyfit_deg = 3
else:
polyfit_deg = 2
polyfit_of_values = Polynomial.fit(
points_to_fit_poly_at,
value_of_points_to_fit,
polyfit_deg,
domain=[start_point_time, end_point_time],
window=[start_point_time, end_point_time])
poly = Polynomial(polyfit_of_values.convert().coef)
for fraction_id_to_add in range(len(endpoint_value_fractions)):
fraction_of_value = endpoint_value_fractions[fraction_id_to_add]
fraction_of_p2p_diff = fraction_of_value * end_point_value
roots = Polynomial.roots(poly - fraction_of_p2p_diff)
failure_count = 1.0
for fraction_point_time in roots:
if np.iscomplex(fraction_point_time):
continue # imaginary part must be non zero so we can't use it
if fraction_point_time < start_point_time or fraction_point_time > end_point_time:
continue
# could still have a complex num obj with imaginary part 0 so force to be real
fraction_point_time = np.real(fraction_point_time)
metrics[fraction_id_to_add, point_index] = fraction_point_time
normalized_metrics[fraction_id_to_add,
point_index] = fraction_point_time / np.abs(
fraction_of_p2p_diff)
failure_count = 0.0
break
metric_failure_counter[fraction_id_to_add] += failure_count
metrics_counters = np.abs(metric_failure_counter - num_point_values)
metrics_sums = np.sum(metrics, axis=-1)
metrics_means = metrics_sums / metrics_counters
normalized_metrics_sums = np.sum(normalized_metrics, axis=-1)
normalized_metrics_sums_means = normalized_metrics_sums / metrics_counters
metrics_failure_proportions = metric_failure_counter / num_point_values
return {
'metric_fractions': np.append(endpoint_value_fractions,
[1.0]), # add the 100% case
'p2p_metric_data': metrics,
'mean_metric_data': metrics_means,
'normalized_metric_data': normalized_metrics_sums_means,
'num_metric_failures': metric_failure_counter,
'num_metric_points': num_point_values,
'metric_failure_proportions': metrics_failure_proportions
}
