void cavoc_rule (t_cavoc *x, t_symbol *msg, short argc, t_atom *argv) { int i; short *rule = x->rule; if( argc != 8 ){ error("the rule must be size 8"); return; } for( i = 0; i < 8; i++ ){ rule[i] = (short) atom_getfloatarg(i, argc, argv); // post("%d",rule[i]); } }
static void search(lotkavolterra_struct *lotkavolterra, t_symbol *s, int argc, t_atom *argv) { int not_found, not_expired = lotkavolterra -> lyap_limit; int jump, i, iterations; t_atom vars[M_var_count]; double temp_a = lotkavolterra -> a; double temp_b = lotkavolterra -> b; double temp_c = lotkavolterra -> c; double temp_e = lotkavolterra -> e; if (argc > 0) { for (i = 0; i < M_var_count; i++) { SETFLOAT(&vars[i], atom_getfloatarg(i, argc, argv)); } } else { for (i = 0; i < M_var_count; i++) { SETFLOAT(&vars[i], lotkavolterra -> vars_init[i]); } } do { jump = 500; not_found = 0; iterations = 10000; bad_params: lotkavolterra -> a = (drand48() * (lotkavolterra -> a_hi - lotkavolterra -> a_lo)) + lotkavolterra -> a_lo; lotkavolterra -> b = (drand48() * (lotkavolterra -> b_hi - lotkavolterra -> b_lo)) + lotkavolterra -> b_lo; lotkavolterra -> c = (drand48() * (lotkavolterra -> c_hi - lotkavolterra -> c_lo)) + lotkavolterra -> c_lo; lotkavolterra -> e = (drand48() * (lotkavolterra -> e_hi - lotkavolterra -> e_lo)) + lotkavolterra -> e_lo; // put any preliminary checks specific to this fractal to eliminate bad_params reset(lotkavolterra, NULL, argc, vars); do { calc(lotkavolterra, lotkavolterra -> vars); } while(jump--); lotkavolterra -> lyap_exp = lyapunov((void *) lotkavolterra, (t_gotfn) calc, M_var_count, (double *) lotkavolterra -> vars); if (isnan(lotkavolterra -> lyap_exp)) { not_found = 1; } if (lotkavolterra -> lyap_exp < lotkavolterra -> lyap_lo || lotkavolterra -> lyap_exp > lotkavolterra -> lyap_hi) { not_found = 1; } not_expired--; } while(not_found && not_expired); reset(lotkavolterra, NULL, argc, vars); if (!not_expired) { post("Could not find a fractal after %d attempts.", (int) lotkavolterra -> lyap_limit); post("Try using wider constraints."); lotkavolterra -> a = temp_a; lotkavolterra -> b = temp_b; lotkavolterra -> c = temp_c; lotkavolterra -> e = temp_e; outlet_anything(lotkavolterra -> search_outlet, gensym("invalid"), 0, NULL); } else { lotkavolterra -> failure_ratio = (lotkavolterra -> lyap_limit - not_expired) / lotkavolterra -> lyap_limit; make_results(lotkavolterra); outlet_anything(lotkavolterra -> search_outlet, gensym("search"), M_search_count, lotkavolterra -> search_out); } }
// freq message - sets the radio frequency in Hz (Max and Pd) // // format: freq <frequency in Hz> [now] // // the optional 'now' argument, if equal to 1, sets frequency right now, if radio is running. // if argument is not passed or equals zero (default) freq setting will be deferred until the radio // gets reset. // void rtlsdr_freq (t_rtlsdr *x, t_symbol *mesg, short argc, t_atom *argv ) { // char msg[100]; int now = 0; // default is to defer frequency setting until reset if(argc < 1) { post("freq: <frequency in Hz> [now]", 0); return; } if(argc > 0) { x->x_freq_hz = (long) atom_getfloatarg(0, argc,argv); new_freq = (uint32_t) x->x_freq_hz; // sprintf(msg, "freq: setting freq to: %f", x->x_freq_hz); // post(msg, 0); } if(argc > 1 ) { now = (int) atom_getfloatarg(1, argc,argv); } if(now == 0) { // post("freq: deferred"); return; // don't set frequency now } // post("freq: immediate"); // note, if radio is off, nothing happens until its turned on if(x->x_radio_is_running == 1) { need_to_set_freq = 1; } }
void pix_video :: dimenMessCallback(void *data, t_symbol *s, int ac, t_atom *av) { GetMyClass(data)->dimenMess(static_cast<int>(atom_getfloatarg(0, ac, av)), static_cast<int>(atom_getfloatarg(1, ac, av)), static_cast<int>(atom_getfloatarg(2, ac, av)), static_cast<int>(atom_getfloatarg(3, ac, av)), static_cast<int>(atom_getfloatarg(4, ac, av)), static_cast<int>(atom_getfloatarg(5, ac, av)) ); }
static void *lowshelf_new(t_symbol *s, int argc, t_atom *argv) { t_lowshelf *x = (t_lowshelf *)pd_new(lowshelf_class); float freq = 0; float slope = 0; int db = 0; ///////////////////////////////////////////////////////////////////////////////////// int argnum = 0; while(argc > 0) { if(argv -> a_type == A_FLOAT) { //if current argument is a float t_float argval = atom_getfloatarg(0, argc, argv); switch(argnum) { case 0: freq = argval; break; case 1: slope = argval; break; case 2: db = argval; break; default: break; }; argnum++; argc--; argv++; } else if (argv -> a_type == A_SYMBOL) { goto errstate; } }; ///////////////////////////////////////////////////////////////////////////////////// x->x_inlet_freq = inlet_new((t_object *)x, (t_pd *)x, &s_signal, &s_signal); pd_float((t_pd *)x->x_inlet_freq, freq); x->x_inlet_q = inlet_new((t_object *)x, (t_pd *)x, &s_signal, &s_signal); pd_float((t_pd *)x->x_inlet_q, slope); x->x_inlet_amp = inlet_new((t_object *)x, (t_pd *)x, &s_signal, &s_signal); pd_float((t_pd *)x->x_inlet_amp, db); x->x_out = outlet_new((t_object *)x, &s_signal); return (x); errstate: pd_error(x, "lowshelf~: improper args"); return NULL; }
static void *select_new(t_symbol *s, int argc, t_atom *argv) { #ifdef ROCKBOX (void) s; #endif t_atom a; if (argc == 0) { argc = 1; SETFLOAT(&a, 0); argv = &a; } if (argc == 1) { t_sel1 *x = (t_sel1 *)pd_new(sel1_class); x->x_atom = *argv; x->x_outlet1 = outlet_new(&x->x_obj, &s_bang); if (argv->a_type == A_FLOAT) { floatinlet_new(&x->x_obj, &x->x_atom.a_w.w_float); x->x_outlet2 = outlet_new(&x->x_obj, &s_float); } else { symbolinlet_new(&x->x_obj, &x->x_atom.a_w.w_symbol); x->x_outlet2 = outlet_new(&x->x_obj, &s_symbol); } return (x); } else { int n; t_selectelement *e; t_sel2 *x = (t_sel2 *)pd_new(sel2_class); x->x_nelement = argc; x->x_vec = (t_selectelement *)getbytes(argc * sizeof(*x->x_vec)); x->x_type = argv[0].a_type; for (n = 0, e = x->x_vec; n < argc; n++, e++) { e->e_outlet = outlet_new(&x->x_obj, &s_bang); if ((x->x_type = argv->a_type) == A_FLOAT) e->e_w.w_float = atom_getfloatarg(n, argc, argv); else e->e_w.w_symbol = atom_getsymbolarg(n, argc, argv); } x->x_rejectout = outlet_new(&x->x_obj, &s_float); return (x); } }
void *volctl_new(t_symbol *s, int argc, t_atom *argv) { if (argc > 3) post("volctl~: extra arguments ignored"); t_volctl *x = (t_volctl *)pd_new(volctl_class); inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("f1")); inlet_settip(x->x_obj.ob_inlet,gensym("factor")); x->x_value = atom_getfloatarg(0, argc, argv); t_inlet * time = floatinlet_new(&x->x_obj, &x->x_h); inlet_settip(time,gensym("interpolation_time")); x->x_h = atom_getfloatarg(1, argc, argv); x->x_samples_per_ms = 44100.f / 1000.f; // assume default samplerate x->x_blocksize = 64; x->x_1overblocksize = 1.f/64.f; outlet_new(&x->x_obj, &s_signal); x->x_f = 0; x->x_slopes = getalignedbytes(4*sizeof(t_float)); return (x); }
void adsr_list (t_adsr *x, t_atom *msg, short argc, t_atom *argv) { x->rsamps = x->tsamps - (x->asamps+x->dsamps+x->ssamps); if( x->rsamps < 0 ) x->rsamps = 0; x->a = (atom_getfloatarg(0,argc,argv)) * .001; x->d = (atom_getfloatarg(1,argc,argv)) * .001; x->s = (atom_getfloatarg(2,argc,argv)) * .001; x->r = (atom_getfloatarg(3,argc,argv)) * .001; x->asamps = x->a * x->srate; x->dsamps = x->d * x->srate; x->ssamps = x->s * x->srate; x->rsamps = x->r * x->srate; x->tsamps = x->asamps+x->dsamps+x->ssamps+x->rsamps; x->ebreak1 = x->asamps; x->ebreak2 = x->asamps+x->dsamps; x->ebreak3 = x->asamps+x->dsamps+x->ssamps; }
/* new values from dialog window */ void glob_audio_dialog(t_pd *dummy, t_symbol *s, int argc, t_atom *argv) { int i, nindev, noutdev; int newaudioindev[4], newaudioinchan[4], newaudiooutdev[4], newaudiooutchan[4]; /* the new values the dialog came back with: */ int newrate = atom_getfloatarg(16, argc, argv); int newadvance = atom_getfloatarg(17, argc, argv); int newcallback = atom_getfloatarg(18, argc, argv); int newblocksize = atom_getfloatarg(19, argc, argv); for (i = 0; i < 4; i++) { newaudioindev[i] = atom_getfloatarg(i, argc, argv); newaudioinchan[i] = atom_getfloatarg(i+4, argc, argv); newaudiooutdev[i] = atom_getfloatarg(i+8, argc, argv); newaudiooutchan[i] = atom_getfloatarg(i+12, argc, argv); } for (i = 0, nindev = 0; i < 4; i++) { if (newaudioinchan[i]) { newaudioindev[nindev] = newaudioindev[i]; newaudioinchan[nindev] = newaudioinchan[i]; /* post("in %d %d %d", nindev, newaudioindev[nindev] , newaudioinchan[nindev]); */ nindev++; } } for (i = 0, noutdev = 0; i < 4; i++) { if (newaudiooutchan[i]) { newaudiooutdev[noutdev] = newaudiooutdev[i]; newaudiooutchan[noutdev] = newaudiooutchan[i]; /* post("out %d %d %d", noutdev, newaudiooutdev[noutdev] , newaudioinchan[noutdev]); */ noutdev++; } } sys_set_audio_settings_reopen(nindev, newaudioindev, nindev, newaudioinchan, noutdev, newaudiooutdev, noutdev, newaudiooutchan, newrate, newadvance, newcallback, newblocksize); }
void chopper_set_loop(t_chopper *x, t_symbol *msg, short argc, t_atom *argv) { if( argc < 3 ){ error("format: start samples increment"); return; } x->loop_start = atom_getintarg(0,argc,argv); x->loop_samps = atom_getintarg(1,argc,argv); x->increment = atom_getfloatarg(2,argc,argv); x->data_recalled = 1; x->samps_to_go = x->loop_samps; x->fbindex = x->bindex = x->loop_start; // post("loop set to: st %d samps %d incr %f", x->loop_start, x->loop_samps,x->increment); }
static void *toany_new(t_symbol *sel, int argc, t_atom *argv){ t_symbol *dummy = sel; dummy = NULL; t_toany *x = (t_toany *)pd_new(toany_class); int bufsize = 256; x->x_binbuf = binbuf_new(); x->x_eos = -1; if(argc) x->x_eos = atom_getfloatarg(0, argc, argv); toany_char_code_clear(&x->x_char_code); toany_char_code_realloc(&x->x_char_code, bufsize); x->x_eos_in = floatinlet_new(&x->x_obj, &x->x_eos); x->x_outlet = outlet_new(&x->x_obj, &s_list); return (void *)x; }
static short get_device_number_from_arguments(int argc, t_atom *argv) { short device_number = -1; t_symbol *first_argument; if(argc == 1) { first_argument = atom_getsymbolarg(0,argc,argv); if(first_argument == &s_) { // single float arg means device # device_number = (short) atom_getfloatarg(0,argc,argv); } } return device_number; }
static void stdout_binary(t_stdout *x, int argc, t_atom *argv) { #define BUFSIZE 65535 char buf[BUFSIZE]; int i; if (argc>BUFSIZE) argc = BUFSIZE; for (i=0; i<argc; i++) ((unsigned char *)buf)[i] = atom_getfloatarg(i, argc, argv); buf[i>BUFSIZE?BUFSIZE:i] = 0; fwrite(buf, 1, argc, stdout); if (x->x_flush || !argc) fflush(stdout); }
void samm_ratiobeats(t_samm *x, t_symbol *msg, short argc, t_atom *argv) { int i,j; double num,denom; if(argc != x->metro_count * 2){ error("%s: arguments did not match metro count %d",x->metro_count); return; } for(i = 0, j= 0; i < argc; i += 2, j++){ num = (double)atom_getfloatarg(i,argc,argv); denom = (double)atom_getfloatarg(i+1,argc,argv); if(!denom){ error("%s: zero divisor given for beat stream %d",OBJECT_NAME,(i/2)+1); denom = 1.0; } x->metro_beatdurs[j] = 4.0 * (num / denom); // post("beat duration %f",4.0 * (num/denom)); x->metro_samps[j] = x->metro_beatdurs[j] * x->onebeat_samps; x->metro[j] = 1.0; // initialize for instantaneous beat } }
void *base3_new(t_symbol *s, int argc, t_atom *argv) { base3_struct *base3 = (base3_struct *) pd_new(base3_class); if (base3 != NULL) { outlet_new(&base3 -> x_obj, &s_float); base3 -> search_outlet = outlet_new(&base3 -> x_obj, &s_list); base3 -> vars_outlet = outlet_new(&base3 -> x_obj, &s_list); base3 -> params_outlet = outlet_new(&base3 -> x_obj, &s_list); if (argc == M_param_count + M_var_count) { base3 -> vars_init[M_x] = base3 -> vars[M_x] = (double) atom_getfloatarg(0, argc, argv); base3 -> a = (double) atom_getfloatarg(1, argc, argv); base3 -> b = (double) atom_getfloatarg(2, argc, argv); } else { if (argc != 0 && argc != M_param_count + M_var_count) { post("Incorrect number of arguments for base3 fractal. Expecting 3 arguments."); } base3 -> vars_init[M_x] = 0.1; base3 -> a = 1; base3 -> b = 1; } constrain(base3, NULL, 0, NULL); lyap(base3, -1000000.0, 1000000.0, M_failure_limit); } return (void *)base3; }
void *granulesf_grist(t_granulesf *x, t_symbol *msg, short argc, t_atom *argv) { if(argc < 10 ){ error("grist takes 10 arguments:"); post("events horizon min_incr max_incr minpan maxpan minamp maxamp mindur maxdur"); return 0; } x->events = atom_getintarg(0,argc,argv); x->horizon_ms = atom_getfloatarg(1,argc,argv); x->min_incr = atom_getfloatarg(2,argc,argv); x->max_incr = atom_getfloatarg(3,argc,argv); x->minpan = atom_getfloatarg(4,argc,argv); x->maxpan = atom_getfloatarg(5,argc,argv); x->minamp = atom_getfloatarg(6,argc,argv); x->maxamp = atom_getfloatarg(7,argc,argv); x->mindur_ms = atom_getfloatarg(8,argc,argv); x->maxdur_ms = atom_getfloatarg(9,argc,argv); x->mindur = .001 * x->sr * x->mindur_ms ; x->maxdur = .001 * x->sr * x->maxdur_ms; x->horizon = .001 * x->sr * x->horizon_ms; if(x->min_incr < 0){ x->min_incr *= -1.0; } if(x->max_incr < 0){ x->max_incr *= -1.0; } if(x->minpan < 0.0) { x->minpan = 0.0; } if(x->maxpan > 1.0) { x->maxpan = 1.0; } if(x->events < 0){ x->events = 0; } return 0; }
static void maximum_list(t_maximum *x, t_symbol *s, int argc, t_atom *argv){ if(argc && argc <= PDCYMAXN){ int numfloats = 0; //counting floats, mainly we're interested if there's more than one float - DK t_float second = 0;//second largest t_float first = 0;//largest int idx = 0; //current index int fidx = 0; //index of largest t_float curf = 0; //declare here so accessible outside while while(argc){ if(argv->a_type == A_FLOAT){ numfloats++; curf = atom_getfloatarg(0, argc, argv); if(numfloats == 1){ second = curf; first = curf; fidx = idx; } else{ if(curf > first){ second = first; first = curf; fidx = idx; } else if(curf > second || numfloats == 2){ second = curf; }; }; }; argc--; argv++; idx++; }; if(numfloats >= 1){ x->x_lastidx = fidx; x->x_test = second; x->x_lastmax = first; outlet_float(x->x_idxlet, x->x_lastidx); outlet_float(x->x_maxlet, x->x_lastmax); }; }; }
void *epluribus_new(t_symbol *msg, int argc, t_atom *argv) { t_epluribus *x; int i; x = (t_epluribus *)pd_new(epluribus_class); x->incount = (int) atom_getfloatarg(0,argc,argv); for(i = 0; i < x->incount - 1; i++){ inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("signal"),gensym("signal")); } outlet_new(&x->x_obj, gensym("signal")); outlet_new(&x->x_obj, gensym("signal")); if(x->incount < 2 || x->incount > 256 ){ error("%s: there must be between 2 and 256 input vectors", OBJECT_NAME); return (NULL); } x->inverse = 0; // by default don't do inverse behaviour return (x); }
void *granulesf_setscale(t_granulesf *x, t_symbol *msg, short argc, t_atom *argv) { int i; float *pitchscale = x->pitchscale; if( argc >= MAXSCALE ){ error("%d is the maximum size scale", MAXSCALE); return 0; } if( argc < 2 ){ error("there must be at least 2 members in scale"); return 0; } for(i=0; i < argc; i++){ pitchscale[i] = atom_getfloatarg(i,argc,argv); } x->pitchsteps = argc; return 0; }
static void *mtx_isequal_new(t_symbol *s, int argc, t_atom *argv) { if (argc>1) post("mtx_isequal : extra arguments ignored"); if (argc) { t_mtx_binscalar *x = (t_mtx_binscalar *)pd_new(mtx_isequalscalar_class); floatinlet_new(&x->x_obj, &x->f); x->f = atom_getfloatarg(0, argc, argv); outlet_new(&x->x_obj, 0); return(x); } else { t_mtx_binmtx *x = (t_mtx_binmtx *)pd_new(mtx_isequal_class); inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("matrix"), gensym("")); outlet_new(&x->x_obj, 0); x->m.col = x->m.row = x->m2.col = x->m2.row = 0; x->m.atombuffer = x->m2.atombuffer = 0; return(x); } }
void *tPlane3D_new(t_symbol *s, int argc, t_atom *argv) { t_tPlane3D *x = (t_tPlane3D *)pd_new(tPlane3D_class); x->force_new=outlet_new(&x->x_obj, 0); x->profondeur=outlet_new(&x->x_obj, 0); x->vitesse=outlet_new(&x->x_obj, 0); x->distance_old = 0; if (argc>=7) x->P= atom_getfloatarg(6, argc, argv); else x->P= 10000; if (argc>=6) x->Z= atom_getfloatarg(5, argc, argv); else x->Z= 0; if (argc>=5) x->Y= atom_getfloatarg(4, argc, argv); else x->Y= 0; if (argc>=4) x->X= atom_getfloatarg(3, argc, argv); else x->X= 0; if (argc>=3) x->VZ= atom_getfloatarg(2, argc, argv); else x->VZ= 0; if (argc>=2) x->VY= atom_getfloatarg(1, argc, argv); else x->VY= 0; if (argc>=1) x->VX= atom_getfloatarg(0, argc, argv); else x->VX= 1; return (x); }
void *channel_new(t_symbol *s, int argc, t_atom *argv) { #if MSP t_channel *x = (t_channel *)newobject(channel_class); intin(x,1); dsp_setup((t_pxobject *)x,1); outlet_new((t_object *)x, "signal"); #endif #if PD t_channel *x = (t_channel *)pd_new(channel_class); outlet_new(&x->x_obj, gensym("signal")); #endif x->channel = (int)atom_getfloatarg(0,argc,argv); // x->channel = 0; return (x); }
static void list_tosymbol_list(t_list_tosymbol *x, t_symbol *s, int argc, t_atom *argv) { int i; #if HAVE_ALLOCA char *str = alloca(argc + 1); #else char *str = getbytes(argc + 1); #endif for (i = 0; i < argc; i++) str[i] = (char)atom_getfloatarg(i, argc, argv); str[argc] = 0; outlet_symbol(x->x_obj.ob_outlet, gensym(str)); #if HAVE_ALLOCA #else freebytes(str, argc+1); #endif }
static void *t3_metro_new(t_symbol *s, int ac, t_atom *av) { t_t3_metro *x = (t_t3_metro *)pd_new(t3_metro_class); x->x_metrotime = 10.0; x->x_t3_bang = 0.0; x->x_hit = 0; if((ac == 1)&&IS_A_FLOAT(av,0)) { t3_metro_ft1(x, atom_getfloatarg(0, ac, av)); } x->x_ticks2ms = 1000.0*(double)sys_getblksize()/(double)sys_getsr(); x->x_clock = clock_new(x, (t_method)t3_metro_tick); outlet_new(&x->x_obj, &s_float); x->x_out_next = outlet_new(&x->x_obj, &s_float); inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("ft1")); return (x); }
t_int *lpreson_tilde_perform(t_int *w) { t_object x_obj; t_lpreson_tilde *x = (t_lpreson_tilde *)(w[1]); t_lpreson_control *ctl = (t_lpreson_control *)(w[2]); int n = (int)(w[3]); t_float *in = ctl->c_residual; t_float *out = ctl->c_output; t_int ord = x->x_order; float mem[ord+1]; /* * Do the inverse filtering * * 'data_in' : residual signal (length 'len') * 'data_out' : output frame (length 'len') * 'coeff' : the parcor coefficients (length 'tap') * 'lattice_iir' : filter memory - Previously initialised using init_lattice_iir_filter() * */ int k, i; float sri; for (i=0;i<=ord;i++) { // SETFLOAT (&schur->x_parcors[i],0); mem[i] = 0.0; } for (k = 0; k < n; k++ ) { /* Synthesis filter - Lattice structure */ sri = in[k]; for (i=0; i<ord; i++) { t_float parcor = atom_getfloatarg ((ord-1-i),ord,ctl->x_parcors); sri = sri - parcor * mem[ord-1-i]; mem[ord-i] = mem[ord-1-i] + parcor*sri; } out[k] = sri; mem[0] = sri; } /* next k */ return(w+4); }
/* Set the send buffer size of socket, returns actual size */ static int tcpclient_set_socket_send_buf_size(t_tcpclient *x, int size) { int optVal = size; int optLen = sizeof(int); #ifdef _WIN32 if (setsockopt(x->x_fd, SOL_SOCKET, SO_SNDBUF, (char*)&optVal, optLen) == SOCKET_ERROR) { post("%s_set_socket_send_buf_size: setsockopt returned %d\n", objName, WSAGetLastError()); #else if (setsockopt(x->x_fd, SOL_SOCKET, SO_SNDBUF, (char*)&optVal, optLen) == -1) { post("%s_set_socket_send_buf_size: setsockopt returned %d\n", objName, errno); #endif return 0; } else return (tcpclient_get_socket_send_buf_size(x)); } /* Get/set the send buffer size of client socket */ static void tcpclient_buf_size(t_tcpclient *x, t_symbol *s, int argc, t_atom *argv) { float buf_size = 0; if(x->x_connectstate == 0) { post("%s_buf_size: no clients connected", objName); return; } /* get size of buffer (first element in list) */ if (argc > 0) { if (argv[0].a_type != A_FLOAT) { post("%s_buf_size: specify buffer size with a float", objName); return; } buf_size = atom_getfloatarg(0, argc, argv); x->x_fdbuf = tcpclient_set_socket_send_buf_size(x, (int)buf_size); if (x->x_verbosity) post("%s_buf_size: set to %d", objName, x->x_fdbuf); return; } x->x_fdbuf = tcpclient_get_socket_send_buf_size(x); return; }
static void search(base3_struct *base3, t_symbol *s, int argc, t_atom *argv) { int not_found, not_expired = base3 -> lyap_limit; int jump, i, iterations; t_atom vars[M_var_count]; double temp_a = base3 -> a; double temp_b = base3 -> b; if (argc > 0) { for (i = 0; i < M_var_count; i++) { SETFLOAT(&vars[i], atom_getfloatarg(i, argc, argv)); } } else { for (i = 0; i < M_var_count; i++) { SETFLOAT(&vars[i], base3 -> vars_init[i]); } } do { jump = 500; not_found = 0; iterations = 10000; bad_params: base3 -> a = (drand48() * (base3 -> a_hi - base3 -> a_lo)) + base3 -> a_lo; base3 -> b = (drand48() * (base3 -> b_hi - base3 -> b_lo)) + base3 -> b_lo; // put any preliminary checks specific to this fractal to eliminate bad_params reset(base3, NULL, argc, vars); do { calc(base3, base3 -> vars); } while(jump--); base3 -> lyap_exp = lyapunov((void *) base3, (t_gotfn) calc, M_var_count, (double *) base3 -> vars); if (isnan(base3 -> lyap_exp)) { not_found = 1; } if (base3 -> lyap_exp < base3 -> lyap_lo || base3 -> lyap_exp > base3 -> lyap_hi) { not_found = 1; } not_expired--; } while(not_found && not_expired); reset(base3, NULL, argc, vars); if (!not_expired) { post("Could not find a fractal after %d attempts.", (int) base3 -> lyap_limit); post("Try using wider constraints."); base3 -> a = temp_a; base3 -> b = temp_b; outlet_anything(base3 -> search_outlet, gensym("invalid"), 0, NULL); } else { base3 -> failure_ratio = (base3 -> lyap_limit - not_expired) / base3 -> lyap_limit; make_results(base3); outlet_anything(base3 -> search_outlet, gensym("search"), M_search_count, base3 -> search_out); } }
static void round_zero_anything(t_round_zero *x, t_symbol *s, int ac, t_atom *av) { int i; t_float f, bound=x->x_bound; for(i=0; i<ac; i++) { if(IS_A_FLOAT(av, i)) { f = atom_getfloatarg(i, ac, av); if((f <= bound)&&(f >= -bound)) { f = 0.0f; SETFLOAT(av+i, f); } } } outlet_anything(x->x_obj.ob_outlet, s, ac, av); }
void samm_sampbeats(t_samm *x, t_symbol *msg, short argc, t_atom *argv) { int i; double samples; if(argc != x->metro_count){ error("%s: arguments did not match metro count %d",x->metro_count); return; } for(i = 0; i < argc; i++){ samples = (double)atom_getfloatarg(i,argc,argv); if(samples <= 0){ error("%s: illegal duration for beat stream %d",OBJECT_NAME,i+1); samples = x->sr; } x->metro_samps[i] = samples; x->metro_beatdurs[i] = x->metro_samps[i] / x->onebeat_samps; // just in case tempo changes x->metro[i] = 1.0; // initialize for instantaneous beat } }
void *multigrain_setscale(t_multigrain *x, t_symbol *msg, short argc, t_atom *argv) { int i; float *pitchscale = x->pitchscale; if( argc >= MAXSCALE ){ error("%d is the maximum size scale", MAXSCALE); return 0; } if( argc < 2 ){ error("there must be at least 2 members in scale"); return 0; } for(i=0; i < argc; i++){ pitchscale[i] = atom_getfloatarg(i,argc,argv); } x->pitchsteps = argc; // post("read %d values into scale", x->pitchsteps); return 0; }