Max 5 API Reference

jit.la.determinant.c

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

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

#define JIT_LA_DETERMINANT_DEF_THRESH 0.000000001

typedef struct _jit_la_determinant 
{
    t_object    ob;
    double      thresh;
    long        resultcount;
    double      result[2];
} t_jit_la_determinant;

void *_jit_la_determinant_class;

t_jit_la_determinant *jit_la_determinant_new(void);
void jit_la_determinant_free(t_jit_la_determinant *x);
t_jit_err jit_la_determinant_matrix_calc(t_jit_la_determinant *x, void *inputs, void *outputs);

t_jit_err jit_la_determinant_init(void) 
{
    long attrflags=0;
    t_jit_object *attr,*mop;
        
    _jit_la_determinant_class = jit_class_new("jit_la_determinant",(method)jit_la_determinant_new,(method)jit_la_determinant_free,
        sizeof(t_jit_la_determinant),0L);
        
    //add mop
    mop = jit_object_new(_jit_sym_jit_mop,1,0);
    jit_class_addadornment(_jit_la_determinant_class,mop);
    //add methods
    jit_class_addmethod(_jit_la_determinant_class, (method)jit_la_determinant_matrix_calc,      "matrix_calc",      A_CANT, 0L);
    //add attributes    
    attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
    attr = jit_object_new(_jit_sym_jit_attr_offset,"thresh",_jit_sym_float64,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_la_determinant,thresh));
    jit_class_addattr(_jit_la_determinant_class,attr);
    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_determinant,resultcount),calcoffset(t_jit_la_determinant,result));
    jit_class_addattr(_jit_la_determinant_class,attr);
    
    jit_class_register(_jit_la_determinant_class);

    return JIT_ERR_NONE;
}

t_jit_err jit_la_determinant_matrix_calc(t_jit_la_determinant *x, void *inputs, void *outputs)
{
    t_jit_err err=JIT_ERR_NONE;
    long tmp_savelock;
    t_jit_matrix_info in_minfo,tmp_minfo;
    char *tmp_bp;
    long swapcount=0;
    void *tmp_matrix=NULL;
    void *uppertri=NULL;
    void *diag=NULL;
    double *det=x->result;
    t_atom *av=NULL;
    void *in_matrix;
    
    in_matrix   = jit_object_method(inputs,_jit_sym_getindex,0);

    if (x&&in_matrix) {
        det[0] = 0;
        det[1] = 0; 
        jit_object_method(in_matrix,_jit_sym_getinfo,&in_minfo);
        //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;}
        //calculate upper triangle
        if (!(tmp_matrix=jit_object_new(_jit_sym_jit_matrix,&in_minfo)))
            { err=JIT_ERR_OUT_OF_MEM; goto out;}
        if (!(uppertri=jit_object_new(gensym("jit_la_uppertri"))))
            { err=JIT_ERR_OUT_OF_MEM; goto out;}
        jit_attr_setfloat(uppertri,gensym("thresh"),x->thresh);
        
        if (err=(long)jit_object_method(uppertri,_jit_sym_matrix_calc,inputs,tmp_matrix)) //TRICKY: single matrix acting as single element list
            goto out;
    
        swapcount = jit_attr_getlong(uppertri,gensym("swapcount"));
        //calculate diagonal product            
        if (!(diag=jit_object_new(gensym("jit_la_diagproduct"))))
            { err=JIT_ERR_OUT_OF_MEM; goto out;}
        
        if (err=(long)jit_object_method(diag,_jit_sym_matrix_calc,tmp_matrix,NULL)) //TRICKY: single matrix acting as single element list
            goto out;
    
        jit_object_method(diag,gensym("getresult"),&x->resultcount,&av);
        det[0] = jit_atom_getfloat(av); 
        det[1] = jit_atom_getfloat(av+1);   
        
        if (av) jit_freebytes(av,x->resultcount*sizeof(t_atom));
                    
        //if odd number of row swaps, then negate                       
        if (swapcount%2) { det[0] *= -1; det[1] *= -1; } 
        
    } else {
        return JIT_ERR_INVALID_PTR;
    }
    
out:
    if (tmp_matrix) {
        jit_object_free(tmp_matrix);
    }
    if (uppertri) jit_object_free(uppertri);
    if (diag) jit_object_free(diag);
    return err;
}

t_jit_la_determinant *jit_la_determinant_new(void)
{
    t_jit_la_determinant *x;
        
    if (x=(t_jit_la_determinant *)jit_object_alloc(_jit_la_determinant_class)) {
        x->thresh = JIT_LA_DETERMINANT_DEF_THRESH; 
        x->resultcount=1;
        x->result[0]=0;
        x->result[1]=0;
    } else {
        x = NULL;
    }   
    return x;
}

void jit_la_determinant_free(t_jit_la_determinant *x)
{
}

Copyright © 2008, Cycling '74