def test_intercept_flag(rows=10, columns=9): inout = get_random_array(rows, columns) x = inout[0] y = inout[1] ntX = HomogenNumericTable(x) ntY = HomogenNumericTable(y) ridge_training_algorithm = ridge_training.Batch() ridge_training_algorithm.input.set(ridge_training.data, ntX) ridge_training_algorithm.input.set(ridge_training.dependentVariables, ntY) # set parameter alpha = 1.0 alpha_nt = HomogenNumericTable(np.array([alpha], ndmin=2)) ridge_training_algorithm.parameter.ridgeParameters = alpha_nt result = ridge_training_algorithm.compute() model = result.get(ridge_training.model) beta_coeff = model.getBeta() np_beta = getNumpyArray(beta_coeff) daal_intercept = np_beta[0,0] regression = ScikitRidgeRegression(alpha=1.0, fit_intercept=True) regression.fit(x, y) scikit_intercept = regression.intercept_ assert_array_almost_equal(scikit_intercept, [daal_intercept])
def check_chisquare(f_obs, f_exp, ddof, axis, expected_chi2): # Use this only for arrays that have no masked values. f_obs = np.asarray(f_obs) if axis is None: num_obs = f_obs.size else: if axis == 'no': use_axis = 0 else: use_axis = axis b = np.broadcast(f_obs, f_exp) num_obs = b.shape[use_axis] if axis == 'no': chi2, p = mstats.chisquare(f_obs, f_exp=f_exp, ddof=ddof) else: chi2, p = mstats.chisquare(f_obs, f_exp=f_exp, ddof=ddof, axis=axis) assert_array_equal(chi2, expected_chi2) ddof = np.asarray(ddof) expected_p = stats.chisqprob(expected_chi2, num_obs - 1 - ddof) assert_array_equal(p, expected_p) # Also compare to stats.chisquare if axis == 'no': stats_chisq, stats_p = stats.chisquare(f_obs, f_exp=f_exp, ddof=ddof) else: stats_chisq, stats_p = stats.chisquare(f_obs, f_exp=f_exp, ddof=ddof, axis=axis) assert_array_almost_equal(chi2, stats_chisq) assert_array_almost_equal(p, stats_p)
def get_daal_prediction(x=np.arange(10).reshape(10,1), y=np.arange(10).reshape(10,1)): ntX = HomogenNumericTable(x) ntY = HomogenNumericTable(y) ridge_training_algorithm = ridge_training.Batch() ridge_training_algorithm.input.set(ridge_training.data, ntX) ridge_training_algorithm.input.set(ridge_training.dependentVariables, ntY) # set parameter alpha = 0.0 alpha_nt = HomogenNumericTable(np.array([alpha], ndmin=2)) ridge_training_algorithm.parameter.ridgeParameters = alpha_nt result = ridge_training_algorithm.compute() model = result.get(ridge_training.model) ridge_prediction_algorithm = ridge_prediction.Batch() ridge_prediction_algorithm.input.setModel(ridge_prediction.model, model) ridge_prediction_algorithm.input.setTable(ridge_prediction.data, ntX) result = ridge_prediction_algorithm.compute() np_predicted = getNumpyArray(result.get(ridge_prediction.prediction)) # assert the same as the initial dependent variable assert_array_almost_equal(y, np_predicted) return np_predicted
def test_svd_daal_vs_sklearn(rows=1000, columns=1000): indata = get_random_array(rows, columns) daal_input = HomogenNumericTable(indata) algorithm = svd.Batch() algorithm.input.set(svd.data, daal_input) start_sklearn = time.time() _U, s, _Vh = np.linalg.svd(indata, full_matrices=False) end_sklearn = time.time() start_daal = time.time() result = algorithm.compute() end_daal = time.time() if os.getenv("CHECKPERFORMANCE") is not None: assert (end_daal - start_daal <= end_sklearn - start_sklearn) sigma = getNumpyArray(result.get(svd.singularValues)) _rows, cols = sigma.shape d_sigma = sigma.reshape(cols, ) assert_array_almost_equal(d_sigma, s) print("SVD for matrix[{}][{}]".format(rows, columns)) print("+ Sklearn SVD: {}".format(end_sklearn - start_sklearn)) print("+ Sklearn Daal: {}".format(end_daal - start_daal))
def check_chisquare(f_obs, f_exp, ddof, axis, expected_chi2): # Use this only for arrays that have no masked values. f_obs = np.asarray(f_obs) if axis is None: num_obs = f_obs.size else: if axis == 'no': use_axis = 0 else: use_axis = axis b = np.broadcast(f_obs, f_exp) num_obs = b.shape[use_axis] if axis == 'no': chi2, p = mstats.chisquare(f_obs, f_exp=f_exp, ddof=ddof) else: chi2, p = mstats.chisquare(f_obs, f_exp=f_exp, ddof=ddof, axis=axis) assert_array_equal(chi2, expected_chi2) ddof = np.asarray(ddof) expected_p = stats.chisqprob(expected_chi2, num_obs - 1 - ddof) assert_array_equal(p, expected_p) # Also compare to stats.chisquare if axis == 'no': stats_chisq, stats_p = stats.chisquare(f_obs, f_exp=f_exp, ddof=ddof) else: stats_chisq, stats_p = stats.chisquare(f_obs, f_exp=f_exp, ddof=ddof, axis=axis) assert_array_almost_equal(chi2, stats_chisq) assert_array_almost_equal(p, stats_p)
def test_kalman(self): # V0 = 12 h = np.atleast_2d(1) # voltimeter measure the voltage itself q = 1e-9 # variance of process noise as the car operates r = 0.05 ** 2 # variance of measurement error b = 0 # no system input u = 0 # no system input filt = Kalman(R=r, A=1, Q=q, H=h, B=b) # Generate random voltages and watch the filter operate. n = 50 # truth = np.random.randn(n) * np.sqrt(q) + V0 truth = np.array([12.0000146639, 12.0000065349, 12.0000032619, 11.9999884321, 11.9999738705, 11.9999717554, 12.000012208, 12.0000269596, 12.0000235391, 12.0000420788, 11.9999763588, 12.0000272251, 11.9999278487, 11.9999775611, 12.0000280208, 11.9999788802, 11.9999531533, 11.9999963402, 11.9999318055, 11.9999537065, 12.0000011098, 11.9999750291, 12.000012755, 11.9999355349, 11.9999960117, 12.0000033276, 12.0000100317, 11.9999962376, 12.0000527124, 12.000019087, 12.0000273276, 11.9999461331, 12.0000527385, 11.9999990413, 11.9999850764, 12.0000031025, 11.9999868222, 11.9999830042, 11.9999881952, 12.0000064122, 12.0000343455, 11.9999779108, 12.0000134648, 12.0000329604, 12.0000536949, 11.999990415, 11.9999935299, 11.9999850717, 12.0000048284, 12.000060395]) # @IgnorePep8 # print(', '.join(['{0}'.format(y) for y in truth])) # noise = np.random.randn(n) * np.sqrt(r) noise = np.array([0.0621366489443, 0.0247330994998, 0.109271521369, -0.0567657373852, -0.0315244553453, -0.0025701462034, 0.00181288937042, 0.109022849782, 0.0241169949603, -0.0543790728855, 0.0380117839575, 0.0582078684346, -0.0734606815139, -0.0665977120387, 0.0270631615171, 0.0369150024436, 0.0788445252483, 0.0111006834355, 0.0169567513801, 0.057081645789, -0.0293106512335, 0.0120282068494, 0.0211769283138, -0.0703228625119, -0.0222740803259, 0.0636500853308, 0.0302268639638, 0.0823316446844, 0.0504871636818, -0.0295402185417, 0.0780534199429, -0.0275453184976, -0.0613567940452, -0.0416930336494, -0.0972202720552, 0.0367572628693, 0.0150242119742, -0.0269063072041, 0.0654834111234, 0.0281867030757, -0.0978716452136, -0.0209143055692, -0.0236015624104, 0.0215804707908, -0.0525669442916, -0.00999304544556, -0.120029281573, -0.0255283929591, -0.00426938028504, -0.0487170747831]) # @IgnorePep8 # print('noise') # print(', '.join(['{0}'.format(y) for y in noise])) z = truth + noise # measurement x = np.zeros(n) for i, zi in enumerate(z): x[i] = filt(zi, u) # perform a Kalman filter iteration print(', '.join(['{0}'.format(y) for y in x])) assert_array_almost_equal(x, [12.0621513128, 12.0434454699, 12.065388589, 12.0348470726, 12.0215675093, 12.0175398445, 12.0152948689, 12.0270143185, 12.0266950063, 12.0185917138, 12.0203550503, 12.0235117738, 12.0160466547, 12.0101417447, 12.0112717378, 12.0128731715, 12.0167512202, 12.0164370857, 12.0164608484, 12.0184896738, 12.0162133963, 12.0160220138, 12.0162467099, 12.0126366982, 12.0112399981, 12.01325607, 12.0138850472, 12.0163296762, 12.0175094638, 12.0159415984, 12.0179463317, 12.0165228489, 12.0141641309, 12.0125210028, 12.0093846209, 12.0101451843, 12.0102767167, 12.0092975878, 12.0107382282, 12.01117469, 12.0085152867, 12.0078138971, 12.0070834443, 12.0074137537, 12.0060816948, 12.0057319401, 12.0030552687, 12.0024592874, 12.0023220236, 12.0013021198]) # @IgnorePep8
def test_case(self): model = clone(estimator) model.fit(**fit_data) for method in methods: try: code = sklearn2code(model, method, javascript) except ExpressionTypeNotSupportedError: continue js = execjs.get('Node') context = js.compile(code) exported_pred = [] try: for _, row in export_predict_data['X'].iterrows(): val = context.eval('%s(%s)' % (method, ', '.join( [str(x) if x == x else 'NaN' for x in row]))) exported_pred.append(val) exported_pred = np.array(exported_pred) pred = DataFrame(getattr(model, method)(**predict_data)) assert_array_almost_equal(np.ravel(pred), np.ravel(exported_pred), 3) except: # print(code) import clipboard clipboard.copy(code) raise
def test_kurtosis(self): # Set flags for axis = 0 and fisher=0 (Pearson's definition of kurtosis # for compatibility with Matlab) y = mstats.kurtosis(self.testmathworks, 0, fisher=0, bias=1) assert_almost_equal(y, 2.1658856802973, 10) # Note that MATLAB has confusing docs for the following case # kurtosis(x,0) gives an unbiased estimate of Pearson's skewness # kurtosis(x) gives a biased estimate of Fisher's skewness (Pearson-3) # The MATLAB docs imply that both should give Fisher's y = mstats.kurtosis(self.testmathworks, fisher=0, bias=0) assert_almost_equal(y, 3.663542721189047, 10) y = mstats.kurtosis(self.testcase, 0, 0) assert_almost_equal(y, 1.64) # test that kurtosis works on multidimensional masked arrays correct_2d = ma.array( np.array([-1.5, -3.0, -1.47247052385, 0.0, -1.26979517952]), mask=np.array([False, False, False, True, False], dtype=np.bool), ) assert_array_almost_equal(mstats.kurtosis(self.testcase_2d, 1), correct_2d) for i, row in enumerate(self.testcase_2d): assert_almost_equal(mstats.kurtosis(row), correct_2d[i]) correct_2d_bias_corrected = ma.array( np.array([-1.5, -3.0, -1.88988209538, 0.0, -0.5234638463918877]), mask=np.array([False, False, False, True, False], dtype=np.bool), ) assert_array_almost_equal(mstats.kurtosis(self.testcase_2d, 1, bias=False), correct_2d_bias_corrected) for i, row in enumerate(self.testcase_2d): assert_almost_equal(mstats.kurtosis(row, bias=False), correct_2d_bias_corrected[i]) # Check consistency between stats and mstats implementations assert_array_almost_equal_nulp(mstats.kurtosis(self.testcase_2d[2, :]), stats.kurtosis(self.testcase_2d[2, :]))
def test_linear_regression_simple(): # calculate beta coefficients x = np.array([0., 2., 3.]).reshape(3, 1) nt_x = nt_y = HomogenNumericTable(x) lr_alg = linear_training.Batch(method=linear_training.qrDense) lr_alg.input.set(linear_training.data, nt_x) lr_alg.input.set(linear_training.dependentVariables, nt_y) result = lr_alg.compute() model = result.get(linear_training.model) beta_coeff = model.getBeta() np_beta_coeff = getNumpyArray(beta_coeff) res_beta_coeff = np.array([0, 1]).reshape(1, 2) assert_almost_equal(res_beta_coeff, np_beta_coeff) # predict lr_alg_predict = linear_prediction.Batch() lr_alg_predict.input.setModel(linear_prediction.model, model) lr_alg_predict.input.setTable(linear_prediction.data, nt_x) result = lr_alg_predict.compute() np_predict = getNumpyArray(result.get(linear_prediction.prediction)) assert_array_almost_equal(x, np_predict)
def test_chisquare_masked_arrays(): # The other tests were taken from the tests for stats.chisquare, so # they don't test the function with masked arrays. Here masked arrays # are tested. obs = np.array([[8, 8, 16, 32, -1], [-1, -1, 3, 4, 5]]).T mask = np.array([[0, 0, 0, 0, 1], [1, 1, 0, 0, 0]]).T mobs = ma.masked_array(obs, mask) expected_chisq = np.array([24.0, 0.5]) chisq, p = mstats.chisquare(mobs) assert_array_equal(chisq, expected_chisq) assert_array_almost_equal( p, stats.chisqprob(expected_chisq, mobs.count(axis=0) - 1)) chisq, p = mstats.chisquare(mobs.T, axis=1) assert_array_equal(chisq, expected_chisq) assert_array_almost_equal( p, stats.chisqprob(expected_chisq, mobs.T.count(axis=1) - 1)) # When axis=None, the two values should have type np.float64. chisq, p = mstats.chisquare([1, 2, 3], axis=None) assert_(isinstance(chisq, np.float64)) assert_(isinstance(p, np.float64)) assert_equal(chisq, 1.0) assert_almost_equal(p, stats.chisqprob(1.0, 2))
def test_tile_array(self): a = np.array([[1, 2], [3, 4], [5, 6]]) a_tiled = hm.linalg.tile_array(a, 2) a_tiled_expected = np.array([[1, 2, 0, 0], [3, 4, 0, 0], [5, 6, 0, 0], [0, 0, 1, 2], [0, 0, 3, 4], [0, 0, 5, 6]]) assert_array_almost_equal(a_tiled.toarray(), a_tiled_expected)
def test_golden_section(): data = mlclass.ex4() x = add_bias(data['x']) y = data['y'] theta = array((.01, .01, .01)) p = -grad(x, y, theta, 0.) c = lambda alpha: nan_guard(cost(x, y, theta + alpha*p, 0.)) assert_array_almost_equal((0.000739624, 0.685489), golden_section((-1.61803, 0, 1, 880.894, 0.778512, 651.614), c))
def test_zmap(self): # This is not in R, so tested by using: # (testcase[i]-mean(testcase,axis=0)) / sqrt(var(testcase)*3/4) y = mstats.zmap(self.testcase, self.testcase) desired_unmaskedvals = ([-1.3416407864999, -0.44721359549996, 0.44721359549996, 1.3416407864999]) assert_array_almost_equal(desired_unmaskedvals, y.data[y.mask == False], decimal=12)
def test_zmap(self): # This is not in R, so tested by using: # (testcase[i]-mean(testcase,axis=0)) / sqrt(var(testcase)*3/4) y = mstats.zmap(self.testcase, self.testcase) desired_unmaskedvals = ([-1.3416407864999, -0.44721359549996, 0.44721359549996, 1.3416407864999]) assert_array_almost_equal(desired_unmaskedvals, y.data[y.mask == False], decimal=12)
def test_line_search(): data = mlclass.ex4() x = add_bias(data['x']) y = data['y'] theta = array((.01, .01, .01)) p = -grad(x, y, theta, 0.) c = lambda alpha: cost(x, y, theta + alpha*p, 0.) assert_array_almost_equal((0.000739624, 0.685489), line_search(0., 1., c))
def test_create_interpolation_least_squares_domain_repetitive_extrapolation( self): "" n = 16 kh = 1.0 max_conv_factor = 0.3 a = hm.linalg.helmholtz_1d_operator(kh, n) location = np.arange(n) level = hm.setup.hierarchy.create_finest_level(a) # Generate relaxed test matrix. x = _get_test_matrix(a, n, 10, num_examples=8) coarsener = hm.setup.coarsening_uniform.UniformCoarsener( level, x, 4, repetitive=True) r, aggregate_size, num_components = coarsener.get_optimal_coarsening( max_conv_factor)[:3] assert aggregate_size == 6 assert num_components == 2 p = hm.setup.interpolation.create_interpolation_least_squares_domain( x, a, r, location, n, aggregate_size=aggregate_size, num_components=num_components, repetitive=True) num_test_examples = 5 x_test = x[:, -num_test_examples:] error_a = np.mean( norm(a.dot(x_test - p.dot(r.dot(x_test))), axis=0) / norm(x_test, axis=0)) assert p[0].nnz == 4 assert error_a == pytest.approx(0.492, 1e-2) assert p.shape == (16, 6) # To print p: #print(','.join(np.array2string(y, separator=",", formatter={'float_kind':lambda x: "%.2f" % x}) for y in np.array(p.todense()))) assert_array_almost_equal(p.todense(), [ [-0.26, 0.17, 0.00, 0.00, -0.20, 0.14], [0.07, 0.56, 0.00, 0.00, -0.08, 0.20], [0.27, 0.11, 0.00, 0.00, 0.16, 0.02], [0.34, -0.25, 0.01, -0.02, 0.00, 0.00], [-0.03, -0.40, -0.13, -0.05, 0.00, 0.00], [-0.30, -0.16, -0.11, -0.01, 0.00, 0.00], [-0.20, 0.14, -0.26, 0.17, 0.00, 0.00], [-0.08, 0.20, 0.07, 0.56, 0.00, 0.00], [0.16, 0.02, 0.27, 0.11, 0.00, 0.00], [0.00, 0.00, 0.34, -0.25, 0.01, -0.02], [0.00, 0.00, -0.22, -0.26, -0.39, 0.12], [0.00, 0.00, -0.38, 0.04, -0.04, 0.55], [0.00, 0.00, 0.16, 0.02, 0.27, 0.11], [0.01, -0.02, 0.00, 0.00, 0.34, -0.25], [-0.13, -0.05, 0.00, 0.00, -0.03, -0.40], [-0.11, -0.01, 0.00, 0.00, -0.30, -0.16], ], decimal=2)
def test_2D(self): a = ma.array(((1, 2, 3, 4), (1, 2, 3, 4), (1, 2, 3, 4)), mask=((0, 0, 0, 0), (1, 0, 0, 1), (0, 1, 1, 0))) actual = mstats.hmean(a) desired = ma.array((1, 2, 3, 4)) assert_array_almost_equal(actual, desired, decimal=14) actual1 = mstats.hmean(a, axis=-1) desired = (4.0 / (1 / 1.0 + 1 / 2.0 + 1 / 3.0 + 1 / 4.0), 2.0 / (1 / 2.0 + 1 / 3.0), 2.0 / (1 / 1.0 + 1 / 4.0)) assert_array_almost_equal(actual1, desired, decimal=14)
def test_savitzky_golay(self): t = np.linspace(-4, 4, 100) # noise = np.random.normal(0, 0.05, t.shape) noise = np.array([-0.0100738410948, 0.0434144660993, -0.00378151879776, 0.0113356386249, 0.00435077505515, -0.0477602072563, 0.0373494077292, -0.0133865881648, -0.058259106898, 0.0661995082581, -0.0302004598725, 0.0251073570423, 0.0504480752083, 0.00591197638959, -0.0936100824835, -0.0475801028574, 0.164260739963, 0.000309393717298, 0.0145265378376, 0.0451974209359, -0.0296464887607, 0.00113264461646, 0.0203243951278, 0.0250086489045, 0.0286663554031, 0.0162585459204, -0.0285237485127, 0.0841528003829, -0.0449728982279, 0.0549796633406, -0.0968901623365, 0.0306727572312, -0.06950957371, 0.00598396964893, 0.0583904237732, 0.0271856795988, 0.0503237614252, 0.179978222833, 0.0909965842309, -0.037723727536, 0.0766788834896, -0.135152061379, -0.0275445486266, 0.00437867535899, -0.0272885999582, -0.0167170993005, 0.0522077667657, -0.044618733434, -0.0323362657615, 0.0122726298648, 0.0311304227245, -0.106361849439, 0.0526578516171, 0.0600674983294, 0.0745276212563, -0.0488453979797, -0.000833273665862, 0.0232768529385, 0.0138869047145, -0.0581069396022, 0.0321001340163, -0.023975724861, -0.0281919023447, 0.0341550408589, -0.0128104984676, -0.0214928514613, -0.0930630211028, -0.086094936458, 0.0169055851217, -0.0106085935018, 0.0114499301052, 0.120823119533, 0.0401375561218, 0.0979979215035, -0.015930504967, 0.0730359376807, -0.0369380623571, 0.0628171477772, -0.0271592027456, -0.0805267873905, -0.047314352792, -0.00693573205681, -0.0276294819462, -0.00896110691771, 0.0248482543453, 0.0877066047642, -0.0325533337143, -0.0638923240986, 0.0512523528302, 0.0720952473332, 0.00555629231342, 0.0562912258368, 0.0518574742355, -0.0599288505845, 0.0129657160415, -0.0025435076237, -0.0136966498082, 0.0260013064028, 0.0315561663839, -0.0293194006299]) # @IgnorePep8 # print(', '.join(['{0}'.format(y) for y in noise])) y = np.exp(-t**2) + noise ysg = SavitzkyGolay(n=20, degree=2).smooth(y) # print(', '.join(['{0}'.format(y) for y in ysg])) assert_array_almost_equal(ysg,[0.08136940307, 0.0628995512206, 0.0459066440291, 0.0303906814954, 0.0163516636196, 0.00378959040169, -0.00729553815838, -0.0169037220606, -0.0250349613049, -0.0316892558914, -0.03686660582, -0.0405670110908, -0.0427904717036, -0.0435369876586, -0.0428065589558, -0.0405991855951, -0.0369148675765, -0.0317536049001, -0.0251153975657, -0.0170002455736, -0.00740814892354, 0.00138883298422, 0.00903982318392, 0.0156981288342, 0.0262571138525, 0.038712235996, 0.0497401536595, 0.0708145615737, 0.0930139468092, 0.115399487253, 0.145859174356, 0.181612636791, 0.217133614374, 0.257717904903, 0.300137304571, 0.345750694351, 0.392370647909, 0.447698806473, 0.498669071812, 0.552242388661, 0.602481962016, 0.649961345551, 0.695325299394, 0.735374047294, 0.773010811455, 0.805919165272, 0.834865852047, 0.854796400219, 0.86842923705, 0.871717227059, 0.870973756546, 0.854091989437, 0.838398655214, 0.810673923439, 0.783634317013, 0.749908334726, 0.714315301461, 0.67175727743, 0.634614314389, 0.593943523363, 0.54497174327, 0.497539947485, 0.442464744684, 0.39039262486, 0.339641566641, 0.287962531039, 0.243889096129, 0.20650960823, 0.165038163827, 0.127423305227, 0.098217909507, 0.0723906956301, 0.0457840790019, 0.0325691800506, 0.0207065223098, 0.0137400799931, 0.00547944733578, -0.000268557810876, -0.00301934919753, -0.00213643706217, -0.0101846106787, -0.0170002602175, -0.0225833856784, -0.0269339870616, -0.030052064367, -0.0319376175946, -0.0325906467444, -0.0320111518164, -0.0301991328106, -0.0271545897271, -0.0228775225657, -0.0173679313266, -0.0106258160097, -0.00265117661497, 0.00655598685753, 0.0169956744078, 0.0286678860359, 0.0415726217417, 0.0557098815254, 0.0710796653868]) # @IgnorePep8
def test_gram_schmidt(self): a = np.random.random((10, 4)) q = hm.linalg.gram_schmidt(a) q_expected = _gram_schmidt_explicit(a) assert_array_almost_equal( hm.linalg.normalize_signs(q, axis=1), hm.linalg.normalize_signs(q_expected, axis=1))
def test_ctm_adjoint(): scen, control = small_scenario() state = CTMSimulator().simulate(scen, control) hx = CTMAdjoint(scen).hx(state, control) hu = CTMAdjoint(scen).hu(state, control) assert_array_equal(hx, np.tril(hx)) u = np.ones(control.flatten().shape) * 0.01 adjoint = CTMAdjoint(scen) assert_array_almost_equal(adjoint.grad(u), adjoint.grad_fd(u), 3)
def test_bracket(): data = mlclass.ex4() x = add_bias(data['x']) y = data['y'] theta = array((.01, .01, .01)) p = -grad(x, y, theta, 0.) c = lambda alpha: nan_guard(cost(x, y, theta + alpha*p, 0.)) assert_array_almost_equal((-1.61803, 0, 1, 880.894, 0.778512, 651.614), bracket(0., 1., c), decimal=3)
def test_min_sample_size_axis(self): data = [[40.0, 0.0, 40.0, 0.0], [40.0, 0.0, 40.0, 0.0]] self.assertAlmostEqual(2236.5791393864079, min_sample_size(data, 0.95, 0.05)) x = 4051.185794406982 assert_array_almost_equal([x, x], min_sample_size(data, .95, .05, 1))
def test_zscore_multicolumns(): input_ = np.random.rand(10, 3) sc_zscore = stats.zscore(input_, axis=0, ddof=1) da_input = HomogenNumericTable(input_) da_zscore = z_score(da_input) np_da_zscore = getNumpyArray(da_zscore) assert_array_almost_equal(sc_zscore, np_da_zscore)
def test_2D(self): a = ma.array(((1, 2, 3, 4), (1, 2, 3, 4), (1, 2, 3, 4)), mask=((0, 0, 0, 0), (1, 0, 0, 1), (0, 1, 1, 0))) actual = mstats.hmean(a) desired = ma.array((1, 2, 3, 4)) assert_array_almost_equal(actual, desired, decimal=14) actual1 = mstats.hmean(a, axis=-1) desired = (4. / (1 / 1. + 1 / 2. + 1 / 3. + 1 / 4.), 2. / (1 / 2. + 1 / 3.), 2. / (1 / 1. + 1 / 4.)) assert_array_almost_equal(actual1, desired, decimal=14)
def test_scaled_norm_of_matrix_3d(self): num_functions = 4 x = 2 * np.random.random((10, 2, num_functions)) - 1 actual = hm.linalg.scaled_norm_of_matrix(x) y = x.reshape(20, num_functions) factor = 1 / np.prod(x.shape[:-1])**0.5 expected = factor * np.array( [norm(y[:, i]) for i in range(y.shape[1])]) assert_array_almost_equal(actual, expected, 10)
def test_gauss_seidel_sweep_same_as_loop_implementation(self): n = 16 kh = 0.5 a = hm.linalg.helmholtz_1d_operator(kh, n) relaxer = hm.solve.relax.GsRelaxer(a) x = np.random.random((n, 5)) b = np.zeros_like(x) for i in range(10): y = gs_relax_with_loop(kh, x) x = relaxer.step(x, b) assert_array_almost_equal(x - x.mean(), y - y.mean())
def test_penalize_nothing_var(): adj1, _ = dumb_admm_system() old_ju1 = adj1.ju alpha = 0.0 def new_ju1(x, u): ju = old_ju1(x, u) ju[1] = alpha * 2 * (u[1] - 3.0) return ju adj1.ju = new_ju1 assert_array_almost_equal(AcceleratedGradient().solve(adj1, numpy.zeros(2)), [1.0, 0.0], 3) alpha = 1.0 assert_array_almost_equal(AcceleratedGradient().solve(adj1, numpy.zeros(2)), [1.0, 3.0], 3)
def test_ridge_regression_against_scikit(rows=10, columns=9): ''' Test prediction daal against scikit :param rows: :param columns: ''' inout = get_random_array(rows, columns) x = inout[0] y = inout[1] daal_predicted = get_daal_prediction(x, y) scik_predicted = get_scikit_prediction(x, y) assert_array_almost_equal(daal_predicted, scik_predicted)
def test_td_target(): trials = 10 time_steps = 100 rewards = np.random.normal(size=(trials, time_steps, 1)) values = np.random.normal(size=(trials, time_steps, 1)) gamma = .9 expected_result = rewards.copy() expected_result[:, :-1, :] += gamma * values[:, 1:, :] assert_array_almost_equal(expected_result, td_target(gamma, rewards, values))
def test_spaceGroupQuery(self): sg = self.stru2.sg assert sg.number is 225 assert sg.num_sym_equiv is 192 assert sg.num_primitive_sym_equiv is 48 assert sg.short_name=='Fm-3m' assert sg.alt_name=='F M 3 M' assert sg.point_group_name=='PGm3barm' assert sg.crystal_system=='CUBIC' assert sg.pdb_name=='F 4/m -3 2/m' assert_array_almost_equal(sg.symop_list[1].R, numpy.identity(3)) assert_array_almost_equal(sg.symop_list[1].t, numpy.array([ 0. , 0.5, 0.5]))
def test_spaceGroupQuery(self): sg = self.stru2.sg assert sg.number is 225 assert sg.num_sym_equiv is 192 assert sg.num_primitive_sym_equiv is 48 assert sg.short_name=='Fm-3m' assert sg.alt_name=='F M 3 M' assert sg.point_group_name=='PGm3barm' assert sg.crystal_system=='CUBIC' assert sg.pdb_name=='F 4/m -3 2/m' assert_array_almost_equal(sg.symop_list[1].R, numpy.identity(3)) assert_array_almost_equal(sg.symop_list[1].t, numpy.array([ 0. , 0.5, 0.5]))
def test_discount(): trials = 10 time_steps = 100 rewards = np.random.normal(size=(trials, time_steps)) gamma = .9 expected_result = np.empty(shape=(trials, time_steps)) for i in range(time_steps): discount_vec = gamma**np.arange(time_steps - i) expected_result[:, i] = np.dot(rewards[:, i:], discount_vec) assert_array_almost_equal(expected_result, discount(gamma, rewards))
def test_pairwise_cos_similarity(self): # Compare with explicit summation. x = 2 * np.random.random((10, 4)) - 1 y = 2 * np.random.random((10, 3)) - 1 x[:, 0] = 0 actual = hm.linalg.pairwise_cos_similarity(x, y) expected = np.array([[ sum(x[:, i] * y[:, j]) / np.clip( (sum(x[:, i]**2) * sum(y[:, j]**2))**0.5, 1e-15, None) for j in range(y.shape[1]) ] for i in range(x.shape[1])]) assert_array_almost_equal(actual, expected, 10)
def test_confidence_interval_axis(self): data = [[8.0, 7.0, 5.0, 9.0, 9.5, 11.3, 5.2, 8.5], [8.0, 7.0, 5.0, 9.0, 9.5, 11.3, 5.2, 8.5]] assert_array_almost_equal([1.67722628, 1.67722628], half_confidence_interval_size(data, .95, axis=1)) assert_array_almost_equal([ 0., 0., 0., 0., 0., 0., 0., 0.], half_confidence_interval_size(data, .95, axis=0)) self.assertAlmostEqual(1.06902922476, half_confidence_interval_size(data, .95))
def test_helmholtz_1d_operator(self): kh = 1.5 n = 8 a = hm.linalg.helmholtz_1d_operator(kh, n) a_expected = \ [[0.25, 1., 0., 0., 0., 0., 0., 1.], [1., 0.25, 1., 0., 0., 0., 0., 0.], [0., 1., 0.25, 1., 0., 0., 0., 0.], [0., 0., 1., 0.25, 1., 0., 0., 0.], [0., 0., 0., 1., 0.25, 1., 0., 0.], [0., 0., 0., 0., 1., 0.25, 1., 0.], [0., 0., 0., 0., 0., 1., 0.25, 1.], [1., 0., 0., 0., 0., 0., 1., 0.25]] assert_array_almost_equal(a.toarray(), a_expected)
def test_create_uniform_coarsening_domain_indivisible_size(self): n = 17 kh = 0.5 aggregate_size = 4 a = hm.linalg.helmholtz_1d_operator(kh, n) # Generate relaxed test matrix. x = _get_test_matrix(a, n, 10) # Generate coarse variables (R) on the non-repetitive domain. coarsener = hm.setup.coarsening_uniform.FixedAggSizeUniformCoarsener(x, aggregate_size, repetitive=True) result = coarsener.all_candidate_coarsening() # For a cycle index of 1, the max coarsening ratio is 0.7, and aggregate_size * 0.7 = 2.8, so we can have at # most # 2 PCs per aggregate. assert len(result) == 2 r_values = np.array([item[1][0] for item in result]) mean_energy_error = np.array([item[1][1] for item in result]) assert_array_almost_equal(mean_energy_error, [0.477069, 0.175552], decimal=5) assert r_values[0].shape == (5, 17) r = r_values[1] assert r.shape == (10, 17) # To print r: # print(','.join(np.array2string(y, separator=",", formatter={'float_kind':lambda x: "%.2f" % x}) # for y in np.array(r.todense()))) assert_array_almost_equal( r.todense(), [ [-0.27, -0.53, -0.62, -0.52, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00], [0.70, 0.38, -0.12, -0.59, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00], [0.00, 0.00, 0.00, 0.00, -0.27, -0.53, -0.62, -0.52, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00], [0.00, 0.00, 0.00, 0.00, 0.70, 0.38, -0.12, -0.59, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00], [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, -0.27, -0.53, -0.62, -0.52, 0.00, 0.00, 0.00, 0.00, 0.00], [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.70, 0.38, -0.12, -0.59, 0.00, 0.00, 0.00, 0.00, 0.00], [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, -0.27, -0.53, -0.62, -0.52, 0.00], [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.70, 0.38, -0.12, -0.59, 0.00], [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, -0.27, -0.53, -0.62, -0.52], [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.70, 0.38, -0.12, -0.59] ], decimal=2)
def test_linear_regression_daal_vs_sklearn(rows=10, columns=9, verbose=False): inout = get_random_array(rows, columns) x = inout[0] y = inout[1] start_sklearn = time.time() lin_solver_sklearn = h2o4gpu.LinearRegression(verbose=True, backend='sklearn') lin_solver_sklearn.fit(x, y) sklearn_predicted = lin_solver_sklearn.predict(x) end_sklearn = time.time() print(("Sklearn prediction: ", sklearn_predicted) if verbose else "", end="") start_daal = time.time() lin_solver_daal = h2o4gpu.LinearRegression( fit_intercept=True, verbose=True, backend='daal', method=LinearMethod.normal_equation) lin_solver_daal.fit(x, y) daal_predicted = lin_solver_daal.predict(x) end_daal = time.time() print(("Daal prediction: ", daal_predicted) if verbose else "", end="") print("Prediction calculated:") print("+ Sklearn: {}".format(end_sklearn - start_sklearn)) print("+ Daal: {}".format(end_daal - start_daal)) assert_array_almost_equal(daal_predicted, sklearn_predicted, decimal=4) assert_array_almost_equal(daal_predicted, y, decimal=4) if os.getenv("CHECKPERFORMANCE") is not None: assert end_daal - start_daal <= end_sklearn - start_sklearn sklearn_score = lin_solver_sklearn.score(x, y) daal_score = lin_solver_daal.score(x, y) print("Score calculated: ") print("+ Sklearn: {}".format(sklearn_score)) print("+ Daal: {}".format(daal_score)) assert daal_score == sklearn_score
def check_equal(cdfmapping, mapping): assert_array_equal(cdfmapping.img.shape, mapping.img.shape) assert_array_equal(cdfmapping.lats.shape, mapping.lats.shape) assert_array_equal(cdfmapping.img, mapping.img) assert_array_equal(cdfmapping.lats, mapping.lats) assert_array_equal(cdfmapping.lons, mapping.lons) assert_array_equal(cdfmapping.latsCenter, mapping.latsCenter) assert_array_equal(cdfmapping.lonsCenter, mapping.lonsCenter) assert_equal(cdfmapping.boundingBox, mapping.boundingBox) # elevation is stored as float32, so there is some loss of accuracy assert_array_almost_equal(cdfmapping.elevation, mapping.elevation, decimal=5) assert_equal(cdfmapping.photoTime, mapping.photoTime) assert_equal(cdfmapping.cameraPosGCRS, mapping.cameraPosGCRS)
def test_sparse_circulant(self): vals = np.array([1, 2, 3, 5, 4]) offsets = np.array([-2, -1, 0, 2, 1]) n = 8 a = hm.linalg.sparse_circulant(vals, offsets, n) a_expected = \ [[3., 4., 5., 0., 0., 0., 1., 2.], [2., 3., 4., 5., 0., 0., 0., 1.], [1., 2., 3., 4., 5., 0., 0., 0.], [0., 1., 2., 3., 4., 5., 0., 0.], [0., 0., 1., 2., 3., 4., 5., 0.], [0., 0., 0., 1., 2., 3., 4., 5.], [5., 0., 0., 0., 1., 2., 3., 4.], [4., 5., 0., 0., 0., 1., 2., 3.]] assert_array_almost_equal(a.toarray(), a_expected)
def test_gauss_seidel_sweep_reduces_energy_for_spd(self): n = 16 kh = 0 # Make a positive definite (= -Laplacian). a = -hm.linalg.helmholtz_1d_operator(kh, n) relaxer = hm.solve.relax.GsRelaxer(a) x = np.random.random((n, 1)) b = np.zeros_like(x) energy = x.T.dot(a.dot(x))[0, 0] for i in range(10): y = gs_relax_with_loop(kh, x) x = relaxer.step(x, b) assert_array_almost_equal(x - x.mean(), y - y.mean()) energy_new = x.T.dot(a.dot(x))[0, 0] assert energy_new < energy energy = energy_new
def test_case(self): model = clone(estimator) model.fit(**fit_data) for method in methods: pred = getattr(model, method)(**predict_data) code = sklearn2code(model, method, numpy_flat) try: module = exec_module('test_module', code) exported_pred = getattr(module, method)(**export_predict_data['X']) if isinstance(exported_pred, tuple): exported_pred = DataFrame(dict(enumerate(exported_pred))) assert_array_almost_equal(pred, exported_pred, 3) except: # print(code) # import clipboard # clipboard.copy(code) raise
def test_svd_simple_check(): indata = np.array([[1, 3, 4], [5, 6, 9], [1, 2, 3], [7, 6, 8]]) dataSource = HomogenNumericTable(indata) algorithm = svd.Batch() algorithm.input.set(svd.data, dataSource) result = algorithm.compute() sigma = getNumpyArray(result.get(svd.singularValues)) U = getNumpyArray(result.get(svd.leftSingularMatrix)) V = getNumpyArray(result.get(svd.rightSingularMatrix)) # create diagonal matrix of Singular values _rows, cols = sigma.shape d_sigma = sigma.reshape(cols, ) outdata = np.dot(U, np.dot(np.diag(d_sigma), V)) assert_array_almost_equal(outdata, indata)
def test_ritz(self): n = 16 kh = 0 a = hm.linalg.helmholtz_1d_operator(kh, n) x = np.random.random((n, 4)) action = lambda x: a.dot(x) y, lam_y = hm.linalg.ritz(x, action) lam_y_expected = np.array( [_rq(y[:, k], action) for k in range(y.shape[1])]) assert_array_almost_equal(lam_y, lam_y_expected) assert y.shape == x.shape r = action(y) r = np.array([r[:, k] - lam_y[k] * y[:, k] for k in range(y.shape[1])]) assert norm(r.dot(x)) < 1e-14
def test_tile_csr_matrix(self): n = 4 kh = 0.5 a = hm.linalg.helmholtz_1d_operator(kh, n) a_expected = \ [[-1.75, 1., 0., 1.], [1., -1.75, 1., 0.], [0., 1., -1.75, 1.], [1., 0., 1., -1.75]] assert_array_almost_equal(a.toarray(), a_expected) for growth_factor in range(2, 5): a_tiled = hm.linalg.tile_csr_matrix(a, growth_factor) a_tiled_expected = hm.linalg.helmholtz_1d_operator( kh, growth_factor * n).tocsr() assert_array_almost_equal(a_tiled.toarray(), a_tiled_expected.toarray())
def test_all(self): for i, node in enumerate(self.nodes): assert_array_almost_equal(AcceleratedGradient(50).solve(node.f, numpy.ones(2) * 10), [i] * 2) graph = Graph(self.nodes, self.edges) problem = MultiAgentProblem(graph, 100) problem.solve() for edge in self.edges: assert_array_almost_equal(edge.x_values(edge.l_node), edge.x_values(edge.r_node) * -1.0, 2) for i, node in enumerate(self.nodes): x = node.x if i is 0: self.assertAlmostEqual(x[0], 0.0, 2) else: self.assertAlmostEqual(x[0], i - 0.5, 2) if i is self.n - 1: self.assertAlmostEqual(x[1], i, 2) else: self.assertAlmostEqual(x[1], i + 0.5, 2)
def test_tile_csr_matrix_level2_operator(self): a = np.array([[-0.16, 0.05, 0.18, 0.35, 0., 0., 0.18, -0.21], [0.05, -1.22, -0.21, -0.42, 0., 0., 0.35, -0.42], [0.18, -0.21, -0.16, 0.05, 0.18, 0.35, 0., 0.], [0.35, -0.42, 0.05, -1.22, -0.21, -0.42, 0., 0.], [0., 0., 0.18, -0.21, -0.16, 0.05, 0.18, 0.35], [0., 0., 0.35, -0.42, 0.05, -1.22, -0.21, -0.42], [0.18, 0.35, 0., 0., 0.18, -0.21, -0.16, 0.05], [-0.21, -0.42, 0., 0., 0.35, -0.42, 0.05, -1.22]]) a_tiled = hm.linalg.tile_csr_matrix(scipy.sparse.csr_matrix(a), 2) # The tiled operator should have blocks of of 2 6-point stencils that are periodic on 16 points. wrapped_around = np.zeros_like(a) wrapped_around[-2:, :2] = a[-2:, :2] wrapped_around[:2, -2:] = a[:2, -2:] a_tiled_expected = np.block([[a - wrapped_around, wrapped_around], [wrapped_around, a - wrapped_around]]) assert_array_almost_equal(a_tiled.toarray(), a_tiled_expected)
def test_admm_on_dumb(): adj1, adj2 = dumb_admm_system() xymap1 = [] xymap2 = [] uymap1 = [0, 1] uymap2 = [0, 1] yzmap1 = [0, 1] yzmap2 = [1, 0] data1 = AdjointAdmmData(adj1, xymap1, uymap1, yzmap1, numpy.zeros(2), rho=.5) data2 = AdjointAdmmData(adj2, xymap2, uymap2, yzmap2, numpy.zeros(2), rho=.5) sp1 = AdjointAdmmSubProblem(data1, solver=AcceleratedGradient()) sp2 = AdjointAdmmSubProblem(data2, solver=AcceleratedGradient()) def objective(problem): return (problem.z[0] - 1) ** 2 + (problem.z[1] - 2) ** 2 + sum( [sp.data.admm_cost() for sp in problem.sub_problems]) problem = Admm([sp2, sp1], n_iters=40, objective=objective) problem.solve() assert_array_almost_equal(problem.z, [1.0, 2.0])
def test_dataset_to_instances(self, default_rank = [1, 2, 3, 4, 5]): #create the final numpy array manually and see if the conversion happens ok newdata = [] default_rank = Ranking(default_rank).inverse().integers() for i in range(1, 101): for rank_strings in range(5): vector = sorted([(str(k),k+rank_strings) for k in range(20)]) vector = np.array([float(v) for _, v in vector]) #newdata.append([vector, int(rank_strings)+1, i]) newdata.append([vector, default_rank[rank_strings], i]) newdata = np.array(newdata) newmetadata = {'input_size' : 20, #size of feature vector 'scores' : set([1, 2, 3, 4, 5])} data, metadata = dataset_to_instances(self.train_filename).raw_source() for i in range(np.shape(data)[0]): vector1, rank1, query1 = data[i] vector2, rank2, query2 = newdata[i] assert_array_almost_equal(vector1, vector2, err_msg="MLPython: error in the conversion of batch data") assert_equal(rank1, rank2, err_msg="MLPython: error in the conversion of rank_strings value") assert_equal(query1, query2) assert_equal(metadata, newmetadata, err_msg="MLPython: error in the conversion of metadata")
def test_chisquare_masked_arrays(): # The other tests were taken from the tests for stats.chisquare, so # they don't test the function with masked arrays. Here masked arrays # are tested. obs = np.array([[8, 8, 16, 32, -1], [-1, -1, 3, 4, 5]]).T mask = np.array([[0, 0, 0, 0, 1], [1, 1, 0, 0, 0]]).T mobs = ma.masked_array(obs, mask) expected_chisq = np.array([24.0, 0.5]) chisq, p = mstats.chisquare(mobs) assert_array_equal(chisq, expected_chisq) assert_array_almost_equal(p, stats.chisqprob(expected_chisq, mobs.count(axis=0) - 1)) chisq, p = mstats.chisquare(mobs.T, axis=1) assert_array_equal(chisq, expected_chisq) assert_array_almost_equal(p, stats.chisqprob(expected_chisq, mobs.T.count(axis=1) - 1)) # When axis=None, the two values should have type np.float64. chisq, p = mstats.chisquare([1,2,3], axis=None) assert_(isinstance(chisq, np.float64)) assert_(isinstance(p, np.float64)) assert_equal(chisq, 1.0) assert_almost_equal(p, stats.chisqprob(1.0, 2))
def test_both(): t = 3 nl = 2 nr = 2 zl = numpy.zeros(t) zr = numpy.zeros(t) p = numpy.zeros(t) beta = .5 cl = LeftAdmm(zl, p, beta, t, nl).no_control() cr = RightAdmm(zl, p, beta, t, nl).no_control() for i in range(100): l = LeftAdmm(zl, p, beta, t, nl) cl = l.optimal_control() xl = l.fs(cl)[nl - 1, :] cr = RightAdmm(zr, p, beta, t, nr).optimal_control() xr = cr[[0] + range(nr, len(cr))] v = -p + beta / 2.0 * (xl - xr) zl = 1.0 / beta * (-p - v) + xl zr = 1.0 / beta * (-p - v) - xr p = -v fsl = LeftAdmm(zl, p, beta, t, nl).solve() fsr = RightAdmm(zr, p, beta, t, nl).solve() assert_array_almost_equal(fsl[-1, :], fsr[0, :], 7) assert_array_almost_equal(numpy.concatenate((fsl[:-1, :], fsr), 0), numpy.eye(3) / 3.0, 3)
def test_2D(self): a = ma.array(((1, 2, 3, 4), (1, 2, 3, 4), (1, 2, 3, 4)), mask=((0, 0, 0, 0), (1, 0, 0, 1), (0, 1, 1, 0))) actual = mstats.gmean(a) desired = np.array((1, 2, 3, 4)) assert_array_almost_equal(actual, desired, decimal=14) desired1 = mstats.gmean(a, axis=0) assert_array_almost_equal(actual, desired1, decimal=14) actual = mstats.gmean(a, -1) desired = ma.array((np.power(1 * 2 * 3 * 4, 1.0 / 4.0), np.power(2 * 3, 1.0 / 2.0), np.power(1 * 4, 1.0 / 2.0))) assert_array_almost_equal(actual, desired, decimal=14)
def test_vs_nonmasked(self): x = np.array((-2, -1, 0, 1, 2, 3) * 4) ** 2 assert_array_almost_equal(mstats.normaltest(x), stats.normaltest(x)) assert_array_almost_equal(mstats.skewtest(x), stats.skewtest(x)) assert_array_almost_equal(mstats.kurtosistest(x), stats.kurtosistest(x)) funcs = [stats.normaltest, stats.skewtest, stats.kurtosistest] mfuncs = [mstats.normaltest, mstats.skewtest, mstats.kurtosistest] x = [1, 2, 3, 4] for func, mfunc in zip(funcs, mfuncs): assert_raises(ValueError, func, x) assert_raises(ValueError, mfunc, x)
def test_hampelfilter(self): Y = np.array([4979, 5002, 5004, 5000, 4987, 4989, 5008, 5013, 5000, 4996, 5026, 5000, 5003, 4988, 4991, 5017, 5013, 5004, 4990, 4997, 5010, 5007, 5001, 4970, 5002, 4986, 5032, 5003, 4994, 5001, 4988, 4998, 5002, 4996, 4988, 5009, 5003, 4986, 4996, 4994, 4997, 5003, 5012, 5002, 5001, 5006, 5006, 4986, 4998, 4978, 4995, 4999, 4987, 5015, 5009, 5016, 4995, 5007, 5013, 4996, 5018, 4992, 4989, 4994, 4991, 4995, 5018, 5007, 5008, 4990, 5010, 4986, 5009, 4999, 5008, 5000, 5001, 5000, 5004, 5032, 5009, 5005, 5014, 5000, 4992, 4994, 4991, 4993, 5000, 5005, 4993, 5003, 4995, 4980, 4995, 4999, 5007, 5000, 4988, 4982, 5030, 4997, 4993, 5009, 4993, 5020, 5010, 4997, 4987, 4999, 5006, 4984, 5000, 4987, 4986, 5006, 5002, 5001, 5003, 4996, 4994, 5002, 4989, 4998, 4996, 5007, 4993, 4998, 5001, 4989, 5012, 5001, 5010, 4996, 5004, 5008, 5002, 5024, 4997, 5001, 5010, 5023, 4996, 5018, 5002, 4990, 5009, 4997, 5016, 5000, 5013, 5008, 4990, 5011, 4996, 5010, 5004, 5023, 4999, 5004, 4996, 5011, 4998, 5000, 4988, 5000, 4993, 4998, 5000, 5006, 5010, 4988, 5000, 4997, 4995, 4996, 5005, 5003, 5009, 5009, 4997, 5010, 5014, 4990, 5013, 5015, 5011, 4987, 5004, 4999, 5030, 5000, 5000, 4999, 5013, 5012, 5001, 5012, 4995, 4997, 4995, 4985, 4989, 5007, 5010, 4997, 5011, 4995, 5000, 5011, 4998, 4991, 5021, 5003, 4985, 4991, 4995, 5018, 4979, 5003, 5011, 5009, 5001, 4998, 5008, 4994, 5016, 4992, 5008, 4993, 4983, 5010, 5023, 4975, 4987, 4994, 5002, 4984, 5005, 5006, 5005, 5000, 4996, 5000, 4999, 5004, 4994, 5000, 4981, 5001, 4994, 4993, 5000, 5004, 5001, 4992, 5002, 5006, 4997, 4987, 5001, 5008, 5011, 4995, 5006, 4976, 4999, 4989, 5008, 4996, 4997, 5006, 5005, 5007, 4990, 5010, 4996, 4998, 5000, 5014, 5002, 5001, 4996, 4997, 5000, 5003, 5000, 4986, 5013, 5001, 4990, 4990, 5010, 5000, 5021, 5000, 5006, 4995, 5012, 5019, 5000, 5006, 4999, 5007, 5014, 5000, 4994, 4991, 5010, 4985, 4988, 5007, 5005, 5000, 5005, 4997, 4995, 4987, 5000, 5000, 5009, 5000, 4999, 5011, 5018, 4994, 5000, 4995, 5000, 5008, 4994, 4992, 5000, 4998, 4992, 5006, 4996, 5000, 5018, 5000, 5022, 5002, 5007, 5000, 5012, 5014, 5010, 4997, 4996, 5014, 4995, 4991, 5006, 4992, 5008, 5004, 4995, 5016, 4974, 5005, 5000, 4985, 5002, 5000, 5009, 4991, 4995, 5004, 4987, 5014, 4986, 5008, 4985, 4995, 5010, 5000, 5001, 5013, 4988, 5001, 5002, 4986, 4985, 5001, 4995, 5004, 4998, 4998, 4992, 5003, 5000, 4991, 4998, 5002, 5011, 4986, 5013, 4997, 5000, 4997, 5003, 5014, 4998, 5002, 5006, 5015, 4992, 4992, 4995, 4998, 4994, 5007, 4977, 5004, 5005, 4990, 4991, 5001, 5010, 4991, 4990, 5006, 5004, 5004, 4997, 5001, 4992, 5000, 5000, 4996, 4987, 4993, 5001, 5006, 4999, 4993, 4999, 5001, 5001, 5014, 4985, 5010, 5006, 4989, 5002, 5011, 4999, 5010, 5005, 5002, 5010, 4990, 4994, 5000, 4985, 5010, 5000, 4999, 5000, 4977, 5007, 5005, 4990, 5000, 4985, 5003, 5009, 5012, 5012, 5000, 5018, 4997, 5002, 4992, 4999, 4997, 5005, 5009, 4989, 5005, 4988, 5001, 5000, 5018, 4999, 5005, 4997, 5015, 5001, 4988, 4983, 5013, 4992, 5002, 5012, 4999, 5013, 5000, 4988, 4989, 4996, 5000, 5002, 4999, 5021, 4991, 5009, 5005, 4994, 5000, 4994, 4985, 4999, 4980, 5013, 5014, 5000, 4996, 5008, 5028, 5002, 5004, 4999, 5012, 4992, 5002, 4987, 5004, 5009, 5004, 5013, 4989, 5027, 4992, 5016, 5007, 5003, 5013, 5003, 4983, 5000, 4987, 5001, 4998, 4994, 4998, 4997, 5023, 4971, 5001, 4990, 5025, 5003, 4996, 5006, 5005, 4995, 4994, 5023, 5003, 5005, 4991, 5001, 5028, 4996, 5001, 5005, 5001, 5001, 5028, 4983, 5000, 5005, 5001, 4999, 5003, 4982, 5000, 5012, 5011, 5008, 5000, 4998, 4994, 4988, 5013, 4998, 5017, 4991, 5007, 5016, 5007, 4997, 4974, 4997, 5006, 5003, 5010, 5003, 4997, 4997, 4994, 4998, 4987, 5004, 4974, 5009, 5006, 5009, 4984, 5010, 5023, 5000, 5008, 4992, 5008, 4993, 5010, 5012, 4989, 5002, 4993, 5007, 4985, 4990, 4988, 4997, 5000, 4994, 5004, 4981, 5000, 4999, 5003, 4988, 5006, 5019, 5003, 4992, 4977, 4998, 4987, 4995, 4987, 5000, 4986, 4998, 4996, 5008, 5011, 5009, 5000, 4999, 5010, 4999, 5009, 5010, 4992, 4998, 4994, 5009, 4998, 5013, 5011, 4997, 5016, 4995, 5003, 4986, 5010, 4995, 4986, 5025, 4990, 5010, 4990, 4996, 5000, 5002, 4994, 5002, 5000, 5020, 4995, 5003, 5006, 5000, 4997, 4996, 5010, 4992, 5013, 4998, 4988, 4999, 5004, 5004, 5002, 5002, 5001, 4986, 5011, 5012, 4988, 5000, 5000, 5012, 5004, 5004, 4984, 5012, 4998, 5005, 5005, 5005, 4995, 4971, 5006, 5000, 5008, 5015, 4999, 4999, 4996, 5000, 4992, 5019, 5020, 4999, 4991, 5020, 5000, 5002, 5000, 5003, 4985, 4990, 5011, 5012, 4997, 4989, 4999, 5006, 4997, 4992, 4999, 4985, 4999, 5012, 5003, 4989, 5010, 5010, 5012, 4990, 4986, 5014, 5000, 4994, 5017, 4995, 5005, 5003, 5000, 5000, 4988, 5018, 5007, 5009, 5002, 5004, 4999, 5026, 4987, 4986, 5000, 4994, 5012, 5022, 4996, 5002, 4986, 4990, 4989, 5030, 4997, 5002, 5004, 4999, 5000, 4992, 4977, 4997, 4998, 5000, 4987, 5032, 4998, 5014, 4978, 5001, 4988, 5006, 5003, 5005, 5021, 5005, 5000, 5003, 4990, 4991, 4990, 5016, 5006, 4981, 5002, 4998, 4989, 4995, 5007, 5004, 5019, 5001, 5004, 5000, 4996, 4988, 5022, 5003, 5009, 4998, 5003, 4991, 5000, 4988, 5004, 5002, 4991, 4998, 4996, 4991, 5013, 5007, 5010, 5004, 5006, 5007, 4993, 5000, 5002, 4992, 4999, 4992, 5001, 4989, 4992, 5015, 5011, 5008, 5004, 4990, 4995, 4993, 5004, 4995, 4982, 5008, 5000, 4993, 5000, 5000, 4991, 5005, 5008, 5003, 4994, 4997, 5012, 4995, 5009, 5020, 5010, 5019, 4979, 5013, 4990, 5002, 5000, 5015, 4989, 5009, 4998, 5004, 5010, 4988, 4994, 5004, 4985, 4998, 4991, 4985, 4994, 4986, 5010, 4990, 5002, 5005, 5008, 5004, 4988, 4980, 5005, 4994, 5004, 4998, 4990, 5010, 5003, 5011, 4992, 5009, 5003, 5013, 4996, 4997, 4989, 4992, 5002, 4992, 4996, 4999, 5000, 5009, 4990, 4992, 5020, 4981, 5011, 5000, 5008, 4997, 4994, 4982, 5014, 5013, 4996, 5002, 5011, 5003, 5000, 5015, 4999, 5001, 5002, 5018, 4984, 5022, 5009, 5006, 5009, 5000, 4974, 4991, 5020, 5000, 4987, 5003, 4987, 5003, 5002, 5016, 4997, 5022, 5005, 4998, 4999, 5001, 5000, 5008, 5000, 5001, 4994, 4991, 4997, 4990, 4991, 4995, 5008, 5007, 4994, 5000, 5007, 4988, 5014, 5003, 4998, 4995, 5000, 5000, 5004], dtype=float) # @IgnorePep8 # randint = np.random.randint # Y = 5000 + np.int_(10*np.random.randn(1000)) # outliers = randint(0, 1000, size=(10,)) outliers = np.array([470, 795, 399, 614, 864, 37, 815, 112, 69, 16]) # noise = randint(1000, size=(10,)) noise = np.array([932, 286, 736, 427, 858, 63, 243, 264, 668, 844]) # print(', '.join(['{0:d}'.format(y) for y in Y])) Y[outliers] = Y[outliers] + noise YY, _res = HampelFilter(fulloutput=True)(Y) assert_array_almost_equal(YY[outliers], [5002, 5000, 5003, 5008, 5000, 4997, 4998, 4999, 5009, 4997]) assert_array_almost_equal(np.int_(YY), [5001, 5002, 5004, 5000, 4987, 4989, 5008, 5013, 5000, 4996, 5000, 5000, 5003, 4988, 4991, 5017, 4997, 5004, 4990, 4997, 5010, 5007, 5001, 4970, 5002, 4986, 5032, 5003, 4994, 5001, 4988, 4998, 5002, 4996, 4988, 5009, 5003, 4997, 4996, 4994, 4997, 5003, 5012, 5002, 5001, 5006, 5006, 4986, 4998, 4978, 4995, 4999, 4987, 5015, 5009, 5016, 4995, 5007, 5013, 4996, 5018, 4992, 4989, 4994, 4991, 4995, 5018, 5007, 5008, 5009, 5010, 5008, 5009, 4999, 5000, 5000, 5001, 5000, 5004, 5005, 5009, 5005, 5014, 5000, 4992, 4994, 4991, 4993, 5000, 5005, 4993, 5003, 4995, 4980, 4995, 4999, 5007, 5000, 4988, 4982, 5030, 4997, 4993, 5009, 4993, 5020, 5010, 4997, 4987, 4999, 5006, 4984, 4999, 4987, 4986, 5006, 5002, 5001, 5003, 4996, 4994, 5002, 4989, 4998, 4996, 5007, 4993, 4998, 5001, 4989, 5012, 5001, 5010, 4996, 5004, 5008, 5002, 5004, 4997, 5001, 5010, 5023, 4996, 5018, 5002, 4990, 5009, 4997, 5016, 5000, 5013, 5008, 4990, 5011, 4996, 5010, 5004, 5023, 4999, 5004, 4996, 5011, 4998, 5000, 4998, 5000, 4993, 4998, 5000, 5006, 5010, 4988, 5000, 4997, 4995, 4996, 5005, 5003, 5009, 5009, 4997, 5010, 5014, 5011, 5013, 5015, 5011, 4987, 5004, 4999, 5000, 5000, 5000, 4999, 5001, 5012, 5001, 5012, 4995, 4997, 4995, 4985, 4989, 5007, 5010, 4997, 5011, 4995, 5000, 5011, 4998, 4991, 5021, 5003, 4985, 4991, 4995, 5018, 4979, 5003, 5011, 5009, 5001, 4998, 5008, 4994, 5016, 4992, 5008, 4993, 4983, 5010, 5023, 4975, 4987, 4994, 5002, 5002, 5005, 5006, 5005, 5000, 4996, 5000, 4999, 5004, 5000, 5000, 4981, 5001, 4994, 4993, 5000, 5004, 5001, 4992, 5002, 5006, 4997, 4987, 5001, 5008, 5011, 4995, 5006, 4976, 4999, 4989, 5008, 4996, 4997, 5006, 5005, 5007, 4990, 5010, 4996, 4998, 5000, 5000, 5002, 5001, 4996, 4997, 5000, 5003, 5000, 5000, 5013, 5001, 4990, 4990, 5010, 5000, 5021, 5000, 5006, 4995, 5012, 5019, 5000, 5006, 4999, 5007, 5014, 5000, 4994, 4991, 5010, 4985, 4988, 5007, 5005, 5000, 5005, 4997, 4995, 4987, 5000, 5000, 5000, 5000, 4999, 5011, 5018, 4994, 5000, 4995, 5000, 5008, 4994, 4992, 5000, 4998, 4992, 5006, 4996, 5000, 5018, 5000, 5002, 5002, 5007, 5000, 5012, 5014, 5010, 4997, 4996, 5014, 4995, 4991, 5006, 4992, 5008, 5004, 4995, 5016, 5000, 5005, 5000, 4985, 5002, 5000, 5009, 4991, 4995, 5004, 4987, 5014, 4986, 5008, 4985, 4995, 5010, 5000, 5001, 5001, 5001, 5001, 5002, 4986, 5001, 5001, 4995, 5004, 4998, 4998, 4992, 5003, 5000, 4991, 4998, 5002, 5011, 5000, 5013, 4997, 5000, 5003, 5003, 5014, 4998, 5002, 5006, 5015, 4992, 4992, 4995, 4998, 4994, 5007, 4977, 5004, 5005, 4990, 4991, 4991, 4991, 4991, 5004, 5006, 5004, 5004, 4997, 5001, 4992, 5000, 5000, 4996, 4987, 4993, 5001, 5006, 4999, 4993, 4999, 5001, 5001, 5014, 4985, 5010, 5006, 4989, 5002, 5011, 4999, 5010, 5005, 5002, 5010, 4990, 4994, 5000, 4985, 5000, 5000, 4999, 5000, 5000, 5007, 5005, 4990, 5000, 4985, 5003, 5009, 5012, 5012, 5000, 5002, 4997, 5002, 4992, 4999, 4997, 5005, 5009, 4989, 5005, 4988, 5001, 5000, 5000, 4999, 5005, 4997, 5015, 5001, 4988, 4983, 5013, 4992, 5002, 5012, 4999, 5013, 5000, 4988, 4989, 4996, 5000, 5002, 4999, 5002, 4991, 5009, 5005, 4994, 5000, 4994, 4985, 4999, 4980, 5013, 5014, 5000, 4996, 5008, 5002, 5002, 5004, 4999, 5012, 4992, 5002, 4987, 5004, 5009, 5004, 5013, 4989, 5027, 4992, 5016, 5007, 5003, 5013, 5003, 5001, 5000, 4987, 5001, 4998, 4994, 4998, 4997, 4997, 4971, 5001, 4990, 5001, 5003, 4996, 5006, 5005, 4995, 5005, 5023, 5003, 5005, 4991, 5001, 5001, 4996, 5001, 5005, 5001, 5001, 5001, 5001, 5000, 5005, 5001, 4999, 5003, 5001, 5000, 5012, 5011, 5008, 5000, 4998, 4994, 4988, 5013, 4998, 5017, 4991, 5007, 5016, 5007, 4997, 5003, 4997, 5006, 5003, 5010, 5003, 4997, 4997, 4994, 4998, 4987, 5004, 5004, 5009, 5006, 5009, 5009, 5010, 5023, 5000, 5008, 5008, 5008, 4993, 5010, 5012, 4989, 5002, 4993, 4990, 4985, 4990, 4988, 4997, 5000, 4994, 5004, 5000, 5000, 4999, 5003, 5003, 5006, 5019, 5003, 4992, 4977, 4998, 4987, 4995, 4987, 5000, 4986, 4998, 4996, 5008, 5011, 5009, 5000, 5009, 5010, 4999, 5009, 5010, 4992, 4998, 4994, 5009, 4998, 5013, 5011, 4997, 5016, 4995, 5003, 4986, 5010, 4995, 4986, 5025, 4990, 5010, 4990, 4996, 5000, 5002, 4994, 5002, 5000, 5002, 4995, 5003, 5006, 5000, 4997, 4996, 4998, 4992, 5013, 4998, 4988, 4999, 5004, 5004, 5002, 5002, 5001, 4986, 5011, 5012, 4988, 5000, 5000, 5012, 5004, 5004, 4984, 5004, 5005, 5005, 5005, 5005, 5005, 5005, 5006, 5000, 5008, 5015, 4999, 4999, 4996, 5000, 4992, 5019, 5020, 4999, 4991, 5000, 5000, 5002, 5000, 5003, 4985, 4990, 5011, 5012, 4997, 4989, 4999, 4997, 4997, 4992, 4999, 4985, 4999, 5012, 5003, 5010, 5010, 5010, 5012, 5010, 4986, 5014, 5000, 4994, 5017, 4995, 5005, 5003, 5000, 5000, 4988, 5018, 5007, 5009, 5002, 5004, 4999, 5000, 4987, 4986, 5000, 4994, 5012, 5022, 4996, 5002, 4986, 4990, 4989, 4997, 4997, 5002, 5004, 4999, 5000, 4992, 4998, 4997, 4998, 5000, 5000, 5032, 4998, 5014, 4978, 5001, 5003, 5006, 5003, 5005, 5005, 5005, 5000, 5003, 4990, 4991, 4990, 5016, 5006, 4981, 4998, 4998, 4989, 4995, 5007, 5004, 5004, 5001, 5004, 5000, 4996, 4988, 5000, 5003, 5009, 4998, 5003, 4991, 5000, 4988, 5004, 5002, 4991, 4998, 4996, 4991, 5013, 5007, 5010, 5004, 5006, 5007, 4993, 5000, 5002, 4992, 4999, 4992, 5001, 4989, 4992, 5015, 5011, 5008, 5004, 4990, 4995, 4993, 5004, 5000, 4982, 5008, 5000, 4993, 5000, 5000, 4991, 5005, 5008, 5003, 4994, 4997, 5012, 4995, 5009, 5020, 5010, 5019, 4979, 5013, 4990, 5002, 5000, 5015, 4989, 5009, 4998, 5004, 5010, 4988, 4994, 5004, 4985, 4998, 4991, 4985, 4994, 4986, 5010, 4990, 5002, 5005, 5008, 5004, 4988, 5004, 5005, 4994, 5004, 4998, 4990, 5010, 5003, 5011, 4992, 5009, 5003, 5013, 4996, 4997, 4989, 4992, 5002, 4992, 4996, 4999, 5000, 5009, 4990, 4992, 5020, 4981, 5011, 5000, 5008, 4997, 4994, 4982, 5014, 5013, 4996, 5002, 5011, 5003, 5000, 5002, 4999, 5001, 5002, 5018, 4984, 5022, 5009, 5006, 5009, 5000, 4974, 4991, 5020, 5000, 4987, 5003, 5002, 5003, 5002, 5016, 4997, 5002, 5005, 4998, 4999, 5001, 5000, 5000, 5000, 5001, 4994, 4991, 4997, 4990, 4991, 4995, 5008, 5007, 4994, 5000, 5007, 4988, 5014, 5003, 4998, 4995, 5000, 5000, 5004]) # @IgnorePep8 YY1, _res1 = HampelFilter(dx=1, t=3, adaptive=0.1, fulloutput=True)(Y) assert_array_almost_equal(np.int_(YY1), [4999, 5002, 5004, 5000, 4987, 4989, 5008, 5013, 5000, 4996, 5026, 5000, 5003, 4988, 4991, 5017, 5003, 5004, 4990, 4997, 5010, 5007, 5001, 4970, 5002, 4986, 5032, 5003, 4994, 5001, 4988, 4998, 5002, 4996, 4988, 5009, 5003, 5001, 4996, 4994, 4997, 5003, 5012, 5002, 5001, 5006, 5006, 4986, 4998, 4978, 4995, 4999, 4987, 5015, 5009, 5016, 4995, 5007, 5013, 4996, 5018, 4992, 4989, 4994, 4991, 4995, 5018, 5007, 5008, 5006, 5010, 4986, 5009, 4999, 5008, 5000, 5001, 5000, 5004, 5004, 5009, 5005, 5014, 5000, 4992, 4994, 4991, 4993, 5000, 5005, 4993, 5003, 4995, 4980, 4995, 4999, 5007, 5000, 4988, 4982, 5030, 4997, 4993, 5009, 4993, 5020, 5010, 4997, 4987, 4999, 5006, 4984, 4998, 4987, 4986, 5006, 5002, 5001, 5003, 4996, 4994, 5002, 4989, 4998, 4996, 5007, 4993, 4998, 5001, 4989, 5012, 5001, 5010, 4996, 5004, 5008, 5002, 5024, 4997, 5001, 5010, 5023, 4996, 5018, 5002, 4990, 5009, 4997, 5016, 5000, 5013, 5008, 4990, 5011, 4996, 5010, 5004, 5023, 4999, 5004, 4996, 5011, 4998, 5000, 4988, 5000, 4993, 4998, 5000, 5006, 5010, 4988, 5000, 4997, 4995, 4996, 5005, 5003, 5009, 5009, 4997, 5010, 5014, 5009, 5013, 5015, 5011, 5005, 5004, 4999, 5002, 5000, 5000, 4999, 5013, 5012, 5001, 5012, 4995, 4997, 4995, 4985, 4989, 5007, 5010, 4997, 5011, 4995, 5000, 5011, 4998, 4991, 5021, 5003, 4985, 4991, 4995, 5018, 4979, 5003, 5011, 5009, 5001, 4998, 5008, 4994, 5016, 4992, 5008, 4993, 4983, 5010, 5023, 4975, 4987, 4994, 5002, 4984, 5005, 5006, 5005, 5000, 4996, 5000, 4999, 5004, 4994, 5000, 4981, 5001, 4994, 4993, 5000, 5004, 5001, 4992, 5002, 5006, 4997, 4987, 5001, 5008, 5011, 4995, 5006, 4976, 4999, 4989, 5008, 4996, 4997, 5006, 5005, 5007, 4990, 5010, 4996, 4998, 5000, 5000, 5002, 5001, 4996, 4997, 5000, 5003, 5000, 4986, 5013, 5001, 4990, 4990, 5010, 5000, 5021, 5000, 5006, 4995, 5012, 5019, 5000, 5006, 4999, 5007, 5014, 5000, 4994, 4991, 5010, 4985, 4988, 5007, 5005, 5000, 5005, 4997, 4995, 4999, 5000, 5000, 5009, 5000, 4999, 5011, 5018, 4994, 5000, 4995, 5000, 5008, 4994, 4992, 5000, 4998, 4992, 5006, 4996, 5000, 5018, 5000, 5022, 5002, 5007, 5000, 5012, 5014, 5010, 4997, 4996, 5014, 4995, 4991, 5006, 4992, 5008, 5004, 4995, 5016, 5000, 5005, 5000, 4985, 5002, 5000, 5009, 4991, 4995, 5004, 4987, 5014, 4986, 5008, 4985, 4995, 5010, 5000, 5001, 5013, 4988, 5001, 5002, 4986, 4985, 5001, 4995, 5004, 4998, 4998, 4992, 5003, 5000, 4991, 4998, 5002, 5011, 4986, 5013, 4997, 5000, 5002, 5003, 5014, 4998, 5002, 5006, 5015, 4992, 4992, 4995, 4998, 4994, 5007, 4977, 5004, 5005, 4990, 4991, 5001, 5010, 4991, 4990, 5006, 5004, 5004, 4997, 5001, 4992, 5000, 5000, 4996, 4987, 4993, 5001, 5006, 4999, 4993, 4999, 5001, 5001, 5014, 4985, 5010, 5006, 4989, 5002, 5011, 4999, 5010, 5005, 5002, 5010, 4990, 4994, 5000, 4985, 5010, 5000, 4999, 5000, 4977, 5007, 5005, 4990, 5000, 4985, 5003, 5009, 5012, 5012, 5000, 5003, 4997, 5002, 4992, 4999, 4997, 5005, 5009, 4989, 5005, 4988, 5001, 5000, 5000, 4999, 5005, 4997, 5015, 5001, 4988, 4983, 5013, 4992, 5002, 5012, 4999, 5013, 5000, 4988, 4989, 4996, 5000, 5002, 4999, 5021, 4991, 5009, 5005, 4994, 5000, 4994, 4985, 4999, 4980, 5013, 5014, 5000, 4996, 5008, 5028, 5002, 5004, 4999, 5012, 4992, 5002, 4987, 5004, 5009, 5004, 5013, 4989, 5027, 4992, 5016, 5007, 5003, 5013, 5003, 4999, 5000, 4987, 5001, 4998, 4994, 4998, 4997, 4998, 4998, 5001, 4990, 5025, 5003, 4996, 5006, 5005, 4995, 4994, 5023, 5003, 5005, 4991, 5001, 5001, 4996, 5001, 5005, 5001, 5001, 5000, 5000, 5000, 5005, 5001, 4999, 5003, 4982, 5000, 5012, 5011, 5008, 5000, 4998, 4994, 4988, 5013, 4998, 5017, 4991, 5007, 5016, 5007, 4997, 4974, 4997, 5006, 5003, 5010, 5003, 4997, 4997, 4994, 4998, 4987, 5004, 5001, 5009, 5006, 5009, 4984, 5010, 5023, 5000, 5008, 5007, 5008, 4993, 5010, 5012, 4989, 5002, 4993, 5007, 4985, 4990, 4988, 4997, 5000, 4994, 5004, 4981, 5000, 4999, 5003, 4988, 5006, 5019, 5003, 4992, 4977, 4998, 4987, 4995, 4987, 5000, 4986, 4998, 4996, 5008, 5011, 5009, 5000, 4999, 5010, 4999, 5009, 5010, 4992, 4998, 4994, 5009, 4998, 5013, 5011, 4997, 5016, 4995, 5003, 4986, 5010, 4995, 4986, 5025, 4990, 5010, 4990, 4996, 5000, 5002, 4994, 5002, 5000, 5001, 4995, 5003, 5006, 5000, 4997, 4996, 5010, 4992, 5013, 4998, 4988, 4999, 5004, 5004, 5002, 5002, 5001, 4986, 5011, 5012, 4988, 5000, 5000, 5012, 5004, 5004, 4984, 5012, 4998, 5005, 5005, 5005, 4995, 5004, 5006, 5000, 5008, 5015, 4999, 4999, 4996, 5000, 4992, 5019, 5020, 4999, 4991, 5020, 5000, 5002, 5000, 5003, 4985, 4990, 5011, 5012, 4997, 4989, 4999, 5006, 4997, 4992, 4999, 4985, 4999, 5012, 5003, 4989, 5010, 5010, 5012, 4990, 4986, 5014, 5000, 4994, 5017, 4995, 5005, 5003, 5000, 5000, 4988, 5018, 5007, 5009, 5002, 5004, 4999, 5026, 4987, 4986, 5000, 4994, 5012, 5022, 4996, 5002, 4986, 4990, 4989, 4997, 4997, 5002, 5004, 4999, 5000, 4992, 4999, 4997, 4998, 5000, 5002, 5032, 4998, 5014, 4978, 5001, 4988, 5006, 5003, 5005, 5002, 5005, 5000, 5003, 4990, 4991, 4990, 5016, 5006, 4981, 4999, 4998, 4989, 4995, 5007, 5004, 5019, 5001, 5004, 5000, 4996, 4988, 5001, 5003, 5009, 4998, 5003, 4991, 5000, 4988, 5004, 5002, 4991, 4998, 4996, 4991, 5013, 5007, 5010, 5004, 5006, 5007, 4993, 5000, 5002, 4992, 4999, 4992, 5001, 4989, 4992, 5015, 5011, 5008, 5004, 4990, 4995, 4993, 5004, 5000, 4982, 5008, 5000, 4993, 5000, 5000, 4991, 5005, 5008, 5003, 4994, 4997, 5012, 4995, 5009, 5020, 5010, 5019, 4979, 5013, 4990, 5002, 5000, 5015, 4989, 5009, 4998, 5004, 5010, 4988, 4994, 5004, 4985, 4998, 4991, 4985, 4994, 4986, 5010, 4990, 5002, 5005, 5008, 5004, 4988, 4980, 5005, 4994, 5004, 4998, 4990, 5010, 5003, 5011, 4992, 5009, 5003, 5013, 4996, 4997, 4989, 4992, 5002, 4992, 4996, 4999, 5000, 5009, 4990, 4992, 5020, 4981, 5011, 5000, 5008, 4997, 4994, 4982, 5014, 5013, 4996, 5002, 5011, 5003, 5000, 5015, 4999, 5001, 5002, 5018, 4984, 5022, 5009, 5006, 5009, 5000, 4974, 4991, 5020, 5000, 4987, 5003, 4987, 5003, 5002, 5016, 4997, 5022, 5005, 4998, 4999, 5001, 5000, 4999, 5000, 5001, 4994, 4991, 4997, 4990, 4991, 4995, 5008, 5007, 4994, 5000, 5007, 4988, 5014, 5003, 4998, 4995, 5000, 5000, 5004]) # @IgnorePep8 YY2, _res2 = HampelFilter(dx=3, t=0, fulloutput=True)(Y) # Y0 = assert_array_almost_equal(np.int_(YY2), [5001, 5000, 4994, 5000, 5002, 5000, 5000, 5000, 5000, 5003, 5000, 5000, 5000, 5003, 5003, 5003, 4997, 5004, 5007, 5004, 5001, 5001, 5001, 5002, 5002, 5001, 5001, 5001, 4998, 5001, 4998, 4996, 4998, 4998, 5002, 5002, 4996, 4997, 5003, 5003, 5002, 5001, 5002, 5003, 5003, 5002, 5001, 4998, 4998, 4995, 4995, 4998, 4999, 4999, 5007, 5009, 5009, 5009, 5007, 4996, 4996, 4994, 4994, 4994, 4994, 4995, 5007, 5008, 5008, 5009, 5008, 5008, 5008, 5001, 5000, 5001, 5001, 5004, 5004, 5005, 5005, 5005, 5005, 5000, 4994, 4994, 4994, 4993, 4994, 4995, 4995, 4995, 4995, 4995, 4999, 4995, 4995, 4999, 4999, 4997, 4997, 4993, 4997, 5009, 4997, 4997, 4999, 4999, 4999, 4999, 4997, 4987, 4999, 5002, 5001, 5002, 5001, 5001, 5002, 5001, 4998, 4996, 4996, 4996, 4998, 4998, 4998, 4998, 5001, 5001, 5001, 5001, 5004, 5004, 5004, 5004, 5002, 5004, 5008, 5002, 5010, 5002, 5002, 5009, 5002, 5002, 5002, 5002, 5008, 5008, 5008, 5008, 5008, 5008, 5008, 5004, 5004, 5004, 5004, 5004, 5000, 4999, 5000, 4998, 4998, 4998, 5000, 5000, 5000, 5000, 5000, 5000, 4997, 4997, 4997, 5000, 5003, 5003, 5005, 5009, 5009, 5009, 5010, 5011, 5011, 5011, 5004, 5011, 5004, 5000, 5000, 5000, 5000, 5001, 5001, 5001, 5001, 5001, 4997, 4995, 4995, 4995, 4997, 4997, 4997, 5000, 5007, 5000, 4998, 5000, 5000, 5000, 4998, 4995, 4995, 4995, 4995, 4995, 5003, 5003, 5003, 5003, 5003, 5008, 5001, 5001, 4998, 4994, 4994, 5008, 4993, 4993, 4993, 4994, 4994, 4994, 4994, 5002, 5002, 5002, 5000, 5000, 5000, 5000, 5000, 4999, 5000, 4999, 4994, 4994, 5000, 5000, 5000, 5000, 5001, 5001, 5001, 5001, 5001, 5002, 5001, 5001, 5001, 5001, 4999, 4999, 4996, 4997, 4997, 4999, 5005, 5005, 5005, 5005, 5005, 5000, 5000, 5000, 5001, 5000, 5000, 5000, 5001, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5001, 5000, 5000, 5000, 5006, 5006, 5006, 5006, 5006, 5006, 5007, 5006, 5000, 5000, 5000, 5000, 4994, 4994, 4994, 5000, 5005, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 4995, 5000, 4998, 4998, 4998, 4996, 4998, 5000, 5000, 5000, 5002, 5002, 5002, 5007, 5007, 5010, 5007, 5007, 5010, 5010, 4997, 4997, 4996, 4996, 5004, 4995, 5004, 5004, 5004, 5004, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 4995, 4995, 4995, 4995, 4995, 5000, 5000, 5001, 5000, 5001, 5001, 5001, 5001, 5001, 4995, 5001, 4998, 4998, 4998, 4998, 4998, 4998, 4998, 4998, 5000, 5000, 5000, 4998, 5000, 5002, 5003, 5003, 5003, 5002, 5003, 5006, 5003, 5002, 4998, 4998, 4995, 4995, 4994, 4995, 4998, 4998, 4994, 5001, 5001, 5001, 4991, 4991, 5001, 5004, 5004, 5001, 5001, 5001, 5000, 5000, 4997, 4996, 4996, 5000, 4999, 4996, 4999, 4999, 5001, 5001, 4999, 5001, 5001, 5001, 5002, 5006, 5002, 5006, 5005, 5002, 5005, 5005, 5002, 5002, 5000, 5000, 5000, 4999, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5003, 5003, 5003, 5003, 5009, 5009, 5009, 5002, 5000, 4999, 4999, 4999, 4999, 4999, 4999, 5001, 5001, 5001, 5000, 5001, 5000, 5001, 5001, 5001, 4999, 5001, 4997, 5001, 5001, 4999, 5002, 5002, 5000, 5000, 4999, 4999, 5000, 4999, 4999, 4999, 5000, 5002, 5002, 5000, 5000, 4994, 4999, 4994, 4994, 4999, 4999, 4999, 5000, 5008, 5008, 5004, 5002, 5004, 5004, 5002, 5002, 5002, 5002, 5004, 5004, 5004, 5004, 5004, 5009, 5007, 5007, 5007, 5007, 5003, 5003, 5003, 5001, 5000, 4998, 4998, 4998, 4998, 4998, 4998, 4997, 4998, 5001, 5001, 5001, 5003, 5003, 5003, 5003, 5003, 5005, 5003, 5001, 5003, 5003, 5001, 5001, 5001, 5001, 5001, 5001, 5001, 5001, 5001, 5001, 5001, 5000, 5000, 5001, 5001, 5003, 5003, 5000, 5000, 5000, 5000, 4998, 4998, 4998, 4998, 5007, 5007, 5007, 5007, 4997, 5006, 5003, 5003, 5003, 5003, 5003, 5003, 4998, 4997, 4997, 4997, 4997, 4998, 5004, 5004, 5006, 5009, 5009, 5008, 5009, 5008, 5008, 5008, 5008, 5008, 5008, 5002, 5002, 5002, 4993, 4990, 4993, 4993, 4994, 4994, 4994, 4997, 4999, 5000, 4999, 5000, 5000, 5003, 5003, 5003, 4998, 4998, 4995, 4992, 4992, 4987, 4995, 4995, 4996, 4998, 5000, 5000, 5000, 5008, 5008, 5009, 5009, 5000, 4999, 4999, 4999, 4998, 4998, 4998, 4998, 5009, 5009, 5003, 5003, 5003, 4997, 4995, 4995, 4995, 4995, 4995, 4995, 4996, 5000, 4996, 5000, 5000, 5000, 5000, 5002, 5002, 5002, 5000, 5000, 5000, 5000, 5000, 4998, 4997, 4998, 4999, 4999, 5002, 5002, 5002, 5002, 5002, 5002, 5002, 5001, 5000, 5000, 5004, 5004, 5000, 5004, 5004, 5004, 5004, 5005, 5005, 5005, 5005, 5005, 5005, 5005, 5000, 5000, 5000, 5000, 4999, 4999, 4999, 4999, 4999, 5000, 5000, 5002, 5000, 5000, 5000, 5000, 5000, 5002, 5000, 4997, 4997, 4999, 4999, 4997, 4997, 4997, 4999, 4999, 4999, 4999, 4999, 5003, 5010, 5010, 5003, 5010, 5010, 5000, 5000, 4995, 5000, 5003, 5000, 5000, 5000, 5000, 5003, 5003, 5002, 5004, 5004, 5007, 5004, 5002, 5000, 4999, 4999, 5000, 4996, 5000, 5000, 4996, 4996, 4996, 4996, 4997, 4997, 4999, 5000, 5000, 4999, 4999, 4998, 4998, 4998, 4998, 4998, 5000, 5000, 5001, 5001, 5001, 5001, 5003, 5003, 5005, 5005, 5005, 5003, 5003, 5000, 5000, 5000, 4991, 4991, 4998, 4998, 4998, 4998, 4998, 5004, 5001, 5004, 5004, 5004, 5001, 5001, 5001, 5003, 5000, 5003, 5003, 5003, 5000, 5000, 5000, 5000, 4998, 4998, 4996, 4998, 4998, 4998, 5004, 5006, 5007, 5007, 5006, 5004, 5002, 5000, 4999, 4999, 4999, 4992, 4992, 4999, 5001, 5004, 5004, 5004, 5004, 5004, 5004, 4995, 4995, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5003, 5003, 5003, 5003, 5009, 5010, 5010, 5010, 5010, 5010, 5002, 5002, 5000, 5002, 5000, 5002, 5004, 5004, 4998, 5004, 4998, 4998, 4994, 4991, 4994, 4991, 4991, 4991, 4991, 4994, 5002, 5004, 5004, 5002, 5004, 5004, 5004, 4998, 4994, 4998, 5003, 5003, 5003, 5003, 5003, 5009, 5003, 5003, 4997, 4997, 4997, 4996, 4996, 4996, 4996, 4999, 4999, 4996, 4999, 4999, 5000, 5000, 5000, 5000, 5000, 4997, 5000, 5000, 4997, 4997, 5002, 5003, 5003, 5003, 5002, 5002, 5002, 5002, 5001, 5002, 5002, 5006, 5009, 5009, 5006, 5006, 5006, 5000, 5000, 5000, 4991, 5000, 5002, 5002, 5002, 5003, 5003, 5003, 5002, 5001, 5000, 5001, 5000, 5000, 5000, 5000, 5000, 4997, 4994, 4994, 4994, 4995, 4995, 4995, 5000, 5000, 5007, 5003, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000]) # @IgnorePep8
def test_pass_info(): beta_op.beta = 1.0 beta_op.factor = 1.02 beta_op.factor = 1.000 beta_op.beta_admm_factor = 1.000 n, t = 10, 10 scen_full = Scenario.blank(n, t) scen_full.ic.mainline[0] = 0.5 admm = CtmAdjointAdmm.from_full_scenario(scen_full, 5, beta=30.0, n_iters=400) d1 = admm.l_scen.simulate(admm.l_scen.no_control()).density d2 = admm.r_scen.simulate(admm.r_scen.no_control()).density sln = admm.solve() d3 = sln.l.fs(sln.l.construct_control(sln.cl)).density d4 = sln.r.fs(sln.r.construct_control(sln.cr)).density subplot(2, 2, 1) pcolor(d1, cmap="binary", vmin=0.0, vmax=1.0) xlabel("Time") ylabel("Space") title("Initial Upstream Subnetwork") colorbar() subplot(2, 2, 2) pcolor(d2, cmap="binary", vmin=0.0, vmax=1.0) xlabel("Time") ylabel("Space") title("Initial Downstream Subnetwork") colorbar() subplot(2, 2, 3) pcolor(d3, cmap="binary", vmin=0.0, vmax=1.0) xlabel("Time") ylabel("Space") title("Final Upstream Subnetwork") colorbar() subplot(2, 2, 4) pcolor(d4, cmap="binary", vmin=0.0, vmax=1.0) xlabel("Time") ylabel("Space") title("Final Downstream Subnetwork") colorbar() savefig("init-final.pdf") sln.density_summary() cl = sln.l.construct_control(sln.cl) cr = sln.r.construct_control(sln.cr) assert_array_almost_equal(cl[0][-2:, :], cr[0][:2, :]) assert_array_almost_equal(cl[1], [0, 0, 0.5, 0], 2) assert_array_almost_equal(cr[1], [0, 0.5, 0, 0], 2) assert_almost_equals(sln.history.x[-1], 0.0, 2) assert_almost_equals(sln.history.y[-1], 0.0, 2)
def test_fs_controlled(): beta_op.beta = 1.0 scen, control = small_scenario() ca = CTMAdjoint(scen) for _ in range(5): c = rand(scen.N * scen.T, 1).flatten() assert_array_almost_equal(ca.grad(c), ca.grad_fd(c)) # fs = CTMSimulator().simulate(scen, control) ca = ControlledCtmAdjoint(True, scen) control = ca.construct_control(ca.no_control()) fs = ca.fs(control) # assert_array_equal(fs.density, [[.9, 1.0, .9, .1, 0, 0, 0, 0, 0, 0, 0], [0, 1.0, .9, .9, .1, 0, 0, 0, 0, 0, 0]]) assert_array_almost_equal(fs.density, [[0.9, 1.0, 0.9, 0.1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]]) control[1][:] += 2.0 fs = ca.fs(control) assert_array_almost_equal( fs.density, np.array([[0.9, 1.8, 1.8, 1.8, 1.8, 1.8, 1.8], [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 1.0]]) )
def test_two_length(): beta_op.beta = 50.0 # beta_op.beta = 0.8 beta_op.factor = 1.02 beta_op.beta = 100.0 beta_op.factor = 1.02 beta_op.factor = 1.000 beta = 100.0 beta_op.beta_admm_factor = 1.000 beta_op.inner_iters = 100 n, t = 2, 2 scen_full = Scenario.blank(n, t) scen_full.ic.mainline[1] = 0.5 sln = CtmAdjointAdmm.from_full_scenario(scen_full, 1, beta=beta, n_iters=20).solve() sln.density_summary() cl = sln.l.construct_control(sln.cl) cr = sln.r.construct_control(sln.cr) assert_array_almost_equal(cl[0][-2:, :], cr[0][:2, :]) assert_array_almost_equal(cl[1], [0, 0, 0.5, 0], 2) assert_array_almost_equal(cr[1], [0, 0.5, 0, 0], 2) assert_almost_equals(sln.history.x[-1], 0.0, 2) assert_almost_equals(sln.history.y[-1], 0.0, 2)
def test_plotting_positions(): # Regression test for #1256 pos = mstats.plotting_positions(np.arange(3), 0, 0) assert_array_almost_equal(pos.data, np.array([0.25, 0.5, 0.75]))
def test_triinterp(): # Test points within triangles of masked triangulation. x, y = np.meshgrid(np.arange(4), np.arange(4)) x = x.ravel() y = y.ravel() z = 1.23*x - 4.79*y triangles = [[0, 1, 4], [1, 5, 4], [1, 2, 5], [2, 6, 5], [2, 3, 6], [3, 7, 6], [4, 5, 8], [5, 9, 8], [5, 6, 9], [6, 10, 9], [6, 7, 10], [7, 11, 10], [8, 9, 12], [9, 13, 12], [9, 10, 13], [10, 14, 13], [10, 11, 14], [11, 15, 14]] mask = np.zeros(len(triangles)) mask[8:10] = 1 triang = mtri.Triangulation(x, y, triangles, mask) linear_interp = mtri.LinearTriInterpolator(triang, z) cubic_min_E = mtri.CubicTriInterpolator(triang, z) cubic_geom = mtri.CubicTriInterpolator(triang, z, kind='geom') xs = np.linspace(0.25, 2.75, 6) ys = [0.25, 0.75, 2.25, 2.75] xs, ys = np.meshgrid(xs, ys) # Testing arrays with array.ndim = 2 for interp in (linear_interp, cubic_min_E, cubic_geom): zs = interp(xs, ys) assert_array_almost_equal(zs, (1.23*xs - 4.79*ys)) # Test points outside triangulation. xs = [-0.25, 1.25, 1.75, 3.25] ys = xs xs, ys = np.meshgrid(xs, ys) for interp in (linear_interp, cubic_min_E, cubic_geom): zs = linear_interp(xs, ys) assert_array_equal(zs.mask, [[True]*4]*4) # Test mixed configuration (outside / inside). xs = np.linspace(0.25, 1.75, 6) ys = [0.25, 0.75, 1.25, 1.75] xs, ys = np.meshgrid(xs, ys) for interp in (linear_interp, cubic_min_E, cubic_geom): zs = interp(xs, ys) matest.assert_array_almost_equal(zs, (1.23*xs - 4.79*ys)) mask = (xs >= 1) * (xs <= 2) * (ys >= 1) * (ys <= 2) assert_array_equal(zs.mask, mask) # 2nd order patch test: on a grid with an 'arbitrary shaped' triangle, # patch test shall be exact for quadratic functions and cubic # interpolator if *kind* = user (a, b, c) = (1.23, -4.79, 0.6) def quad(x, y): return a*(x-0.5)**2 + b*(y-0.5)**2 + c*x*y def gradient_quad(x, y): return (2*a*(x-0.5) + c*y, 2*b*(y-0.5) + c*x) x = np.array([0.2, 0.33367, 0.669, 0., 1., 1., 0.]) y = np.array([0.3, 0.80755, 0.4335, 0., 0., 1., 1.]) triangles = np.array([[0, 1, 2], [3, 0, 4], [4, 0, 2], [4, 2, 5], [1, 5, 2], [6, 5, 1], [6, 1, 0], [6, 0, 3]]) triang = mtri.Triangulation(x, y, triangles) z = quad(x, y) dz = gradient_quad(x, y) # test points for 2nd order patch test xs = np.linspace(0., 1., 5) ys = np.linspace(0., 1., 5) xs, ys = np.meshgrid(xs, ys) cubic_user = mtri.CubicTriInterpolator(triang, z, kind='user', dz=dz) interp_zs = cubic_user(xs, ys) assert_array_almost_equal(interp_zs, quad(xs, ys)) (interp_dzsdx, interp_dzsdy) = cubic_user.gradient(x, y) (dzsdx, dzsdy) = gradient_quad(x, y) assert_array_almost_equal(interp_dzsdx, dzsdx) assert_array_almost_equal(interp_dzsdy, dzsdy) # Cubic improvement: cubic interpolation shall perform better than linear # on a sufficiently dense mesh for a quadratic function. n = 11 x, y = np.meshgrid(np.linspace(0., 1., n+1), np.linspace(0., 1., n+1)) x = x.ravel() y = y.ravel() z = quad(x, y) triang = mtri.Triangulation(x, y, triangles=meshgrid_triangles(n+1)) xs, ys = np.meshgrid(np.linspace(0.1, 0.9, 5), np.linspace(0.1, 0.9, 5)) xs = xs.ravel() ys = ys.ravel() linear_interp = mtri.LinearTriInterpolator(triang, z) cubic_min_E = mtri.CubicTriInterpolator(triang, z) cubic_geom = mtri.CubicTriInterpolator(triang, z, kind='geom') zs = quad(xs, ys) diff_lin = np.abs(linear_interp(xs, ys) - zs) for interp in (cubic_min_E, cubic_geom): diff_cubic = np.abs(interp(xs, ys) - zs) assert np.max(diff_lin) >= 10 * np.max(diff_cubic) assert (np.dot(diff_lin, diff_lin) >= 100 * np.dot(diff_cubic, diff_cubic))
def test_simplest(): scen, control = smallest_possible() u = control.flatten() adjoint = CTMAdjoint(scen) assert_array_almost_equal(adjoint.grad(u), adjoint.grad_fd(u))
def test_triinterp_transformations(): # 1) Testing that the interpolation scheme is invariant by rotation of the # whole figure. # Note: This test is non-trivial for a CubicTriInterpolator with # kind='min_E'. It does fail for a non-isotropic stiffness matrix E of # :class:`_ReducedHCT_Element` (tested with E=np.diag([1., 1., 1.])), and # provides a good test for :meth:`get_Kff_and_Ff`of the same class. # # 2) Also testing that the interpolation scheme is invariant by expansion # of the whole figure along one axis. n_angles = 20 n_radii = 10 min_radius = 0.15 def z(x, y): r1 = np.hypot(0.5 - x, 0.5 - y) theta1 = np.arctan2(0.5 - x, 0.5 - y) r2 = np.hypot(-x - 0.2, -y - 0.2) theta2 = np.arctan2(-x - 0.2, -y - 0.2) z = -(2*(np.exp((r1/10)**2)-1)*30. * np.cos(7.*theta1) + (np.exp((r2/10)**2)-1)*30. * np.cos(11.*theta2) + 0.7*(x**2 + y**2)) return (np.max(z)-z)/(np.max(z)-np.min(z)) # First create the x and y coordinates of the points. radii = np.linspace(min_radius, 0.95, n_radii) angles = np.linspace(0 + n_angles, 2*np.pi + n_angles, n_angles, endpoint=False) angles = np.repeat(angles[..., np.newaxis], n_radii, axis=1) angles[:, 1::2] += np.pi/n_angles x0 = (radii*np.cos(angles)).flatten() y0 = (radii*np.sin(angles)).flatten() triang0 = mtri.Triangulation(x0, y0) # Delaunay triangulation z0 = z(x0, y0) # Then create the test points xs0 = np.linspace(-1., 1., 23) ys0 = np.linspace(-1., 1., 23) xs0, ys0 = np.meshgrid(xs0, ys0) xs0 = xs0.ravel() ys0 = ys0.ravel() interp_z0 = {} for i_angle in range(2): # Rotating everything theta = 2*np.pi / n_angles * i_angle x = np.cos(theta)*x0 + np.sin(theta)*y0 y = -np.sin(theta)*x0 + np.cos(theta)*y0 xs = np.cos(theta)*xs0 + np.sin(theta)*ys0 ys = -np.sin(theta)*xs0 + np.cos(theta)*ys0 triang = mtri.Triangulation(x, y, triang0.triangles) linear_interp = mtri.LinearTriInterpolator(triang, z0) cubic_min_E = mtri.CubicTriInterpolator(triang, z0) cubic_geom = mtri.CubicTriInterpolator(triang, z0, kind='geom') dic_interp = {'lin': linear_interp, 'min_E': cubic_min_E, 'geom': cubic_geom} # Testing that the interpolation is invariant by rotation... for interp_key in ['lin', 'min_E', 'geom']: interp = dic_interp[interp_key] if i_angle == 0: interp_z0[interp_key] = interp(xs0, ys0) # storage else: interpz = interp(xs, ys) matest.assert_array_almost_equal(interpz, interp_z0[interp_key]) scale_factor = 987654.3210 for scaled_axis in ('x', 'y'): # Scaling everything (expansion along scaled_axis) if scaled_axis == 'x': x = scale_factor * x0 y = y0 xs = scale_factor * xs0 ys = ys0 else: x = x0 y = scale_factor * y0 xs = xs0 ys = scale_factor * ys0 triang = mtri.Triangulation(x, y, triang0.triangles) linear_interp = mtri.LinearTriInterpolator(triang, z0) cubic_min_E = mtri.CubicTriInterpolator(triang, z0) cubic_geom = mtri.CubicTriInterpolator(triang, z0, kind='geom') dic_interp = {'lin': linear_interp, 'min_E': cubic_min_E, 'geom': cubic_geom} # Test that the interpolation is invariant by expansion along 1 axis... for interp_key in ['lin', 'min_E', 'geom']: interpz = dic_interp[interp_key](xs, ys) matest.assert_array_almost_equal(interpz, interp_z0[interp_key])