double SwitchingFunction::calculate(double distance,double&dfunc)const{
plumed_massert(init,"you are trying to use an unset SwitchingFunction");
if(distance>dmax){
dfunc=0.0;
return 0.0;
}
const double rdist = (distance-d0)*invr0;
double result;
if(rdist<=0.){
result=1.;
dfunc=0.0;
}else{
if(type==smap){
double sx=c*pow( rdist, a );
result=pow( 1.0 + sx, d );
dfunc=-b*sx/rdist*result/(1.0+sx);
} else if(type==rational){
result=do_rational(rdist,dfunc,nn,mm);
}else if(type==exponential){
result=exp(-rdist);
dfunc=-result;
}else if(type==nativeq){
double rdist2 = beta*(distance - lambda * ref);
double exprdist=exp(rdist2);
result=1./(1.+exprdist);
dfunc=-exprdist/(1.+exprdist)/(1.+exprdist);
}else if(type==gaussian){
result=exp(-0.5*rdist*rdist);
dfunc=-rdist*result;
}else if(type==cubic){
double tmp1=rdist-1, tmp2=(1+2*rdist);
result=tmp1*tmp1*tmp2;
dfunc=2*tmp1*tmp2 + 2*tmp1*tmp1;
}else if(type==tanh){
double tmp1=std::tanh(rdist);
result = 1.0 - tmp1;
dfunc=-(1-tmp1*tmp1);
#ifdef __PLUMED_HAS_MATHEVAL
}else if(type==matheval){
result=evaluator_evaluate_x(evaluator,rdist);
dfunc=evaluator_evaluate_x(evaluator_deriv,rdist);
#endif
}else plumed_merror("Unknown switching function type");
// this is for the chain rule:
dfunc*=invr0;
// this is because calculate() sets dfunc to the derivative divided times the distance.
// (I think this is misleading and I would like to modify it - GB)
dfunc/=distance;
}
result=result*stretch+shift;
dfunc*=stretch;
return result;
}
void
cv1d_mult_with_scaled_ft_fct_ (complex *a,
/*double (*b_real) (),
double (*b_imag) (),*/
void *b_real,
void *b_imag,
double scale,
int begin,
int end,
real b_step,
real b_begin)
{
register complex tmp;
register real tmp2;
register int i;
register double b_r;
register double b_i;
assert (a != 0);
assert (b_real != 0);
if (b_imag) {
for (i = begin; i <= end; i++) {
tmp = a[i];
tmp2 = (double) (b_begin + i*b_step)*scale;
b_r = scale*evaluator_evaluate_x(b_real,tmp2);
b_i = scale*evaluator_evaluate_x(b_imag,tmp2);
a[i].real = a[i].real*b_r - a[i].imag*b_i;
a[i].imag = tmp.real *b_i + tmp.imag *b_r;
/* Update the sum of the squared mof of the filter. */
flt_squared_mod_sum_ += b_r*b_r + b_i*b_i;
}
} else {
for (i = begin; i <= end; i++) {
tmp2 = scale * evaluator_evaluate_x(b_real,((double)(b_begin+i*b_step))*scale);
a[i].real *= tmp2;
a[i].imag *= tmp2;
/* Update the sum of the squared mof of the filter. */
flt_squared_mod_sum_ += tmp2*tmp2;
}
}
return;
}
double newtonrap(double x0, double es, double *ea, int imax, int *iter, int tabla, char *buffer, char *buffer2)
{
double x1=x0;
void *f, *f2; /* Evaluators for function and function derivative. */
/* Create evaluator for function. */
f = evaluator_create (buffer);
f2 = evaluator_create (buffer2);
assert (f);
assert (f2);
if(tabla == 1)
{
printf ("\n\n| i | Raiz | ea | f(xr) | \n");
printf ("______________________________________________________\n");
}
*iter = 0;
do{
x0 = x1;
x1 = x0-(evaluator_evaluate_x(f,x0)/evaluator_evaluate_x(f2,x0));
*iter=*iter+1;
if(x1!=0)
{
*ea=fabs((x1-x0)/x1)*100;
}
if ( tabla == 1 ) {
printf ("| %2d | %12.8f | %12.8f | %12.8f |\n", *iter, x1, *ea, evaluator_evaluate_x(f,x1) );
}
}while(es < *ea && *iter <= imax);
evaluator_destroy(f);
evaluator_destroy(f2);
if ( tabla == 1 ) {
printf ("\n\nLa Raiz es %6.4lf en %d iteraciones\n",x1,*iter);
printf ("\n\nEl error relativo aproximado es %6.4lf\n",*ea);
return 0;
}
else
return x1;
}
/*
* Compute from BEGIN to END the multiplication between an array of
* complex data and a complex function. The complex function is given
* by 2 C-function pointer, one for its real part and one for its
* imaginary part. If the pointer for the imaginary part is set to
* NULL, it is considered the complex function has no imaginary
* part.
*/
void
cv1d_cplx_mult_num_ana_ (complex *a,
/*double (*b_real) (),
double (*b_imag) (),*/
void *b_real,
void *b_imag,
int begin,
int end,
real b_step,
real b_begin)
{
register complex tmp;
register real tmp2;
register double b_r;
register double b_i;
register int i;
assert (a != 0);
assert (b_real != 0);
if (b_imag) {
for (i = begin; i <= end; i++) {
tmp = a[i];
tmp2 = b_begin + i*b_step;
b_r = evaluator_evaluate_x(b_real,(double)(tmp2));
b_i = evaluator_evaluate_x(b_imag,(double)(tmp2));
a[i].real = a[i].real*b_r - a[i].imag*b_i;
a[i].imag = tmp.real*b_i + tmp.imag*b_r;
/* Update the sum of the squared mof of the filter. */
flt_squared_mod_sum_ += b_r*b_r + b_i*b_i;
}
} else {
for (i = begin; i <= end; i++) {
tmp2 = evaluator_evaluate_x(b_real,(double)(b_begin+i*b_step));
a[i].real *= tmp2;
a[i].imag *= tmp2;
/* Update the sum of the squared mof of the filter. */
flt_squared_mod_sum_ += tmp2*tmp2;
}
}
}
double pfijo(double x0, double es, double *ea, int imax, int *iter, int tabla, char *buffer)
{
double xr=x0, xrold;
void *f; /* Evaluators for function and function derivative. */
/* Create evaluator for function. */
f = evaluator_create (buffer);
assert (f);
if(tabla == 1)
{
printf ("\n\n| i | Raiz | ea | f(xr) | \n");
printf ("______________________________________________________\n");
}
*iter = 0;
do{
xrold = xr;
xr = evaluator_evaluate_x(f,xrold);
*iter=*iter+1;
if(xr!=0)
{
*ea=fabs((xr-xrold)/xr)*100;
}
if ( tabla == 1 ) {
printf ("| %2d | %12.8f | %12.8f | %12.8f |\n", *iter, xr, *ea, evaluator_evaluate_x(f,xr) );
}
}while(es < *ea && *iter <= imax);
evaluator_destroy(f);
if ( tabla == 1 ) {
printf ("\n\nLa Raiz es %6.4lf en %d iteraciones\n",xr,*iter);
printf ("\n\nEl error relativo aproximado es %6.4lf\n",*ea);
return 0;
}
else
return xr;
}
/*
* TODO - Como graficar de manera que el "path" que se forma al unir los puntos
* concuerde con la gráfica. Por ejemplo, la función tan(x) presenta asÃntotas verticales
* en los múltiplos impares de pi/2.
* Entonces se tiene un punto de la forma (a,f(a)) unido a (b,f(b)) donde a < n*pi/2 < b, y
* f(a) >>>> f(b)... entonces se genera una linea que atraviesa la que seria la asintota horizontal.
*/
static void
gs_function_plot_draw (GsPlot *plot, GsGraphTransform *t, GsRectangle *v, cairo_t *cr)
{
GsPoint point, d_point, d_prev_point;
if (GS_FUNCTION_PLOT (plot)->priv->matheval_c == NULL) {
return;
}
d_prev_point. x = -1;
d_prev_point.y = -1;
cairo_save (cr);
gdk_cairo_set_source_color (cr, &(plot->priv->color));
// cairo_set_line_join (cr, CAIRO_LINE_JOIN_BEVEL);
for (point.x = v->x1; point.x <= v->x2; point.x += 0.05) {
point.y = evaluator_evaluate_x (GS_FUNCTION_PLOT (plot)->priv->matheval_c,
point.x);
gs_point_to_pixel (t, &point, &d_point);
if (d_prev_point.x > -1 && d_prev_point.y > -1) {
/* cairo_move_to (cr, d_prev_point.x, d_prev_point.y);
cairo_line_to (cr, d_point.x, d_point.y);
cairo_stroke (cr);*/
cairo_arc (cr, d_point.x, d_point.y, 1., 0., M_PI * 2);
cairo_fill (cr);
}
d_prev_point.x = d_point.x;
d_prev_point.y = d_point.y;
}
cairo_restore (cr);
}
/*!
\brief convert_before_download() converts the value passed using the
conversions bound to the widget
\param widget (GtkWidget *) widget to extract the conversion info from
\param value (gfloat *) the "real world" value from the tuning gui before
translation to MS-units
\returns the integere ms-units form after conversion
*/
G_MODULE_EXPORT gint convert_before_download(GtkWidget *widget, gfloat value)
{
static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
gint return_value = 0;
gint tmpi = 0;
gchar * conv_expr = NULL;
void *evaluator = NULL;
DataSize size = MTX_U08;
float lower = 0.0;
float upper = 0.0;
gfloat *multiplier = NULL;
gfloat *adder = NULL;
guint i = 0;
GHashTable *mhash = NULL;
GHashTable *ahash = NULL;
gchar *key_list = NULL;
gchar *mult_list = NULL;
gchar *add_list = NULL;
gchar **keys = NULL;
gchar **mults = NULL;
gchar **adds = NULL;
gint table_num = 0;
gchar *tmpbuf = NULL;
gchar * source_key = NULL;
gchar * hash_key = NULL;
gint *algorithm = NULL;
GHashTable *sources_hash = NULL;
sources_hash = DATA_GET(global_data,"sources_hash");
algorithm = DATA_GET(global_data,"algorithm");
g_static_mutex_lock(&mutex);
if (!OBJ_GET(widget,"size"))
printf(__FILE__"%s %s\n",_(": convert_before_download, FATAL ERROR, size undefined for widget %s "),glade_get_widget_name(widget));
size = (DataSize)OBJ_GET(widget,"size");
if (OBJ_GET(widget,"raw_lower"))
lower = (gfloat)strtol(OBJ_GET(widget,"raw_lower"),NULL,10);
else
lower = (gfloat)get_extreme_from_size(size,LOWER);
if (OBJ_GET(widget,"raw_upper"))
upper = (gfloat)strtol(OBJ_GET(widget,"raw_upper"),NULL,10);
else
upper = (gfloat)get_extreme_from_size(size,UPPER);
/* MULTI EXPRESSION ONLY! */
if (OBJ_GET(widget,"multi_expr_keys"))
{
if ((!OBJ_GET(widget,"mhash")) && (!OBJ_GET(widget,"ahash")))
{
mhash = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,g_free);
ahash = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,g_free);
key_list = OBJ_GET(widget,"multi_expr_keys");
mult_list = OBJ_GET(widget,"fromecu_mults");
add_list = OBJ_GET(widget,"fromecu_addds");
keys = g_strsplit(key_list,",",-1);
mults = g_strsplit(mult_list,",",-1);
adds = g_strsplit(add_list,",",-1);
for (i=0;i<MIN(g_strv_length(keys),g_strv_length(mults));i++)
{
multiplier = g_new0(gfloat, 1);
*multiplier = (gfloat)g_strtod(mults[i],NULL);
g_hash_table_insert(mhash,g_strdup(keys[i]),multiplier);
adder = g_new0(gfloat, 1);
*adder = (gfloat)g_strtod(adds[i],NULL);
g_hash_table_insert(ahash,g_strdup(keys[i]),adder);
}
g_strfreev(keys);
g_strfreev(mults);
g_strfreev(adds);
OBJ_SET_FULL(widget,"mhash",mhash,g_hash_table_destroy);
OBJ_SET_FULL(widget,"ahash",ahash,g_hash_table_destroy);
}
mhash = OBJ_GET(widget,"mhash");
ahash = OBJ_GET(widget,"ahash");
source_key = OBJ_GET(widget,"source_key");
if (!source_key)
printf(_("big problem, source key is undefined!!\n"));
hash_key = (gchar *)g_hash_table_lookup(sources_hash,source_key);
tmpbuf = (gchar *)OBJ_GET(widget,"table_num");
if (tmpbuf)
table_num = (GINT)strtol(tmpbuf,NULL,10);
if (table_num == -1) /* Not a table */
{
if (!hash_key)
{
multiplier = g_hash_table_lookup(mhash,"DEFAULT");
adder = g_hash_table_lookup(ahash,"DEFAULT");
}
else
{
multiplier = g_hash_table_lookup(mhash,(gchar *)hash_key);
adder = g_hash_table_lookup(ahash,(gchar *)hash_key);
}
}
else /* This is a 3d table */
{
switch (algorithm[table_num])
{
case SPEED_DENSITY:
if (!hash_key)
{
multiplier = g_hash_table_lookup(mhash,"DEFAULT");
adder = g_hash_table_lookup(ahash,"DEFAULT");
}
else
{
multiplier = g_hash_table_lookup(mhash,hash_key);
adder = g_hash_table_lookup(ahash,hash_key);
}
break;
case ALPHA_N:
multiplier = g_hash_table_lookup(mhash,"DEFAULT");
adder = g_hash_table_lookup(ahash,"DEFAULT");
break;
case MAF:
multiplier = g_hash_table_lookup(mhash,"AFM_VOLTS");
adder = g_hash_table_lookup(ahash,"AFM_VOLTS");
break;
}
}
/* Reverse calc due to this being TO the ecu */
if ((multiplier) && (adder))
return_value = (GINT)((value - (*adder))/(*multiplier));
else if (multiplier)
return_value = (GINT)(value/(*multiplier));
else
return_value = (GINT)value;
}
else /* NON Multi Expression */
{
conv_expr = (gchar *)OBJ_GET(widget,"toecu_conv_expr");
/* Expression is NOT multi expression but has more complex math*/
if (conv_expr)
{
evaluator = (void *)OBJ_GET(widget,"dl_evaluator");
if (!evaluator)
{
evaluator = evaluator_create(conv_expr);
assert(evaluator);
OBJ_SET_FULL(widget,"dl_evaluator",(gpointer)evaluator,evaluator_destroy);
}
return_value = (GINT)evaluator_evaluate_x(evaluator,value);
}
else
{
multiplier = (gfloat *)OBJ_GET(widget,"fromecu_mult");
adder = (gfloat *)OBJ_GET(widget,"fromecu_add");
/* Handle all cases of with or without multiplier/adder*/
if ((multiplier) && (adder))
return_value = (GINT)((value - (*adder))/(*multiplier));
else if (multiplier)
return_value = (GINT)(value/(*multiplier));
else
return_value = (GINT)value;
}
}
dbg_func(CONVERSIONS,g_strdup_printf(__FILE__": convert_before_dl():\n\t widget %s raw %.2f, sent %i\n",glade_get_widget_name(widget),value,return_value));
if (return_value > upper)
{
dbg_func(CONVERSIONS|CRITICAL,g_strdup_printf(__FILE__": convert_before_download()\n\t WARNING value clamped at %f (%f <- %f -> %f)!!\n",upper,lower,value,upper));
return_value = upper;
}
if (return_value < lower)
{
dbg_func(CONVERSIONS|CRITICAL,g_strdup_printf(__FILE__": convert_before_download()\n\t WARNING value clamped at %f (%f <- %f -> %f)!!\n",lower,lower,value,upper));
return_value = lower;
}
tmpi = return_value;
if (OBJ_GET(widget,"lookuptable"))
return_value = (GINT)reverse_lookup_obj(G_OBJECT(widget),tmpi);
g_static_mutex_unlock(&mutex);
return (return_value);
}
/*!
\brief convert_after_upload() converts the ms-units data to the real world
units for display on the GUI
\param widget (GtkWidget *) to extract the conversion info from to perform
the necessary math
\returns the real world value for the GUI
*/
G_MODULE_EXPORT gfloat convert_after_upload(GtkWidget * widget)
{
static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
static gint (*get_ecu_data_f)(gpointer);
static void (*send_to_ecu_f)(gpointer, gint, gboolean) = NULL;
gfloat return_value = 0.0;
gchar * conv_expr = NULL;
void *evaluator = NULL;
gint tmpi = 0;
DataSize size = 0;
gfloat lower = 0.0;
gfloat upper = 0.0;
gboolean fromecu_complex = FALSE;
guint i = 0;
gint table_num = -1;
GHashTable *mhash = NULL;
GHashTable *ahash = NULL;
gchar *key_list = NULL;
gchar *mult_list = NULL;
gchar *add_list = NULL;
gchar **keys = NULL;
gchar **mults = NULL;
gchar **adds = NULL;
gchar * tmpbuf = NULL;
gchar * source_key = NULL;
gchar * hash_key = NULL;
gfloat *multiplier = NULL;
gfloat *adder = NULL;
gint *algorithm = NULL;
GHashTable *sources_hash = NULL;
extern gconstpointer *global_data;
if (!get_ecu_data_f)
get_symbol("get_ecu_data",(void *)&get_ecu_data_f);
if (!send_to_ecu_f)
get_symbol("send_to_ecu",(void *)&send_to_ecu_f);
g_return_val_if_fail(get_ecu_data_f,0.0);
g_return_val_if_fail(send_to_ecu_f,0.0);
g_static_mutex_lock(&mutex);
size = (DataSize)OBJ_GET(widget,"size");
if (size == 0)
{
printf(_("BIG PROBLEM, size undefined! widget %s, default to U08 \n"),(gchar *)glade_get_widget_name(widget));
size = MTX_U08;
}
if (OBJ_GET(widget,"raw_lower"))
lower = (gfloat)strtol(OBJ_GET(widget,"raw_lower"),NULL,10);
else
lower = (gfloat)get_extreme_from_size(size,LOWER);
if (OBJ_GET(widget,"raw_upper"))
upper = (gfloat)strtol(OBJ_GET(widget,"raw_upper"),NULL,10);
else
upper = (gfloat)get_extreme_from_size(size,UPPER);
fromecu_complex = (GBOOLEAN)OBJ_GET(widget,"fromecu_complex");
if (fromecu_complex)
{
g_static_mutex_unlock(&mutex);
/*printf("Complex upload conversion for widget at page %i, offset %i, name %s\n",(GINT)OBJ_GET(widget,"page"),(GINT)OBJ_GET(widget,"offset"),glade_get_widget_name(widget));
*/
return handle_complex_expr_obj(G_OBJECT(widget),NULL,UPLOAD);
}
if (OBJ_GET(widget,"lookuptable"))
tmpi = lookup_data_obj(G_OBJECT(widget),get_ecu_data_f(widget));
else
tmpi = get_ecu_data_f(widget);
if (tmpi < lower)
{
dbg_func(CONVERSIONS|CRITICAL,g_strdup_printf(__FILE__": convert_after_upload()\n\t WARNING RAW value out of range for widget %s, clamped at %.1f (%.1f <- %i -> %.1f), updating ECU with valid value within limits!!\n",(gchar *)glade_get_widget_name(widget),lower,lower,tmpi,upper));
tmpi = lower;
send_to_ecu_f(widget,tmpi,TRUE);
}
if (tmpi > upper)
{
dbg_func(CONVERSIONS|CRITICAL,g_strdup_printf(__FILE__": convert_after_upload()\n\t WARNING RAW value out of range for widget %s, clamped at %.1f (%.1f <- %i -> %.1f), updating ECU with valid value within limits!!\n",(gchar *)glade_get_widget_name(widget),lower,lower,tmpi,upper));
tmpi = upper;
send_to_ecu_f(widget,tmpi,TRUE);
}
/* MULTI EXPRESSION ONLY! */
if (OBJ_GET(widget,"multi_expr_keys"))
{
sources_hash = DATA_GET(global_data,"sources_hash");
if ((!OBJ_GET(widget,"mhash")) && (!OBJ_GET(widget,"ahash")))
{
mhash = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,g_free);
ahash = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,g_free);
key_list = OBJ_GET(widget,"multi_expr_keys");
mult_list = OBJ_GET(widget,"fromecu_mults");
add_list = OBJ_GET(widget,"fromecu_adds");
if (!mult_list)
printf("BUG, widget %s is multi_expression but doesn't have fromecu_mults defined!\n",glade_get_widget_name(widget));
if (!add_list)
printf("BUG, widget %s is multi_expression but doesn't have fromecu_adds defined!\n",glade_get_widget_name(widget));
keys = g_strsplit(key_list,",",-1);
mults = g_strsplit(mult_list,",",-1);
adds = g_strsplit(add_list,",",-1);
for (i=0;i<MIN(g_strv_length(keys),g_strv_length(mults));i++)
{
multiplier = g_new0(gfloat, 1);
*multiplier = (gfloat)g_strtod(mults[i],NULL);
g_hash_table_insert(mhash,g_strdup(keys[i]),multiplier);
adder = g_new0(gfloat, 1);
*adder = (gfloat)g_strtod(adds[i],NULL);
g_hash_table_insert(ahash,g_strdup(keys[i]),adder);
}
g_strfreev(keys);
g_strfreev(mults);
g_strfreev(adds);
OBJ_SET_FULL(widget,"mhash",mhash,g_hash_table_destroy);
OBJ_SET_FULL(widget,"ahash",ahash,g_hash_table_destroy);
}
mhash = OBJ_GET(widget,"mhash");
ahash = OBJ_GET(widget,"ahash");
source_key = OBJ_GET(widget,"source_key");
if (!source_key)
printf(_("big problem, source key is undefined!!\n"));
hash_key = (gchar *)g_hash_table_lookup(sources_hash,source_key);
tmpbuf = (gchar *)OBJ_GET(widget,"table_num");
if (tmpbuf)
table_num = (GINT)strtol(tmpbuf,NULL,10);
if (table_num == -1)
{
if (!hash_key)
{
multiplier = g_hash_table_lookup(mhash,"DEFAULT");
adder = g_hash_table_lookup(ahash,"DEFAULT");
}
else
{
multiplier = g_hash_table_lookup(mhash,(gchar *)hash_key);
adder = g_hash_table_lookup(ahash,(gchar *)hash_key);
}
}
else
{
algorithm = DATA_GET(global_data,"algorithm");
switch (algorithm[table_num])
{
case SPEED_DENSITY:
if (!hash_key)
{
multiplier = g_hash_table_lookup(mhash,"DEFAULT");
adder = g_hash_table_lookup(ahash,"DEFAULT");
}
else
{
multiplier = g_hash_table_lookup(mhash,hash_key);
adder = g_hash_table_lookup(ahash,hash_key);
}
break;
case ALPHA_N:
multiplier = g_hash_table_lookup(mhash,"DEFAULT");
adder = g_hash_table_lookup(ahash,"DEFAULT");
break;
case MAF:
multiplier = g_hash_table_lookup(mhash,"AFM_VOLTS");
adder = g_hash_table_lookup(ahash,"AFM_VOLTS");
break;
}
}
if ((multiplier) && (adder))
return_value = (((gfloat)tmpi * (*multiplier)) + (*adder));
else if (multiplier)
return_value = (gfloat)tmpi * (*multiplier);
else
return_value = (gfloat)tmpi;
}
else
{
conv_expr = (gchar *)OBJ_GET(widget,"fromecu_conv_expr");
if (conv_expr)
{
evaluator = (void *)OBJ_GET(widget,"ul_evaluator");
if (!evaluator)
{
evaluator = evaluator_create(conv_expr);
assert(evaluator);
OBJ_SET_FULL(widget,"ul_evaluator",(gpointer)evaluator,evaluator_destroy);
}
return_value = evaluator_evaluate_x(evaluator,tmpi);
}
else
{
multiplier = OBJ_GET(widget,"fromecu_mult");
adder = OBJ_GET(widget,"fromecu_add");
if ((multiplier) && (adder))
return_value = (((gfloat)tmpi * (*multiplier)) + (*adder));
else if (multiplier)
return_value = (gfloat)tmpi * (*multiplier);
else
return_value = (gfloat)tmpi;
/*dbg_func(CONVERSIONS,g_strdup_printf(__FILE__": convert_after_ul():\n\tNo/Fast CONVERSION defined for widget %s, value %f\n",(gchar *)glade_get_widget_name(widget), return_value));*/
}
}
// dbg_func(CONVERSIONS,g_strdup_printf(__FILE__": convert_after_ul()\n\t page %i,offset %i, raw %i, val %f\n",page,offset,tmpi,return_value));
g_static_mutex_unlock(&mutex);
return (return_value);
}
int core_oph_predicate2(oph_stringPtr byte_array, char *result)
{
unsigned long i, occurrence, occurrence_number = 0;
unsigned short r;
double res, temporary;
oph_predicate2_param *_result = (oph_predicate2_param *) result;
if (_result->occurrence < 0)
occurrence = 1;
else
occurrence = (unsigned long) _result->occurrence;
switch (byte_array->type) {
case OPH_DOUBLE:
{
for (i = _result->occurrence < 0 ? byte_array->numelem - 1 : 0; (0 <= i) && (i < byte_array->numelem); _result->occurrence < 0 ? --i : ++i) {
res = evaluator_evaluate_x(_result->f[1], *((double *) (byte_array->content + i * byte_array->elemsize)));
switch (_result->op) {
case OPH_GREATER_THAN_ZERO:
{
r = res > 0.0;
break;
}
case OPH_LESS_THAN_ZERO:
{
r = res < 0.0;
break;
}
case OPH_EQUAL_TO_ZERO:
{
r = res == 0.0;
break;
}
case OPH_GREATER_OR_EQUAL_TO_ZERO:
{
r = res >= 0.0;
break;
}
case OPH_LESS_OR_EQUAL_TO_ZERO:
{
r = res <= 0.0;
break;
}
case OPH_NOT_EQUAL_TO_ZERO:
{
r = res != 0.0;
break;
}
case OPH_NULL:
{
r = isnan(res);
break;
}
default:
pmesg(1, __FILE__, __LINE__, "Comparison value non recognized\n");
return -1;
}
if (occurrence && r) {
occurrence_number++;
if (occurrence != occurrence_number)
r = 0;
}
temporary = evaluator_evaluate_x(_result->f[r ? 2 : 3], *((double *) (byte_array->content + i * byte_array->elemsize)));
if (core_oph_type_cast(&temporary, (((char *) _result->f[0]) + i * _result->result_elemsize), OPH_DOUBLE, _result->result_type, byte_array->missingvalue)) {
pmesg(1, __FILE__, __LINE__, "Unable to find result\n");
return 1;
}
}
break;
}
case OPH_FLOAT:
{
for (i = _result->occurrence < 0 ? byte_array->numelem - 1 : 0; (0 <= i) && (i < byte_array->numelem); _result->occurrence < 0 ? --i : ++i) {
res = evaluator_evaluate_x(_result->f[1], *((float *) (byte_array->content + i * byte_array->elemsize)));
switch (_result->op) {
case OPH_GREATER_THAN_ZERO:
{
r = res > 0.0;
break;
}
case OPH_LESS_THAN_ZERO:
{
r = res < 0.0;
break;
}
case OPH_EQUAL_TO_ZERO:
{
r = res == 0.0;
break;
}
case OPH_GREATER_OR_EQUAL_TO_ZERO:
{
r = res >= 0.0;
break;
}
case OPH_LESS_OR_EQUAL_TO_ZERO:
{
r = res <= 0.0;
break;
}
case OPH_NOT_EQUAL_TO_ZERO:
{
r = res != 0.0;
break;
}
case OPH_NULL:
{
r = isnan(res);
break;
}
default:
pmesg(1, __FILE__, __LINE__, "Comparison value non recognized\n");
return -1;
}
if (occurrence && r) {
occurrence_number++;
if (occurrence != occurrence_number)
r = 0;
}
temporary = evaluator_evaluate_x(_result->f[r ? 2 : 3], *((float *) (byte_array->content + i * byte_array->elemsize)));
if (core_oph_type_cast(&temporary, (((char *) _result->f[0]) + i * _result->result_elemsize), OPH_DOUBLE, _result->result_type, byte_array->missingvalue)) {
pmesg(1, __FILE__, __LINE__, "Unable to find result\n");
return 1;
}
}
break;
}
case OPH_INT:
{
for (i = _result->occurrence < 0 ? byte_array->numelem - 1 : 0; (0 <= i) && (i < byte_array->numelem); _result->occurrence < 0 ? --i : ++i) {
res = evaluator_evaluate_x(_result->f[1], *((int *) (byte_array->content + i * byte_array->elemsize)));
switch (_result->op) {
case OPH_GREATER_THAN_ZERO:
{
r = res > 0.0;
break;
}
case OPH_LESS_THAN_ZERO:
{
r = res < 0.0;
break;
}
case OPH_EQUAL_TO_ZERO:
{
r = res == 0.0;
break;
}
case OPH_GREATER_OR_EQUAL_TO_ZERO:
{
r = res >= 0.0;
break;
}
case OPH_LESS_OR_EQUAL_TO_ZERO:
{
r = res <= 0.0;
break;
}
case OPH_NOT_EQUAL_TO_ZERO:
{
r = res != 0.0;
break;
}
case OPH_NULL:
{
r = isnan(res);
break;
}
default:
pmesg(1, __FILE__, __LINE__, "Comparison value non recognized\n");
return -1;
}
if (occurrence && r) {
occurrence_number++;
if (occurrence != occurrence_number)
r = 0;
}
temporary = evaluator_evaluate_x(_result->f[r ? 2 : 3], *((int *) (byte_array->content + i * byte_array->elemsize)));
if (core_oph_type_cast(&temporary, (((char *) _result->f[0]) + i * _result->result_elemsize), OPH_DOUBLE, _result->result_type, byte_array->missingvalue)) {
pmesg(1, __FILE__, __LINE__, "Unable to find result\n");
return 1;
}
}
break;
}
case OPH_SHORT:
{
for (i = _result->occurrence < 0 ? byte_array->numelem - 1 : 0; (0 <= i) && (i < byte_array->numelem); _result->occurrence < 0 ? --i : ++i) {
res = evaluator_evaluate_x(_result->f[1], *((short *) (byte_array->content + i * byte_array->elemsize)));
switch (_result->op) {
case OPH_GREATER_THAN_ZERO:
{
r = res > 0.0;
break;
}
case OPH_LESS_THAN_ZERO:
{
r = res < 0.0;
break;
}
case OPH_EQUAL_TO_ZERO:
{
r = res == 0.0;
break;
}
case OPH_GREATER_OR_EQUAL_TO_ZERO:
{
r = res >= 0.0;
break;
}
case OPH_LESS_OR_EQUAL_TO_ZERO:
{
r = res <= 0.0;
break;
}
case OPH_NOT_EQUAL_TO_ZERO:
{
r = res != 0.0;
break;
}
case OPH_NULL:
{
r = isnan(res);
break;
}
default:
pmesg(1, __FILE__, __LINE__, "Comparison value non recognized\n");
return -1;
}
if (occurrence && r) {
occurrence_number++;
if (occurrence != occurrence_number)
r = 0;
}
temporary = evaluator_evaluate_x(_result->f[r ? 2 : 3], *((short *) (byte_array->content + i * byte_array->elemsize)));
if (core_oph_type_cast(&temporary, (((char *) _result->f[0]) + i * _result->result_elemsize), OPH_DOUBLE, _result->result_type, byte_array->missingvalue)) {
pmesg(1, __FILE__, __LINE__, "Unable to find result\n");
return 1;
}
}
break;
}
case OPH_BYTE:
{
for (i = _result->occurrence < 0 ? byte_array->numelem - 1 : 0; (0 <= i) && (i < byte_array->numelem); _result->occurrence < 0 ? --i : ++i) {
res = evaluator_evaluate_x(_result->f[1], *((char *) (byte_array->content + i * byte_array->elemsize)));
switch (_result->op) {
case OPH_GREATER_THAN_ZERO:
{
r = res > 0.0;
break;
}
case OPH_LESS_THAN_ZERO:
{
r = res < 0.0;
break;
}
case OPH_EQUAL_TO_ZERO:
{
r = res == 0.0;
break;
}
case OPH_GREATER_OR_EQUAL_TO_ZERO:
{
r = res >= 0.0;
break;
}
case OPH_LESS_OR_EQUAL_TO_ZERO:
{
r = res <= 0.0;
break;
}
case OPH_NOT_EQUAL_TO_ZERO:
{
r = res != 0.0;
break;
}
case OPH_NULL:
{
r = isnan(res);
break;
}
default:
pmesg(1, __FILE__, __LINE__, "Comparison value non recognized\n");
return -1;
}
if (occurrence && r) {
occurrence_number++;
if (occurrence != occurrence_number)
r = 0;
}
temporary = evaluator_evaluate_x(_result->f[r ? 2 : 3], *((char *) (byte_array->content + i * byte_array->elemsize)));
if (core_oph_type_cast(&temporary, (((char *) _result->f[0]) + i * _result->result_elemsize), OPH_DOUBLE, _result->result_type, byte_array->missingvalue)) {
pmesg(1, __FILE__, __LINE__, "Unable to find result\n");
return 1;
}
}
break;
}
case OPH_LONG:
{
for (i = _result->occurrence < 0 ? byte_array->numelem - 1 : 0; (0 <= i) && (i < byte_array->numelem); _result->occurrence < 0 ? --i : ++i) {
res = evaluator_evaluate_x(_result->f[1], *((long long *) (byte_array->content + i * byte_array->elemsize)));
switch (_result->op) {
case OPH_GREATER_THAN_ZERO:
{
r = res > 0.0;
break;
}
case OPH_LESS_THAN_ZERO:
{
r = res < 0.0;
break;
}
case OPH_EQUAL_TO_ZERO:
{
r = res == 0.0;
break;
}
case OPH_GREATER_OR_EQUAL_TO_ZERO:
{
r = res >= 0.0;
break;
}
case OPH_LESS_OR_EQUAL_TO_ZERO:
{
r = res <= 0.0;
break;
}
case OPH_NOT_EQUAL_TO_ZERO:
{
r = res != 0.0;
break;
}
case OPH_NULL:
{
r = isnan(res);
break;
}
default:
pmesg(1, __FILE__, __LINE__, "Comparison value non recognized\n");
return -1;
}
if (occurrence && r) {
occurrence_number++;
if (occurrence != occurrence_number)
r = 0;
}
temporary = evaluator_evaluate_x(_result->f[r ? 2 : 3], *((long long *) (byte_array->content + i * byte_array->elemsize)));
if (core_oph_type_cast(&temporary, (((char *) _result->f[0]) + i * _result->result_elemsize), OPH_DOUBLE, _result->result_type, byte_array->missingvalue)) {
pmesg(1, __FILE__, __LINE__, "Unable to find result\n");
return 1;
}
}
break;
}
default:
pmesg(1, __FILE__, __LINE__, "Type non recognized\n");
return -1;
}
return 0;
}
double
Polynomial::evaluate_x( double x )
{
assign( "x", x );
return evaluator_evaluate_x( m_e, x );
}
void *
cv1d_a_real_d (int border_effect,
void *res_data,
int *first_exact_ptr,
int *last_exact_ptr)
{
real *signal_data;
real *result_data;
int i;
real *filter_data = 0;
int filter_begin_index;
int filter_end_index;
_filter_ old_flt;
assert (flt.def == ANALYTICAL);
assert (flt.form != CV1D_UNDEFINED);
assert (sig_form != CV1D_UNDEFINED);
assert (sig_n >= flt.d_n);
assert ((border_effect == CV1D_PERIODIC)
|| (border_effect == CV1D_MIRROR)
|| (border_effect == CV1D_PADDING)
|| (border_effect == CV1D_0_PADDING));
assert (res_data != 0);
assert (first_exact_ptr != 0);
assert (last_exact_ptr != 0);
signal_data = (real *) sig_d_data;
result_data = (real *) res_data;
if (flt.scale == CV1D_NO_SCALE) {
filter_begin_index = (int) floor (flt.d_begin) ;
filter_end_index = (int) ceil (flt.d_end) ;
} else {
filter_begin_index = (int) floor (flt.d_begin*flt.scale) ;
filter_end_index = (int) ceil (flt.d_end*flt.scale) ;
}
filter_data = (real *) malloc (sizeof(real)*flt.d_n);
if (!filter_data) {
EX_RAISE(mem_alloc_error);
}
if (flt.scale == CV1D_NO_SCALE) {
for (i = filter_begin_index; i <= filter_end_index; i++) {
filter_data[i - filter_begin_index] =
evaluator_evaluate_x(flt.d_real_ptr,(double)(i));
}
} else {
for (i = filter_begin_index; i <= filter_end_index; i++) {
filter_data[i - filter_begin_index] =
evaluator_evaluate_x(flt.d_real_ptr,(double)(i)*flt.scale);
}
}
/*
* Compute the sum of the squared modulus of all the filter values.
*/
flt_squared_mod_sum_ = 0.0;
for (i = filter_begin_index; i <= filter_end_index; i++) {
flt_squared_mod_sum_ +=
filter_data[i-filter_begin_index]*filter_data[i-filter_begin_index];
}
/* old_flt.def = flt.def;
old_flt.d_begin = flt.d_begin;
old_flt.d_end = flt.d_end;
old_flt.d_data = flt.d_data;
flt.def = NUMERICAL;
flt.d_begin = (real) filter_begin_index;
flt.d_end = (real) filter_end_index;
flt.d_data = (void *) filter_data;*/
cv1d_flt_copy_ (&flt, &old_flt);
cv1d_flt_init_n (flt.form,
filter_end_index - filter_begin_index + 1,
-filter_begin_index,
0, 0,
filter_data,
0);
result_data = cv1d_n_real_d (border_effect, result_data,
first_exact_ptr, last_exact_ptr);
cv1d_flt_copy_ (&old_flt, &flt);
free (filter_data);
/* flt.def = old_flt.def;
flt.d_begin = old_flt.d_begin;
flt.d_end = old_flt.d_end;
flt.d_data = old_flt.d_data;*/
cv1d_set_f_l_exact_ (first_exact_ptr, last_exact_ptr);
return result_data;
mem_alloc_error:
free (filter_data);
return 0;
}
void *
cv1d_a_cplx_mp (int border_effect,
void *res_data,
int *first_exact_ptr,
int *last_exact_ptr)
{
complex *signal_data;
complex *result_data;
complex *signal_part = 0;
complex *signal_part_ft = 0 ;
complex *filter_ft = 0;
int nb_of_parts, part_nb, part_n;
int size_of_exact_data;
int i;
int flt_f_begin_index;
int flt_f_end_index;
int flt_d_end_index;
real f_step;
assert (flt.def == ANALYTICAL);
assert (flt.form != CV1D_UNDEFINED);
assert (sig_form != CV1D_UNDEFINED);
assert (sig_n >= flt.d_n);
assert ((border_effect == CV1D_PERIODIC)
|| (border_effect == CV1D_MIRROR)
|| (border_effect == CV1D_PADDING)
|| (border_effect == CV1D_0_PADDING));
assert (res_data != 0);
assert (first_exact_ptr != 0);
assert (last_exact_ptr != 0);
signal_data = (complex *) sig_d_data;
result_data = (complex *) res_data;
part_n = cv1d_next_good_fft_size (2*flt.d_n);
size_of_exact_data = part_n - flt.d_n + 1;
nb_of_parts = ceil (((double) sig_n)/size_of_exact_data);
assert (nb_of_parts >= 1);
f_step = 2*M_PI/(part_n);
if (flt.scale == CV1D_NO_SCALE) {
flt_f_begin_index = (int) floor (flt.f_begin/f_step) ;
flt_f_end_index = (int) ceil (flt.f_end/f_step) ;
flt_d_end_index = (int) ceil (flt.d_end) ;
} else {
flt_f_begin_index = (int) floor (flt.f_begin/flt.scale/f_step);
flt_f_end_index = (int) ceil (flt.f_end/flt.scale/f_step);
flt_d_end_index = (int) ceil (flt.d_end*flt.scale);
}
signal_part = (complex *) malloc (sizeof (complex)*part_n);
if (!signal_part) {
EX_RAISE(mem_alloc_error);
}
signal_part_ft = (complex *) malloc (sizeof (complex)*part_n);
if (!signal_part_ft) {
EX_RAISE(mem_alloc_error);
}
filter_ft = (complex *) malloc (sizeof (complex)*part_n);
if (!filter_ft) {
EX_RAISE(mem_alloc_error);
}
/* Fill filter fourier form array. */
if (flt.scale == CV1D_NO_SCALE) {
if (flt.f_imag_ptr) {
for (i = 0; i <= flt_f_end_index; i++) {
filter_ft[i].real =
evaluator_evaluate_x(flt.f_real_ptr,(double)(i*f_step));
filter_ft[i].imag =
evaluator_evaluate_x(flt.f_imag_ptr,(double)(i*f_step));
}
for (; i < part_n+flt_f_begin_index; i++) {
filter_ft[i].real = 0.0;
filter_ft[i].imag = 0.0;
}
for (; i < part_n; i++) {
filter_ft[i].real =
evaluator_evaluate_x(flt.f_real_ptr,(double)((i-flt_f_end_index)*f_step));
filter_ft[i].imag =
evaluator_evaluate_x(flt.f_imag_ptr,(double)((i-flt_f_end_index)*f_step));
}
} else { /* No function pointer for the imaginary part. */
for (i = 0; i <= flt_f_end_index; i++) {
filter_ft[i].real =
evaluator_evaluate_x(flt.f_real_ptr,(double)(i*f_step));
filter_ft[i].imag = 0.0;
}
for (; i < part_n+flt_f_begin_index; i++) {
filter_ft[i].real = 0.0;
filter_ft[i].imag = 0.0;
}
for (; i < part_n; i++) {
filter_ft[i].real =
evaluator_evaluate_x(flt.f_real_ptr,(double)((i-flt_f_end_index)*f_step));
filter_ft[i].imag = 0.0;
}
}
} else { /* flt.scale != CV1D_NO_SCALE */
if (flt.f_imag_ptr) {
for (i = 0; i <= flt_f_end_index; i++) {
filter_ft[i].real =
evaluator_evaluate_x(flt.f_real_ptr,(double)(i*f_step)*flt.scale);
filter_ft[i].imag =
evaluator_evaluate_x(flt.f_imag_ptr,(double)(i*f_step)*flt.scale);
}
for (; i < part_n+flt_f_begin_index; i++) {
filter_ft[i].real = 0.0;
filter_ft[i].imag = 0.0;
}
for (; i < part_n; i++) {
filter_ft[i].real =
evaluator_evaluate_x(flt.f_real_ptr,(double)((i-flt_f_end_index)*f_step)*flt.scale);
filter_ft[i].imag =
evaluator_evaluate_x(flt.f_imag_ptr,(double)((i-flt_f_end_index)*f_step)*flt.scale);
}
} else { /* No function pointer for the imaginary part. */
for (i = 0; i <= flt_f_end_index; i++) {
filter_ft[i].real =
evaluator_evaluate_x(flt.f_real_ptr,(double)(i*f_step)*flt.scale);
filter_ft[i].imag = 0.0;
}
for (; i < part_n+flt_f_begin_index; i++) {
filter_ft[i].real = 0.0;
filter_ft[i].imag = 0.0;
}
for (; i < part_n; i++) {
filter_ft[i].real =
evaluator_evaluate_x(flt.f_real_ptr,(double)((i-flt_f_end_index)*f_step)*flt.scale);
filter_ft[i].imag = 0.0;
}
}
}
/*
* Compute the sum of the squared modulus of all the filter values.
*/
flt_squared_mod_sum_ = 0.0;
for (i = 0; i < part_n; i++) {
flt_squared_mod_sum_ +=
filter_ft[i].real*filter_ft[i].real
+ filter_ft[i].imag*filter_ft[i].imag;
}
flt_squared_mod_sum_ = flt_squared_mod_sum_/part_n;
for (part_nb = 0; part_nb < nb_of_parts; part_nb++) {
int part_begin_in_signal;
part_begin_in_signal = part_nb*size_of_exact_data - flt_d_end_index;
cv1d_get_part_c_ (signal_part, part_n,
signal_data, sig_n,
part_begin_in_signal,
border_effect);
cv1d_fft_c (signal_part, signal_part_ft, part_n);
cv1d_cplx_mult_ (signal_part_ft, filter_ft,
0, part_n - 1);
cv1d_fft_c_i (signal_part_ft, signal_part, part_n);
if (part_nb < (nb_of_parts - 1)) {
memcpy (result_data + part_nb*size_of_exact_data,
signal_part + flt_d_end_index,
size_of_exact_data*sizeof (complex));
} else {
memcpy (result_data + part_nb*size_of_exact_data,
signal_part + flt_d_end_index,
(sig_n - part_nb*(size_of_exact_data))*sizeof (complex));
}
}
free (signal_part);
free (signal_part_ft);
free (filter_ft);
cv1d_set_f_l_exact_ (first_exact_ptr, last_exact_ptr);
return res_data;
mem_alloc_error:
free (signal_part);
free (signal_part_ft);
free (filter_ft);
return 0;
}
void *
cv1d_a_real_ft (int border_effect,
void *res_data,
int *first_exact_ptr,
int *last_exact_ptr)
{
real *signal_data;
real *result_data;
real *new_signal = 0;
complex *new_signal_ft = 0;
int new_size;
int flt_f_begin_index;
int flt_f_end_index;
int flt_d_begin_index;
int flt_d_end_index;
real f_step;
real flt_f_real_0;
real flt_f_imag_0;
assert (flt.def == ANALYTICAL);
assert (flt.form != CV1D_UNDEFINED);
assert (sig_form != CV1D_UNDEFINED);
assert (sig_n >= flt.d_n);
assert ((border_effect == CV1D_PERIODIC)
|| (border_effect == CV1D_MIRROR)
|| (border_effect == CV1D_PADDING)
|| (border_effect == CV1D_0_PADDING));
assert (res_data != 0);
assert (first_exact_ptr != 0);
assert (last_exact_ptr != 0);
assert (cv1d_is_good_fft_size (sig_n));
signal_data = (real *) sig_d_data;
result_data = (real *) res_data;
switch (border_effect) {
case CV1D_0_PADDING:
new_size = sig_n*2;
break;
case CV1D_PADDING:
new_size = sig_n*2;
break;
case CV1D_MIRROR:
new_size = sig_n*2;
break;
case CV1D_PERIODIC:
new_size = sig_n;
break;
}
f_step = 2*M_PI/(new_size);
if (flt.scale == CV1D_NO_SCALE) {
flt_f_begin_index = (int) floor (flt.f_begin) ;
flt_f_end_index = (int) ceil (flt.f_end) ;
flt_d_begin_index = (int) floor (flt.d_begin) ;
flt_d_end_index = (int) ceil (flt.d_end) ;
} else {
flt_f_begin_index = (int) floor (flt.f_begin/flt.scale/f_step);
flt_f_end_index = (int) ceil (flt.f_end/flt.scale/f_step);
flt_d_begin_index = (int) floor (flt.d_begin*flt.scale);
flt_d_end_index = (int) ceil (flt.d_end*flt.scale);
}
assert (new_size >= (2*max(flt_f_end_index, - flt_f_begin_index) + 1));
switch (border_effect) {
case CV1D_0_PADDING:
new_signal = cv1d_0_padding_transform_ (signal_data,
sig_n,
flt_d_end_index);
break;
case CV1D_PADDING:
new_signal = cv1d_padding_transform_ (signal_data,
sig_n,
flt_d_end_index);
break;
case CV1D_MIRROR:
new_signal = cv1d_mirror_transform_ (signal_data,
sig_n,
flt_d_end_index);
break;
case CV1D_PERIODIC:
new_signal = signal_data;
break;
}
if (!new_signal) {
EX_RAISE(mem_alloc_error);
}
new_signal_ft = (complex *) malloc (sizeof (complex)*new_size/2);
if (!new_signal_ft) {
EX_RAISE(mem_alloc_error);
}
cv1d_fft_r (new_signal, new_signal_ft, new_size);
flt_squared_mod_sum_ = 0.0;
if (flt.scale == CV1D_NO_SCALE) {
flt_f_real_0 = evaluator_evaluate_x(flt.f_real_ptr,0.0);
flt_f_imag_0 = evaluator_evaluate_x(flt.f_real_ptr,(double)new_size/2*f_step);
new_signal_ft[0].real *= flt_f_real_0;
new_signal_ft[0].imag *= flt_f_imag_0;
cv1d_cplx_mult_num_ana_ (new_signal_ft, flt.f_real_ptr, flt.f_imag_ptr,
1, new_size/2 - 1, f_step, 0.0);
flt_squared_mod_sum_ *= 2;
flt_squared_mod_sum_ +=
flt_f_real_0*flt_f_real_0 + flt_f_imag_0*flt_f_imag_0;
} else {
flt_f_real_0 = flt.scale*evaluator_evaluate_x(flt.f_real_ptr,0.0*flt.scale);
flt_f_imag_0 = flt.scale
* evaluator_evaluate_x(flt.f_real_ptr, (double)new_size/2*f_step*flt.scale);
new_signal_ft[0].real *= flt_f_real_0;
new_signal_ft[0].imag *= flt_f_imag_0;
cv1d_mult_with_scaled_ft_fct_ (new_signal_ft, flt.f_real_ptr, flt.f_imag_ptr,
flt.scale, 1, new_size/2 - 1, f_step, 0.0);
flt_squared_mod_sum_ *= 2;
flt_squared_mod_sum_ +=
flt_f_real_0*flt_f_real_0 + flt_f_imag_0*flt_f_imag_0;
}
flt_squared_mod_sum_ = flt_squared_mod_sum_/new_size;
if (border_effect == CV1D_PERIODIC) {
cv1d_fft_r_i (new_signal_ft, result_data, new_size);
} else {
cv1d_fft_r_i (new_signal_ft, new_signal, new_size);
memcpy (result_data, new_signal, sig_n*sizeof (real));
free (new_signal);
}
free (new_signal_ft);
cv1d_set_f_l_exact_ (first_exact_ptr, last_exact_ptr);
return res_data;
mem_alloc_error:
free (new_signal_ft);
free (new_signal);
return 0;
}
