Max 5 API Reference

jit.distance.minkovsky.c

/*
 *  jit.distance.minkovsky.c
 *
 *  Copyright 2001-2005 - Cycling '74
 *  Derek Gerstmann - derek@cycling74.com
 *
 *  Functor for calculating Minkovsky distance
 *
 *  Minkovsky distance uses an exponent control to
 *  modulate the result between Manhattan [exp = 1] 
 *  and Euclidean [exp = 2] distances.
 */

#include "jit.common.h"
#include "jit.functor.h"

// --------------------------------------------------------------------------

typedef struct _jit_functor_distance_minkovsky
{
    t_jit_object    ob;
    double          exponent;       // exponent control
    double          invexponent;    // inverse of exponent

} t_jit_functor_distance_minkovsky;

// --------------------------------------------------------------------------

t_jit_object *jit_functor_distance_minkovsky_new(void);
t_jit_err jit_functor_distance_minkovsky_free(t_jit_functor_distance_minkovsky *x);
t_jit_err jit_functor_distance_minkovsky_exponent(t_jit_functor_distance_minkovsky *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_distance_minkovsky_recalc(t_jit_functor_distance_minkovsky *x);

long jit_functor_distance_minkovsky_eval_fixed(t_jit_functor_distance_minkovsky *x, long dimcount, long *vals);
float jit_functor_distance_minkovsky_eval_float32(t_jit_functor_distance_minkovsky *x, long dimcount, float *vals);
double jit_functor_distance_minkovsky_eval_float64(t_jit_functor_distance_minkovsky *x, long dimcount, double *vals);

void jit_functor_distance_minkovsky_fixlut_init(void);

t_class *_jit_functor_distance_minkovsky_class;

// --------------------------------------------------------------------------

t_jit_err jit_functor_distance_minkovsky_init(void)
{
    t_jit_object *attr;

    // create class
    _jit_functor_distance_minkovsky_class = jit_class_new("jit_functor_distance_minkovsky",(method)jit_functor_distance_minkovsky_new,(method)jit_functor_distance_minkovsky_free,
        sizeof(t_jit_functor_distance_minkovsky),0L);

    // add attribute methods
    attr = jit_object_new(_jit_sym_jit_attr_offset,"exponent",_jit_sym_float64,0,
        (method)0L,(method)jit_functor_distance_minkovsky_exponent,
        calcoffset(t_jit_functor_distance_minkovsky,exponent));
    jit_class_addattr(_jit_functor_distance_minkovsky_class,attr);

    // add evaluation methods
    jit_class_addmethod(_jit_functor_distance_minkovsky_class, (method)jit_functor_distance_minkovsky_eval_fixed,       "evalfixed",    A_CANT, 0L);
    jit_class_addmethod(_jit_functor_distance_minkovsky_class, (method)jit_functor_distance_minkovsky_eval_float32,     "evalfloat32",  A_CANT, 0L);
    jit_class_addmethod(_jit_functor_distance_minkovsky_class, (method)jit_functor_distance_minkovsky_eval_float64,     "evalfloat64",  A_CANT, 0L);

    // important to add last for subclassing methods
    jit_functor_setup_class(_jit_functor_distance_minkovsky_class,"distance","minkovsky");
    jit_class_register(_jit_functor_distance_minkovsky_class);

    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_distance_minkovsky_new(void)
{
    long i;
    t_jit_functor_distance_minkovsky *x;

    if (x = (t_jit_functor_distance_minkovsky *)jit_object_alloc(_jit_functor_distance_minkovsky_class)) {

        // initialization
        x->exponent = 0.5;
        jit_functor_distance_minkovsky_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_distance_minkovsky_free(t_jit_functor_distance_minkovsky *x)
{
    return JIT_ERR_NONE;
}

t_jit_err jit_functor_distance_minkovsky_exponent(t_jit_functor_distance_minkovsky *x, void *attr, long argc, t_atom *argv)
{
    double v;

    if (x) {
        v = jit_atom_getfloat(argv);
        if(x->exponent != v) {
            x->exponent = v;
            jit_functor_distance_minkovsky_recalc(x);
        }
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_distance_minkovsky_recalc(t_jit_functor_distance_minkovsky *x)
{
    // calculate intermediary values for efficiency
    x->invexponent = 1.0 / x->exponent;
    return JIT_ERR_NONE;
}

// --------------------------------------------------------------------------

long jit_functor_distance_minkovsky_eval_fixed(t_jit_functor_distance_minkovsky *x, long dimcount, long *vals)
{
    return jit_functor_eval_fixed_with_float64((t_jit_object *)x,dimcount,vals,
            (t_jit_functor_float64_sig)jit_functor_distance_minkovsky_eval_float64);
}

float jit_functor_distance_minkovsky_eval_float32(t_jit_functor_distance_minkovsky *x, long dimcount, float *vals)
{
    return jit_functor_eval_float32_with_float64((t_jit_object *)x,dimcount,vals,
            (t_jit_functor_float64_sig)jit_functor_distance_minkovsky_eval_float64);
}

double jit_functor_distance_minkovsky_eval_float64(t_jit_functor_distance_minkovsky *x, long dimcount, double *vals)
{
    long i;
    double rval = 0;

    // special cases for improved performance
    if(x->exponent == 0.5)
    {
        for (i=0;i<dimcount;i++) {
            rval += jit_math_sqrt(JIT_MATH_F64_ABS(vals[i]));
        }
        return JIT_MATH_SQR(rval);
    }
    else if(x->exponent == 4.0)
    {
        for (i=0;i<dimcount;i++) {
            rval += JIT_MATH_SQR(vals[i]);
        }
        return jit_math_sqrt(jit_math_sqrt(rval));
    }
    else
    {
        for (i=0;i<dimcount;i++) {
            rval += jit_math_pow(JIT_MATH_F64_ABS(vals[i]), x->exponent);
        }
        return jit_math_pow(rval, x->invexponent);
    }

    return rval;
}

// --------------------------------------------------------------------------

Copyright © 2008, Cycling '74