// the signal processing routine;
inline int perform(t_sample ** __ins, t_sample ** __outs, int __n) {
vectorsize = __n;
const t_sample * __in1 = __ins[0];
t_sample * __out1 = __outs[0];
if (__exception) {
return __exception;
} else if (( (__in1 == 0) || (__out1 == 0) )) {
__exception = GENLIB_ERR_NULL_BUFFER;
return __exception;
};
double mul_2327 = (m_resonance_13 * 0.125);
double exp_2328 = exp(mul_2327);
double mul_2326 = (exp_2328 * 0.882497);
double mul_2322 = (mul_2326 * mul_2326);
double expr_2437 = safediv(((m_cutoff_14 * 2) * 3.1415926535898), 44100);
double cos_2325 = cos(expr_2437);
double mul_2324 = (cos_2325 * mul_2326);
double mul_2323 = (mul_2324 * -2);
double add_2321 = ((mul_2323 + mul_2322) + 1);
double mstosamps_2393 = (m_window_15 * (samplerate * 0.001));
double mstosamps_2309 = (m_window_19 * (samplerate * 0.001));
double rsub_2296 = (1 - m_ratio_20);
double mul_2295 = (rsub_2296 * 1000);
double div_2294 = safediv(mul_2295, m_window_19);
samples_to_seconds = (1 / samplerate);
double rsub_2380 = (1 - m_ratio_18);
double mul_2379 = (rsub_2380 * 1000);
double div_2378 = safediv(mul_2379, m_window_15);
// the main sample loop;
while ((__n--)) {
const double in1 = (*(__in1++));
double noise_2247 = noise();
double abs_2264 = fabs(noise_2247);
double mul_2270 = (abs_2264 * m_blur_17);
double noise_2246 = noise();
double abs_2263 = fabs(noise_2246);
double mul_2267 = (abs_2263 * m_blur_17);
double noise_2330 = noise();
double abs_2348 = fabs(noise_2330);
double mul_2354 = (abs_2348 * m_blur_17);
double noise_2332 = noise();
double abs_2350 = fabs(noise_2332);
double mul_2360 = (abs_2350 * m_blur_17);
double noise_2249 = noise();
double abs_2266 = fabs(noise_2249);
double mul_2276 = (abs_2266 * m_blur_17);
double noise_2248 = noise();
double abs_2265 = fabs(noise_2248);
double mul_2273 = (abs_2265 * m_blur_17);
double noise_2331 = noise();
double abs_2349 = fabs(noise_2331);
double mul_2357 = (abs_2349 * m_blur_17);
double noise_2329 = noise();
double abs_2347 = fabs(noise_2329);
double mul_2351 = (abs_2347 * m_blur_17);
double mul_2318 = (mul_2322 * m_y_10);
double mul_2319 = (mul_2323 * m_y_1);
double phasor_2315 = m_phasor_21(div_2294, samples_to_seconds);
double add_2293 = ((phasor_2315 + m_history_9) + 0.5);
double mod_2292 = safemod(add_2293, 1);
double delta_2272 = m_delta_22(mod_2292);
double sah_2252 = m_sah_23(mul_2270, delta_2272, 0);
double sah_2271 = m_sah_24(mstosamps_2309, delta_2272, 0);
double mul_2260 = (sah_2271 * mod_2292);
double sub_2291 = (mod_2292 - 0.5);
double mul_2290 = (sub_2291 * 3.1415926535898);
double cos_2289 = cos(mul_2290);
double mul_2279 = (cos_2289 * cos_2289);
double add_2287 = ((phasor_2315 + m_history_8) + 0.75);
double mod_2286 = safemod(add_2287, 1);
double delta_2269 = m_delta_25(mod_2286);
double sah_2250 = m_sah_26(mul_2267, delta_2269, 0);
double sah_2268 = m_sah_27(mstosamps_2309, delta_2269, 0);
double mul_2259 = (sah_2268 * mod_2286);
double sub_2285 = (mod_2286 - 0.5);
double mul_2284 = (sub_2285 * 3.1415926535898);
double cos_2283 = cos(mul_2284);
double mul_2278 = (cos_2283 * cos_2283);
double add_2314 = ((phasor_2315 + m_history_7) + 0);
double mod_2313 = safemod(add_2314, 1);
double delta_2257 = m_delta_28(mod_2313);
double sah_2256 = m_sah_29(mul_2276, delta_2257, 0);
double sah_2277 = m_sah_30(mstosamps_2309, delta_2257, 0);
double mul_2262 = (sah_2277 * mod_2313);
double sub_2312 = (mod_2313 - 0.5);
double mul_2311 = (sub_2312 * 3.1415926535898);
double cos_2310 = cos(mul_2311);
double mul_2281 = (cos_2310 * cos_2310);
double add_2308 = ((phasor_2315 + m_history_6) + 0.25);
double mod_2307 = safemod(add_2308, 1);
double delta_2275 = m_delta_31(mod_2307);
double sah_2254 = m_sah_32(mul_2273, delta_2275, 0);
double sah_2274 = m_sah_33(mstosamps_2309, delta_2275, 0);
double mul_2261 = (sah_2274 * mod_2307);
double tap_2300 = m_delay_12.read_linear(mul_2262);
double tap_2301 = m_delay_12.read_linear(mul_2261);
double tap_2302 = m_delay_12.read_linear(mul_2260);
double tap_2303 = m_delay_12.read_linear(mul_2259);
double mul_2282 = (tap_2303 * mul_2278);
double mul_2288 = (tap_2302 * mul_2279);
double mul_2298 = (tap_2300 * mul_2281);
double sub_2306 = (mod_2307 - 0.5);
double mul_2305 = (sub_2306 * 3.1415926535898);
double cos_2304 = cos(mul_2305);
double mul_2280 = (cos_2304 * cos_2304);
double mul_2297 = (tap_2301 * mul_2280);
double phasor_2399 = m_phasor_34(div_2378, samples_to_seconds);
double add_2377 = ((m_history_5 + phasor_2399) + 0.5);
double mod_2376 = safemod(add_2377, 1);
double delta_2356 = m_delta_35(mod_2376);
double sah_2335 = m_sah_36(mul_2354, delta_2356, 0);
double sah_2355 = m_sah_37(mstosamps_2393, delta_2356, 0);
double mul_2344 = (sah_2355 * mod_2376);
double sub_2375 = (mod_2376 - 0.5);
double mul_2374 = (sub_2375 * 3.1415926535898);
double cos_2373 = cos(mul_2374);
double mul_2363 = (cos_2373 * cos_2373);
double add_2398 = ((m_history_4 + phasor_2399) + 0);
double mod_2397 = safemod(add_2398, 1);
double delta_2340 = m_delta_38(mod_2397);
double sah_2339 = m_sah_39(mul_2360, delta_2340, 0);
double sah_2361 = m_sah_40(mstosamps_2393, delta_2340, 0);
double mul_2346 = (sah_2361 * mod_2397);
double sub_2396 = (mod_2397 - 0.5);
double mul_2395 = (sub_2396 * 3.1415926535898);
double cos_2394 = cos(mul_2395);
double mul_2365 = (cos_2394 * cos_2394);
double add_2392 = ((m_history_3 + phasor_2399) + 0.25);
double mod_2391 = safemod(add_2392, 1);
double delta_2359 = m_delta_41(mod_2391);
double sah_2337 = m_sah_42(mul_2357, delta_2359, 0);
double sah_2358 = m_sah_43(mstosamps_2393, delta_2359, 0);
double mul_2345 = (sah_2358 * mod_2391);
double sub_2390 = (mod_2391 - 0.5);
double mul_2389 = (sub_2390 * 3.1415926535898);
double cos_2388 = cos(mul_2389);
double mul_2364 = (cos_2388 * cos_2388);
double add_2371 = ((m_history_2 + phasor_2399) + 0.75);
double mod_2370 = safemod(add_2371, 1);
double delta_2353 = m_delta_44(mod_2370);
double sah_2333 = m_sah_45(mul_2351, delta_2353, 0);
double sah_2352 = m_sah_46(mstosamps_2393, delta_2353, 0);
double mul_2343 = (sah_2352 * mod_2370);
double tap_2384 = m_delay_11.read_linear(mul_2346);
double tap_2385 = m_delay_11.read_linear(mul_2345);
double tap_2386 = m_delay_11.read_linear(mul_2344);
double tap_2387 = m_delay_11.read_linear(mul_2343);
double mul_2382 = (tap_2384 * mul_2365);
double mul_2381 = (tap_2385 * mul_2364);
double mul_2372 = (tap_2386 * mul_2363);
double sub_2369 = (mod_2370 - 0.5);
double mul_2368 = (sub_2369 * 3.1415926535898);
double cos_2367 = cos(mul_2368);
double mul_2362 = (cos_2367 * cos_2367);
double mul_2366 = (tap_2387 * mul_2362);
double mul_2320 = ((((((((mul_2298 + mul_2297) + mul_2288) + mul_2282) + mul_2366) + mul_2372) + mul_2381) + mul_2382) * add_2321);
double sub_2317 = (mul_2320 - (mul_2319 + mul_2318));
double mix_2450 = (in1 + (m_mix_16 * (sub_2317 - in1)));
double out1 = mix_2450;
double y2_next_2440 = m_y_1;
double history_2253_next_2441 = sah_2252;
double history_2251_next_2442 = sah_2250;
double history_2258_next_2443 = sah_2256;
double history_2255_next_2444 = sah_2254;
double history_2336_next_2445 = sah_2335;
double history_2341_next_2446 = sah_2339;
double history_2338_next_2447 = sah_2337;
double history_2334_next_2448 = sah_2333;
double y1_next_2449 = sub_2317;
m_delay_12.write(in1);
m_delay_11.write(in1);
m_y_10 = y2_next_2440;
m_history_9 = history_2253_next_2441;
m_history_8 = history_2251_next_2442;
m_history_7 = history_2258_next_2443;
m_history_6 = history_2255_next_2444;
m_history_5 = history_2336_next_2445;
m_history_4 = history_2341_next_2446;
m_history_3 = history_2338_next_2447;
m_history_2 = history_2334_next_2448;
m_y_1 = y1_next_2449;
m_delay_11.step();
m_delay_12.step();
// assign results to output buffer;
(*(__out1++)) = out1;
};
return __exception;
};
// the signal processing routine;
inline int perform(t_sample ** __ins, t_sample ** __outs, int __n) {
vectorsize = __n;
const t_sample * __in1 = __ins[0];
t_sample * __out1 = __outs[0];
if (__exception) {
return __exception;
} else if (( (__in1 == 0) || (__out1 == 0) )) {
__exception = GENLIB_ERR_NULL_BUFFER;
return __exception;
};
double expr_5155 = safediv(((m_cutoff_16 * 2) * 3.1415926535898), 44100);
double sin_5012 = sin(expr_5155);
double clamp_5013 = ((sin_5012 <= 1e-05) ? 1e-05 : ((sin_5012 >= 0.99999) ? 0.99999 : sin_5012));
double mstosamps_5148 = (m_delay_14 * (samplerate * 0.001));
double mstosamps_5077 = (m_delay_18 * (samplerate * 0.001));
double rsub_5064 = (1 - m_ratio_12);
double mul_5063 = (rsub_5064 * 1000);
double div_5062 = safediv(mul_5063, m_delay_18);
samples_to_seconds = (1 / samplerate);
double rsub_5135 = (1 - m_ratio_15);
double mul_5134 = (rsub_5135 * 1000);
double div_5133 = safediv(mul_5134, m_delay_14);
// the main sample loop;
while ((__n--)) {
const double in1 = (*(__in1++));
double noise_5014 = noise();
double abs_5031 = fabs(noise_5014);
double mul_5035 = (abs_5031 * m_blur_17);
double noise_5086 = noise();
double abs_5104 = fabs(noise_5086);
double mul_5112 = (abs_5104 * m_blur_17);
double noise_5015 = noise();
double abs_5032 = fabs(noise_5015);
double mul_5038 = (abs_5032 * m_blur_17);
double noise_5084 = noise();
double abs_5102 = fabs(noise_5084);
double mul_5106 = (abs_5102 * m_blur_17);
double noise_5017 = noise();
double abs_5034 = fabs(noise_5017);
double mul_5044 = (abs_5034 * m_blur_17);
double noise_5087 = noise();
double abs_5105 = fabs(noise_5087);
double mul_5115 = (abs_5105 * m_blur_17);
double noise_5016 = noise();
double abs_5033 = fabs(noise_5016);
double mul_5041 = (abs_5033 * m_blur_17);
double noise_5085 = noise();
double abs_5103 = fabs(noise_5085);
double mul_5109 = (abs_5103 * m_blur_17);
double phasor_5083 = m_phasor_19(div_5062, samples_to_seconds);
double add_5055 = ((phasor_5083 + m_history_9) + 0.75);
double mod_5054 = safemod(add_5055, 1);
double delta_5037 = m_delta_20(mod_5054);
double sah_5018 = m_sah_21(mul_5035, delta_5037, 0);
double sah_5036 = m_sah_22(mstosamps_5077, delta_5037, 0);
double mul_5027 = (sah_5036 * mod_5054);
double sub_5053 = (mod_5054 - 0.5);
double mul_5052 = (sub_5053 * 3.1415926535898);
double cos_5051 = cos(mul_5052);
double mul_5046 = (cos_5051 * cos_5051);
double add_5061 = ((phasor_5083 + m_history_8) + 0.5);
double mod_5060 = safemod(add_5061, 1);
double delta_5040 = m_delta_23(mod_5060);
double sah_5020 = m_sah_24(mul_5038, delta_5040, 0);
double sah_5039 = m_sah_25(mstosamps_5077, delta_5040, 0);
double mul_5028 = (sah_5039 * mod_5060);
double sub_5059 = (mod_5060 - 0.5);
double mul_5058 = (sub_5059 * 3.1415926535898);
double cos_5057 = cos(mul_5058);
double mul_5047 = (cos_5057 * cos_5057);
double add_5082 = ((phasor_5083 + m_history_7) + 0);
double mod_5081 = safemod(add_5082, 1);
double delta_5025 = m_delta_26(mod_5081);
double sah_5024 = m_sah_27(mul_5044, delta_5025, 0);
double sah_5045 = m_sah_28(mstosamps_5077, delta_5025, 0);
double mul_5030 = (sah_5045 * mod_5081);
double sub_5080 = (mod_5081 - 0.5);
double mul_5079 = (sub_5080 * 3.1415926535898);
double cos_5078 = cos(mul_5079);
double mul_5049 = (cos_5078 * cos_5078);
double add_5076 = ((phasor_5083 + m_history_6) + 0.25);
double mod_5075 = safemod(add_5076, 1);
double delta_5043 = m_delta_29(mod_5075);
double sah_5022 = m_sah_30(mul_5041, delta_5043, 0);
double sah_5042 = m_sah_31(mstosamps_5077, delta_5043, 0);
double mul_5029 = (sah_5042 * mod_5075);
double tap_5068 = m_delay_11.read_linear(mul_5030);
double tap_5069 = m_delay_11.read_linear(mul_5029);
double tap_5070 = m_delay_11.read_linear(mul_5028);
double tap_5071 = m_delay_11.read_linear(mul_5027);
double mul_5050 = (tap_5071 * mul_5046);
double mul_5056 = (tap_5070 * mul_5047);
double mul_5066 = (tap_5068 * mul_5049);
double sub_5074 = (mod_5075 - 0.5);
double mul_5073 = (sub_5074 * 3.1415926535898);
double cos_5072 = cos(mul_5073);
double mul_5048 = (cos_5072 * cos_5072);
double mul_5065 = (tap_5069 * mul_5048);
double phasor_5154 = m_phasor_32(div_5133, samples_to_seconds);
double add_5147 = ((m_history_5 + phasor_5154) + 0.25);
double mod_5146 = safemod(add_5147, 1);
double delta_5114 = m_delta_33(mod_5146);
double sah_5092 = m_sah_34(mul_5112, delta_5114, 0);
double sah_5113 = m_sah_35(mstosamps_5148, delta_5114, 0);
double mul_5100 = (sah_5113 * mod_5146);
double sub_5145 = (mod_5146 - 0.5);
double mul_5144 = (sub_5145 * 3.1415926535898);
double cos_5143 = cos(mul_5144);
double mul_5119 = (cos_5143 * cos_5143);
double add_5126 = ((m_history_4 + phasor_5154) + 0.75);
double mod_5125 = safemod(add_5126, 1);
double delta_5108 = m_delta_36(mod_5125);
double sah_5088 = m_sah_37(mul_5106, delta_5108, 0);
double sah_5107 = m_sah_38(mstosamps_5148, delta_5108, 0);
double mul_5098 = (sah_5107 * mod_5125);
double sub_5124 = (mod_5125 - 0.5);
double mul_5123 = (sub_5124 * 3.1415926535898);
double cos_5122 = cos(mul_5123);
double mul_5117 = (cos_5122 * cos_5122);
double add_5153 = ((m_history_3 + phasor_5154) + 0);
double mod_5152 = safemod(add_5153, 1);
double delta_5095 = m_delta_39(mod_5152);
double sah_5094 = m_sah_40(mul_5115, delta_5095, 0);
double sah_5116 = m_sah_41(mstosamps_5148, delta_5095, 0);
double mul_5101 = (sah_5116 * mod_5152);
double sub_5151 = (mod_5152 - 0.5);
double mul_5150 = (sub_5151 * 3.1415926535898);
double cos_5149 = cos(mul_5150);
double mul_5120 = (cos_5149 * cos_5149);
double add_5132 = ((m_history_2 + phasor_5154) + 0.5);
double mod_5131 = safemod(add_5132, 1);
double delta_5111 = m_delta_42(mod_5131);
double sah_5090 = m_sah_43(mul_5109, delta_5111, 0);
double sah_5110 = m_sah_44(mstosamps_5148, delta_5111, 0);
double mul_5099 = (sah_5110 * mod_5131);
double tap_5139 = m_delay_10.read_linear(mul_5101);
double tap_5140 = m_delay_10.read_linear(mul_5100);
double tap_5141 = m_delay_10.read_linear(mul_5099);
double tap_5142 = m_delay_10.read_linear(mul_5098);
double mul_5137 = (tap_5139 * mul_5120);
double mul_5136 = (tap_5140 * mul_5119);
double mul_5121 = (tap_5142 * mul_5117);
double sub_5130 = (mod_5131 - 0.5);
double mul_5129 = (sub_5130 * 3.1415926535898);
double cos_5128 = cos(mul_5129);
double mul_5118 = (cos_5128 * cos_5128);
double mul_5127 = (tap_5141 * mul_5118);
double add_5174 = (((((((mul_5066 + mul_5065) + mul_5056) + mul_5050) + mul_5121) + mul_5127) + mul_5136) + mul_5137);
double mix_5173 = (m_y_1 + (clamp_5013 * (add_5174 - m_y_1)));
double mix_5010 = mix_5173;
double mix_5175 = (in1 + (m_mix_13 * (mix_5010 - in1)));
double out1 = mix_5175;
double history_5019_next_5156 = sah_5018;
double history_5021_next_5157 = sah_5020;
double history_5026_next_5158 = sah_5024;
double history_5023_next_5159 = sah_5022;
double history_5093_next_5160 = sah_5092;
double history_5089_next_5161 = sah_5088;
double history_5096_next_5162 = sah_5094;
double history_5091_next_5163 = sah_5090;
double y0_next_5164 = mix_5010;
m_delay_11.write(in1);
m_delay_10.write(in1);
m_history_9 = history_5019_next_5156;
m_history_8 = history_5021_next_5157;
m_history_7 = history_5026_next_5158;
m_history_6 = history_5023_next_5159;
m_history_5 = history_5093_next_5160;
m_history_4 = history_5089_next_5161;
m_history_3 = history_5096_next_5162;
m_history_2 = history_5091_next_5163;
m_y_1 = y0_next_5164;
m_delay_10.step();
m_delay_11.step();
// assign results to output buffer;
(*(__out1++)) = out1;
};
return __exception;
};
// Perform a moving linear least squares interpolation to arrays
// Input arguments:
// order: order of polynomial used (1 or 2)
// cutoff: the cutoff of weight (in grid points)
// coords: scaled coords [0,1] for interpolation
// N_c: number of grid points
// beg_c: first grid point
// data: the array used
// target: the results are stored in this array
PyObject* mlsqr(PyObject *self, PyObject *args)
{
// The order of interpolation
unsigned char order = -1;
// The cutoff for moving least squares
double cutoff = -1;
// The coordinates for interpolation: array of size (3, N)
PyArrayObject* coords = 0;
// Number of grid points
PyArrayObject* N_c = 0;
// Beginning of grid
PyArrayObject* beg_c = 0;
// The 3d-data to be interpolated: array of size (X, Y, Z)
PyArrayObject* data;
// The interpolation target: array of size (N,)
PyArrayObject* target = 0;
if (!PyArg_ParseTuple(args, "BdOOOOO", &order, &cutoff, &coords, &N_c, &beg_c, &data, &target))
{
return NULL;
}
int coeffs = -1;
if (order == 1)
{
coeffs = 4;
}
if (order == 2)
{
coeffs = 10;
// 1 x y z xy yz zx xx yy zz
}
if (order == 3)
{
// 1 x y z xy yz zx xx yy zz
// xxy xxz yyx yyz zzx zzy
// xxx yyy zzz zyz
coeffs = 20;
}
int points = coords->dimensions[0];
double* coord_nc = DOUBLEP(coords);
double* grid_points = DOUBLEP(N_c);
double* grid_start = DOUBLEP(beg_c);
double* target_n = DOUBLEP(target);
double* data_g = DOUBLEP(data);
// TODO: Calculate fit
const int sizex = ceil(cutoff);
const int sizey = ceil(cutoff);
const int sizez = ceil(cutoff);
// Allocate X-matrix and b-vector
int source_points = (2*sizex+1)*(2*sizey+1)*(2*sizez+1);
double* X = GPAW_MALLOC(double, coeffs*source_points);
double* b = GPAW_MALLOC(double, source_points);
double* work = GPAW_MALLOC(double, coeffs*source_points);
// The multipliers for each dimension
int ldx = data->dimensions[1]*data->dimensions[2];
int ldy = data->dimensions[2];
int ldz = 1;
// For each point to be interpolated
for (int p=0; p< points; p++)
{
double x = (*coord_nc++)*grid_points[0] - grid_start[0];
double y = (*coord_nc++)*grid_points[1] - grid_start[0];
double z = (*coord_nc++)*grid_points[2] - grid_start[0];
// The grid center point
int cx2 = round(x);
int cy2 = round(y);
int cz2 = round(z);
// Scaled to grid
int cx = safemod(cx2,data->dimensions[0]);
int cy = safemod(cy2,data->dimensions[1]);
int cz = safemod(cz2,data->dimensions[2]);
double* i_X = X;
double* i_b = b;
// For each point to take into account
for (int dx=-sizex;dx<=sizex;dx++)
for (int dy=-sizey;dy<=sizey;dy++)
for (int dz=-sizez;dz<=sizez;dz++)
{
// Coordinates centered on x,y,z
double sx = (cx2 + dx) - x;
double sy = (cy2 + dy) - y;
double sz = (cz2 + dz) - z;
// Normalized distance from center
double d = sqrt(sx*sx+sy*sy+sz*sz) / cutoff;
double w = 0.0;
if (d < 1)
{
w = (1-d)*(1-d);
w*=w;
w*=(4*d+1);
}
//double w = exp(-d*d);
*i_X++ = w*1.0;
*i_X++ = w*sx;
*i_X++ = w*sy;
*i_X++ = w*sz;
if (order > 1)
{
*i_X++ = w*sx*sy;
*i_X++ = w*sy*sz;
*i_X++ = w*sz*sx;
*i_X++ = w*sx*sx;
*i_X++ = w*sy*sy;
*i_X++ = w*sz*sz;
}
if (order > 2)
{
*i_X++ = w*sx*sy*sz; // xyz
*i_X++ = w*sx*sx*sx; // xxx
*i_X++ = w*sy*sy*sy; // yyy
*i_X++ = w*sz*sz*sz; // zzz
*i_X++ = w*sx*sx*sy; // xxy
*i_X++ = w*sx*sx*sz; // xxz
*i_X++ = w*sy*sy*sx; // yyx
*i_X++ = w*sy*sy*sz; // yyz
*i_X++ = w*sz*sz*sx; // zzx
*i_X++ = w*sz*sz*sy; // zzy
}
*i_b++ = w*data_g[ safemod(cx+dx, data->dimensions[0]) * ldx +
safemod(cy+dy, data->dimensions[1]) * ldy +
safemod(cz+dz, data->dimensions[2]) * ldz ];
}
int info = 0;
int rhs = 1;
int worksize = coeffs*source_points;
int ldb = source_points;
dgels_("T",
&coeffs, // ...times 4.
&source_points, // lhs is of size sourcepoints...
&rhs, // one rhs.
X, // provide lhs
&coeffs, // Leading dimension of X
b, // provide rhs
&ldb, // Leading dimension of b
work, // work array (and output)
&worksize, // the size of work array
&info); // info
if (info != 0)
printf("WARNING: dgels returned %d!", info);
// Evaluate the polynomial
// Due to centered coordinates, it's just the constant term
double value = b[0];
*target_n++ = value;
//Nearest neighbour
//double value = data_g[ cx*data->dimensions[1]*data->dimensions[2] + cy*data->dimensions[2] + cz ];
//printf("%.5f" , value);
}
free(work);
free(b);
free(X);
Py_RETURN_NONE;
}
