Max 5 API Reference

jit.la.trace.c

/* 
    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com    
*/

#include "jit.common.h"
#include "jit.fixmath.h"

typedef struct _jit_la_trace 
{
    t_object    ob;
    long        resultcount;
    double      result[2];
} t_jit_la_trace;

void *_jit_la_trace_class;

t_jit_la_trace *jit_la_trace_new(void);
void jit_la_trace_free(t_jit_la_trace *x);
t_jit_err jit_la_trace_matrix_calc(t_jit_la_trace *x, void *inputs, void *outputs);

void jit_la_trace_calculate_2d_real(t_jit_la_trace *x, double *val, t_jit_matrix_info *in_minfo, char *bip);
void jit_la_trace_calculate_2d_complex(t_jit_la_trace *x, double *val, t_jit_matrix_info *in_minfo, char *bip);

t_jit_err jit_la_trace_init(void) 
{
    long attrflags=0;
    t_jit_object *attr,*mop;
        
    _jit_la_trace_class = jit_class_new("jit_la_trace",(method)jit_la_trace_new,(method)jit_la_trace_free,
        sizeof(t_jit_la_trace),0L);

    //add mop
    mop = jit_object_new(_jit_sym_jit_mop,1,0);
    jit_class_addadornment(_jit_la_trace_class,mop);
    //add methods
    jit_class_addmethod(_jit_la_trace_class, (method)jit_la_trace_matrix_calc,      "matrix_calc",      A_CANT, 0L);
    //add attributes    
    attrflags = JIT_ATTR_SET_OPAQUE_USER | JIT_ATTR_GET_OPAQUE_USER;
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"result",_jit_sym_float64,2,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_la_trace,resultcount),calcoffset(t_jit_la_trace,result));
    jit_class_addattr(_jit_la_trace_class,attr);
    jit_class_register(_jit_la_trace_class);

    return JIT_ERR_NONE;
}

t_jit_err jit_la_trace_matrix_calc(t_jit_la_trace *x, void *inputs, void *outputs)
{
    t_jit_err err=JIT_ERR_NONE;
    long in_savelock;
    t_jit_matrix_info in_minfo;
    char *in_bp;
    double *trace=x->result;
    void *in_matrix;
    
    in_matrix   = jit_object_method(inputs,_jit_sym_getindex,0);

    if (x&&in_matrix&&trace) {
        trace[0] = 0;
        trace[1] = 0;
        in_savelock = (long) jit_object_method(in_matrix,_jit_sym_lock,1);
        jit_object_method(in_matrix,_jit_sym_getinfo,&in_minfo);
        jit_object_method(in_matrix,_jit_sym_getdata,&in_bp);
        if (!in_bp) { err=JIT_ERR_INVALID_INPUT; goto out; }
        //compatible types?
        if ((in_minfo.type!=_jit_sym_float32)&&(in_minfo.type!=_jit_sym_float64))
            { err=JIT_ERR_MISMATCH_TYPE; goto out; }        
        //compatible planecounts?
        //planecount 1=real. planecount 2=complex
        if (((in_minfo.planecount!=1)&&(in_minfo.planecount!=2))) 
            { err=JIT_ERR_MISMATCH_PLANE; goto out; }
        x->resultcount = in_minfo.planecount;
        //square?
        if (in_minfo.dim[0]!=in_minfo.dim[1]) 
            { err=JIT_ERR_MISMATCH_DIM; goto out; }
        //only 2d
        if (in_minfo.planecount==1)
            jit_la_trace_calculate_2d_real(x, trace, &in_minfo, in_bp);
        else
            jit_la_trace_calculate_2d_complex(x, trace, &in_minfo, in_bp);
    } else {
        return JIT_ERR_INVALID_PTR;
    }
    
out:
    jit_object_method(in_matrix,_jit_sym_lock,in_savelock);
    return err;
}

//diagonal sum
void jit_la_trace_calculate_2d_real(t_jit_la_trace *x, double *val, t_jit_matrix_info *in_minfo, char *bip)
{
    long i,rows;
    char *p;
    
    *val=0.;

    if (in_minfo->type==_jit_sym_float32) {
        rows = in_minfo->dim[1];
        for (i=0;i<rows;i++) {
            p = bip  + i*in_minfo->dimstride[1] + i*in_minfo->dimstride[0];
            *val += (double)(*((float *)(p)));
        }
    } else if (in_minfo->type==_jit_sym_float64) {
        rows = in_minfo->dim[1];
        for (i=0;i<rows;i++) {
            p = bip  + i*in_minfo->dimstride[1] + i*in_minfo->dimstride[0];
            *val += (*((double *)(p)));
        }
    } 
}

#define COMPLEX_IS_ZERO(a,b) (((a)==0)&&((b)==0))
#define COMPLEX_IS_ZERO_THRESH(a,b,thresh) ((ABS(a)<(thresh))&&(ABS(b)<(thresh)))
#define COMPLEX_RECIP_REAL(a,b) ((a)/(((a)*(a))+((b)*(b))))
#define COMPLEX_RECIP_IMAG(a,b) (-(b)/(((a)*(a))+((b)*(b))))
#define COMPLEX_MULT_REAL(a,b,c,d) (((a)*(c))-((b)*(d)))
#define COMPLEX_MULT_IMAG(a,b,c,d) (((a)*(d))+((b)*(c)))

void jit_la_trace_calculate_2d_complex(t_jit_la_trace *x, double *val, t_jit_matrix_info *in_minfo, char *bip)
{
    long i,rows;
    char *p;
    double tmp[2];
    
    val[0]=0.;
    val[1]=0.;

    if (in_minfo->type==_jit_sym_float32) {
        rows = in_minfo->dim[1];
        for (i=0;i<rows;i++) {
            p = bip  + i*in_minfo->dimstride[1] + i*in_minfo->dimstride[0];
            val[0] += (double)(((float *)p)[0]);
            val[1] += (double)(((float *)p)[1]);
        }
    } else if (in_minfo->type==_jit_sym_float64) {
        rows = in_minfo->dim[1];
        for (i=0;i<rows;i++) {
            p = bip  + i*in_minfo->dimstride[1] + i*in_minfo->dimstride[0];
            val[0] += ((double *)p)[0];
            val[1] += ((double *)p)[1];
        }
    } 
}


t_jit_la_trace *jit_la_trace_new(void)
{
    t_jit_la_trace *x;
        
    if (x=(t_jit_la_trace *)jit_object_alloc(_jit_la_trace_class)) {
    } else {
        x = NULL;
    }   
    return x;
}

void jit_la_trace_free(t_jit_la_trace *x)
{
}

Copyright © 2008, Cycling '74