static void *urn_new(t_symbol *s, int argc, t_atom *argv)
{
t_urn *x = (t_urn *)pd_new(urn_class);
t_float f=0.;
ZEXY_USEVAR(s);
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym(""));
x->x_floatout=outlet_new(&x->x_obj, gensym("float"));
x->x_bangout =outlet_new(&x->x_obj, gensym("bang"));
x->x_seed = makeseed();
x->x_noauto = 0;
while(argc--){
if (argv->a_type==A_SYMBOL) {
if (atom_getsymbol(argv)==gensym("no_auto")) {
x->x_noauto=1;
}
} else f = atom_getfloat(argv);
argv++;
}
if (f<1.0)f=1.0;
makestate(x, f);
x->x_range = f;
urn_clear(x);
return (x);
}
static void *random_fl_tilde_new()
{
t_random_fl_tilde *x = (t_random_fl_tilde *)pd_new(random_fl_tilde_class);
x->x_state = makeseed();
outlet_new(&x->x_obj, gensym("signal"));
return (x);
}
static void *random_new(t_floatarg f)
{
t_random *x = (t_random *)pd_new(random_class);
x->x_f = f;
x->x_state = makeseed();
floatinlet_new(&x->x_obj, &x->x_f);
outlet_new(&x->x_obj, &s_float);
return (x);
}
static void *random_fl_new(t_floatarg f, t_floatarg g)
{
t_random_fl *x = (t_random_fl *)pd_new(random_fl_class);
x->x_f = (f) ? f : 0;
x->x_g = (g) ? g : RAND_MAX;
//post("cxc/randomix.c: lolim: %f - %f, uplim: %f - %f", x->x_f, f, x->x_g, g);
x->x_state = makeseed();
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("fl1"));
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("fl2"));
outlet_new(&x->x_obj, &s_float);
return (x);
}
LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
int i;
lua_State *L;
global_State *g;
/* cast -> llimits.h line 93 是一个宏*/
/* f -> lauxlib.c l_alloc */
LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG))); /* -> LG *l = (LG *)((*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));*/
if (l == NULL) return NULL;
L = &l->l.l;
g = &l->g;
L->next = NULL;
L->tt = LUA_TTHREAD;
g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
L->marked = luaC_white(g);
g->gckind = KGC_NORMAL;
preinit_state(L, g);
g->frealloc = f;
g->ud = ud;
g->mainthread = L;
g->seed = makeseed(L);
g->uvhead.u.l.prev = &g->uvhead;
g->uvhead.u.l.next = &g->uvhead;
g->gcrunning = 0; /* no GC while building state */
g->GCestimate = 0;
g->strt.size = 0;
g->strt.nuse = 0;
g->strt.hash = NULL;
setnilvalue(&g->l_registry);
luaZ_initbuffer(L, &g->buff);
g->panic = NULL;
g->version = lua_version(NULL);
g->gcstate = GCSpause;
g->allgc = NULL;
g->finobj = NULL;
g->tobefnz = NULL;
g->sweepgc = g->sweepfin = NULL;
g->gray = g->grayagain = NULL;
g->weak = g->ephemeron = g->allweak = NULL;
g->totalbytes = sizeof(LG);
g->GCdebt = 0;
g->gcpause = LUAI_GCPAUSE;
g->gcmajorinc = LUAI_GCMAJOR;
g->gcstepmul = LUAI_GCMUL;
for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
/* memory allocation error: free partial state */
close_state(L);
L = NULL;
}
else
luai_userstateopen(L);
return L;
}
LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
int i;
lua_State *L;
global_State *g;
LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
if (l == NULL) return NULL;
L = &l->l.l;
g = &l->g;
g->ravi_writeline = ravi_default_writeline;
g->ravi_writestring = ravi_default_writestring;
g->ravi_writestringerror = ravi_default_writestringerror;
g->ravi_debugger_data = NULL;
L->next = NULL;
L->tt = LUA_TTHREAD;
g->currentwhite = bitmask(WHITE0BIT);
L->marked = luaC_white(g);
preinit_thread(L, g);
g->frealloc = f;
g->ud = ud;
g->mainthread = L;
g->seed = makeseed(L);
g->gcrunning = 0; /* no GC while building state */
g->GCestimate = 0;
g->strt.size = g->strt.nuse = 0;
g->strt.hash = NULL;
setnilvalue(&g->l_registry);
g->panic = NULL;
g->version = NULL;
g->gcstate = GCSpause;
g->gckind = KGC_NORMAL;
g->allgc = g->finobj = g->tobefnz = g->fixedgc = NULL;
g->sweepgc = NULL;
g->gray = g->grayagain = NULL;
g->weak = g->ephemeron = g->allweak = NULL;
g->twups = NULL;
g->totalbytes = sizeof(LG);
g->GCdebt = 0;
g->gcfinnum = 0;
g->gcpause = LUAI_GCPAUSE;
g->gcstepmul = LUAI_GCMUL;
g->ravi_state = NULL;
for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
raviV_initjit(L);
if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
/* memory allocation error: free partial state */
close_state(L);
L = NULL;
}
return L;
}
static void *random_tw_new(t_floatarg f, t_floatarg g)
{
t_random_tw *x = (t_random_tw *)pd_new(random_tw_class);
x->x_f = (f) ? f : 0;
x->x_g = (g) ? g : RAND_MAX;
//post("cxc/randomix.c: lolim: %f - %f, uplim: %f - %f", x->x_f, f, x->x_g, g);
x->x_state = makeseed();
x->x_s1=390451501;
x->x_s2=613566701;
x->x_s3=858993401;
x->x_k1=31;
x->x_k2=29;
x->x_k3=28;
x->x_q1=13;
x->x_q2=2;
x->x_q3=3;
x->x_p1=12;
x->x_p2=4;
x->x_p3=17;
/* x->x_q1=3; */
/* x->x_q2=2; */
/* x->x_q3=13; */
/* x->x_p1=20; */
/* x->x_p2=16; */
/* x->x_p3=7; */
random_tw_rand_seed(x, makeseed(),makeseed(),makeseed());
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("fl1"));
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("fl2"));
outlet_new(&x->x_obj, &s_float);
return (x);
}
static void *urn_new(t_floatarg f)
{
t_urn *x = (t_urn *)pd_new(urn_class);
srand( (unsigned)time( NULL ) );
x->x_numbers = x->x_f = f;
if(x->x_f < 0)x->x_f = 0;
x->x_selected = getbytes(((t_int)x->x_f+1)*sizeof(t_int));
x->x_state = makeseed();
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("f"));
x->x_numberout = outlet_new(&x->x_obj, &s_float);
x->x_notify = outlet_new(&x->x_obj, &s_bang);
return (x);
}
void *rdist_new(t_symbol *msg, short argc, t_atom *argv){
t_rdist *x;
int i;
t_atom ar[2];
x = (t_rdist *)newobject(rdist_class); // create a new instance of this object
x->r_out0 = outlet_new(x, 0);
x->r_numVars = 0;
// set up the random number generator
gsl_rng_env_setup();
// waterman14 was the fastest according to my tests
x->r_rng = gsl_rng_alloc((const gsl_rng_type *)gsl_rng_waterman14);
// seed it by reading from /dev/random on mac os x and
// something similar on windows
gsl_rng_set(x->r_rng, makeseed());
// this is really f*****g important. if there's an error and the gsl's
// default handler gets called, it aborts the program!
gsl_set_error_handler(rdist_errorHandler);
// setup a workspace
x->r_output_buffer = (t_atom *)malloc(RDIST_DEFAULT_BUF_SIZE * sizeof(t_atom));
// init the lib. just gensyms all the distribution names
librdist_init();
// handle the args. this should be done with attributes.
if(argc){
if(argv[0].a_type == A_SYM){
rdist_anything(x, argv[0].a_w.w_sym, argc - 1, argv + 1);
}
} else {
SETFLOAT(&(ar[0]), 0.);
SETFLOAT(&(ar[1]), 1.);
rdist_anything(x, gensym("uniform"), 2, ar);
}
return x;
}
void *ar_new(t_symbol *name, long size){
t_ar *x;
if(x = (t_ar *)object_alloc(ar_class)){
t_hashtab *ht;
t_linklist *ll;
x->outlets[3] = outlet_new(x, NULL);
x->outlets[2] = outlet_new(x, NULL);
x->outlets[1] = outlet_new(x, NULL);
x->outlets[0] = outlet_new(x, NULL);
if(strlen(name->s_name) > 0){
x->name = name;
x->iname_ht = ar_make_iname(name, _sym_hashtab);
x->iname_ll = ar_make_iname(name, _sym_linklist);
ar_inc_refcount(x->name);
if(ht = (t_hashtab *)(name->s_thing)){
}else{
ht = (t_hashtab *)hashtab_new(size);
x->iname_ht->s_thing = (t_object *)ht;
ll = (t_linklist *)linklist_new();
x->iname_ll->s_thing = (t_object *)ll;
}
}else{
x->name = ar_make_def_name();
x->iname_ht = ar_make_iname(x->name, _sym_hashtab);
x->iname_ll = ar_make_iname(x->name, _sym_linklist);
ar_inc_refcount(x->name);
/*
x->name = _sym_emptytext;
x->iname_ht = _sym_emptytext;
x->iname_ll = _sym_emptytext;
*/
}
srand(makeseed());
return x;
}
return NULL;
}
void *gendyn_new(t_symbol *msg, short argc, t_atom *argv){
t_gendyn *x;
x = (t_gendyn *)newobject(gendyn_class); // create a new instance of this object
dsp_setup((t_pxobject *)x, 1);
outlet_new((t_pxobject *)x, "signal");
if(argc == 0){
error("you must specify the gendy type [1-3]");
return NULL;
}
x->g_type = argv[0].a_w.w_long;
x->g_whichamp = 1;
x->g_whichdur = 1;
x->g_aamp = 1.f;
x->g_adur = 1.f;
x->g_minfreq = 440.f;
x->g_maxfreq = 660.f;
x->g_scaleamp = 0.5f;
x->g_scaledur = 0.5f;
if(argc > 1) x->g_whichamp = argv[1].a_w.w_long;
if(argc > 2) x->g_whichdur = argv[2].a_w.w_long;
if(argc > 3){
if(argv[3].a_type == A_LONG) x->g_aamp = argv[3].a_w.w_long;
else x->g_aamp = (float)argv[3].a_w.w_float;
}
if(argc > 4){
if(argv[4].a_type == A_LONG) x->g_adur = argv[4].a_w.w_long;
else x->g_adur = (float)argv[4].a_w.w_float;
}
if(argc > 5){
if(argv[5].a_type == A_LONG) x->g_minfreq = argv[5].a_w.w_long;
else x->g_minfreq = (float)argv[5].a_w.w_float;
}
if(argc > 6){
if(argv[6].a_type == A_LONG) x->g_maxfreq = argv[6].a_w.w_long;
else x->g_maxfreq = (float)argv[6].a_w.w_float;
}
if(argc > 7){
if(argv[7].a_type == A_LONG) x->g_scaleamp = argv[7].a_w.w_long;
else x->g_scaleamp = (float)argv[7].a_w.w_float;
}
if(argc > 8){
if(argv[8].a_type == A_LONG) x->g_scaledur = argv[8].a_w.w_long;
else x->g_scaledur = (float)argv[8].a_w.w_float;
}
gsl_rng_env_setup();
x->g_rng = gsl_rng_alloc((const gsl_rng_type *)gsl_rng_default);
// systime_ms() is a really bad idea since it'll be the same or very close if a bunch
// are instantiated when the patch opens.
//gsl_rng_set(x->r_rng, systime_ms());
// makeseed() is from the PD code in x_misc.c
gsl_rng_set(x->g_rng, makeseed());
switch(x->g_type){
case 1:
gendy1_constructor(x);
break;
case 2:
gendy2_constructor(x);
break;
case 3:
gendy3_constructor(x);
break;
}
return(x);
}
