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 }