void split_path_setup(void) { split_path_class = class_new(gensym("split_path"), (t_newmethod)split_path_new, 0, sizeof(t_split_path), 0,0); class_addsymbol(split_path_class,split_path_symbol); logpost(NULL, 4, "[split_path] %s",version); logpost(NULL, 4, "\twritten by Hans-Christoph Steiner <*****@*****.**>"); }
static void sys_loadstartup(void) { char startupdir[PATH_MAX]; struct stat statbuf; strncpy(startupdir, sys_libdir->s_name, PATH_MAX - 8); strcat(startupdir, "/startup"); if (stat(startupdir, &statbuf) == 0 && statbuf.st_mode & S_IFDIR) { DIR* dirp; struct dirent *dp; struct stat statbuf; char buf[PATH_MAX]; char* extension; logpost(NULL, 5, "Using %s as startup.", startupdir); dirp = opendir(startupdir); while ((dp = readdir(dirp)) != NULL) { if(strcmp(".", dp->d_name) == 0 || strcmp("..", dp->d_name) == 0) continue; strncpy(buf, startupdir, PATH_MAX - 1); strcat(buf, "/"); strncat(buf, dp->d_name, PATH_MAX - strlen(buf) - 1); #ifdef _WIN32 char resolved_path[PATH_MAX]; strncpy(resolved_path, buf, PATH_MAX); #elif defined(__gnu_linux__) || defined(__AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER) /* safe, non-standard format of realpath(), with NULL resolved_name */ char* tmp = realpath(buf, NULL); char resolved_path[strlen(tmp)]; strcpy(resolved_path, tmp); free(tmp); #else char resolved_path[PATH_MAX]; realpath(buf, resolved_path); #endif /* _WIN32 elif __gnu_linux__ */ stat(resolved_path, &statbuf); if (S_ISREG(statbuf.st_mode)) { logpost(NULL, 4, "Loading %s", buf); /* remove the extension for sys_load_lib() */ extension = strrchr(resolved_path, '.'); if (extension != NULL) *extension = 0; if (!sys_load_lib(0, resolved_path)) error("%s: can't load startup library'!\n", buf); } else if (S_ISDIR(statbuf.st_mode)) { /* try lib-in-folder style, i.e. mylib/mylib.pd_linux */ logpost(NULL, 4, "Loading %s in %s", dp->d_name, buf); if (!sys_load_lib(0, dp->d_name)) error("%s: can't load startup library'!\n", buf); } } (void)closedir(dirp); } }
///////////////////////////////////////////////////////// // add backends // ///////////////////////////////////////////////////////// bool pix_video :: addHandle( std::vector<std::string>available, std::string ID) { unsigned int i=0; int count=0; std::vector<std::string>id; if(!ID.empty()) { // if requested 'cid' is in 'available' add it to the list of 'id's if(std::find(available.begin(), available.end(), ID)!=available.end()) { id.push_back(ID); } else { // request for an unavailable ID logpost(NULL, 6, "backend '%s' unavailable", ID.c_str()); return false; } } else { // no 'ID' given: add all available IDs id=available; } for(i=0; i<id.size(); i++) { std::string key=id[i]; logpost(NULL, 6, "trying to add '%s' as backend", key.c_str()); if(std::find(m_ids.begin(), m_ids.end(), key)==m_ids.end()) { // not yet added, do so now! gem::plugins::video *handle=NULL; startpost("backend #%d='%s'\t", m_videoHandles.size(), key.c_str()); try { handle=gem::PluginFactory<gem::plugins::video>::getInstance(key); } catch (GemException ex) { } if(NULL==handle) { post("<--- DISABLED"); continue; } std::vector<std::string>devs=handle->provides(); if(devs.size()>0) { startpost(": "); unsigned int i=0; for(i=0; i<devs.size(); i++) { startpost("%s ", devs[i].c_str()); } } endpost(); m_ids.push_back(key); m_videoHandles.push_back(handle); count++; logpost(NULL, 6, "added backend#%d '%s' @ 0x%x", m_videoHandles.size()-1, key.c_str(), handle); } } return (count>0); }
void libdir_setup(void) { int major, minor, bugfix; sys_getversion(&major, &minor, &bugfix); if (major>0 || minor >=47) { sys_register_loader((void*)libdir_loader_pathwise); } else { sys_register_loader((void*)libdir_loader_legacy); } logpost(NULL, 3, "libdir loader %s",version); logpost(NULL, 3, "\tcompiled on "__DATE__" at "__TIME__ " "); logpost(NULL, 3, "\tcompiled against Pd version %d.%d.%d.%s", PD_MAJOR_VERSION, PD_MINOR_VERSION, PD_BUGFIX_VERSION, PD_TEST_VERSION); libdir_class = class_new(gensym("libdir"), libdir_new, 0, sizeof(t_object), CLASS_NOINLET, 0); }
void unroute_setup(void) { unroute_class = class_new(gensym("unroute"), (t_newmethod)unroute_new, 0, sizeof(t_unroute), 0, A_GIMME, 0); #else void maxlib_unroute_setup(void) { unroute_class = class_new(gensym("maxlib/unroute"), (t_newmethod)unroute_new, 0, sizeof(t_unroute), 0, A_GIMME, 0); #endif /* a class for the proxy inlet: */ proxy_class = class_new(gensym("maxlib/unroute_proxy"), NULL, NULL, sizeof(t_proxy), CLASS_PD|CLASS_NOINLET, A_NULL); class_addanything(proxy_class, unroute_input); class_addfloat(unroute_class, unroute_float); class_addlist(unroute_class, unroute_list); class_addanything(unroute_class, unroute_any); #ifndef MAXLIB logpost(NULL, 4, version); #else class_addcreator((t_newmethod)unroute_new, gensym("unroute"), A_GIMME, 0); class_sethelpsymbol(unroute_class, gensym("maxlib/unroute-help.pd")); #endif }
///////////////////////////////////////////////////////// // startRendering // ///////////////////////////////////////////////////////// void GemMan :: startRendering() { if (!m_windowState) { error("GEM: Create window first!"); return; } if (m_rendering) return; logpost(NULL, 3, "GEM: Start rendering"); // set up all of the gemheads renderChain(gensym("__gem_render"), true); renderChain(gensym("__gem_render_osd"), true); m_rendering = 1; // if only single buffering then just return if (GemMan::m_buffer == 1) return; m_lastRenderTime = clock_getsystime(); render(NULL); }
///////////////////////////////////////////////////////// // // polygon // ///////////////////////////////////////////////////////// // Constructor // ///////////////////////////////////////////////////////// polygon :: polygon(t_floatarg numInputs) : GemShape(), m_numVertices(0), m_vertarray(NULL), m_vert(NULL), m_numInputs(0), m_inlet(NULL) { int i; int realNum = static_cast<int>(numInputs); // configure the inlets if(realNum>0) { createVertices(realNum); m_numInputs=realNum; m_inlet=new t_inlet*[m_numInputs]; char tempVt[7]; // create the proper number of inputs for (i = 0; i < realNum; i++) { sprintf(tempVt, "%d", i+1); m_inlet[i]=inlet_new(this->x_obj, &this->x_obj->ob_pd, &s_list, gensym(tempVt) ); } } else { logpost(NULL, 5, "variable number of vertices"); } }
void exciter_setup(void) { logpost(NULL, 4, exciter_version ); exciter_class = class_new(gensym("exciter"), (t_newmethod)exciter_new, (t_method)exciter_free, sizeof(t_exciter), 0, A_GIMME, 0); class_addmethod(exciter_class, (t_method)exciter_dialog, gensym("dialog"), A_GIMME, 0); class_addmethod(exciter_class, (t_method)exciter_dump, gensym("dump"), 0); class_addmethod(exciter_class, (t_method)exciter_clear, gensym("clear"), 0); class_addmethod(exciter_class, (t_method)exciter_start, gensym("start"), 0); class_addmethod(exciter_class, (t_method)exciter_stop, gensym("stop"), 0); class_addmethod(exciter_class, (t_method)exciter_reset, gensym("reset"), 0); class_addmethod(exciter_class, (t_method)exciter_pause, gensym("pause"), 0); class_addmethod(exciter_class, (t_method)exciter_resume, gensym("resume"), 0); class_addmethod(exciter_class, (t_method)exciter_dsp, gensym("dsp"), A_NULL); exciter_widgetbehavior.w_getrectfn = exciter_getrect; exciter_widgetbehavior.w_displacefn = exciter_displace; exciter_widgetbehavior.w_selectfn = exciter_select; exciter_widgetbehavior.w_activatefn = NULL; exciter_widgetbehavior.w_deletefn = exciter_delete; exciter_widgetbehavior.w_visfn = exciter_vis; exciter_widgetbehavior.w_clickfn = exciter_click; #if PD_MINOR_VERSION >= 37 class_setpropertiesfn(exciter_class, exciter_properties); class_setsavefn(exciter_class, exciter_save); #else exciter_widgetbehavior.w_propertiesfn = exciter_properties; exciter_widgetbehavior.w_savefn = exciter_save; #endif class_setwidget(exciter_class, &exciter_widgetbehavior); sys_vgui("eval [read [open {%s/%s.tcl}]]\n", exciter_class->c_externdir->s_name, exciter_class->c_name->s_name); }
void dist_setup(void) { dist_class = class_new(gensym("dist"), (t_newmethod)dist_new, 0, sizeof(t_dist), 0, A_GIMME, 0); #else void maxlib_dist_setup(void) { dist_class = class_new(gensym("maxlib_dist"), (t_newmethod)dist_new, 0, sizeof(t_dist), 0, A_GIMME, 0); #endif class_addcreator((t_newmethod)dist_new, gensym("d"), A_GIMME, 0); class_addbang(dist_class, dist_bang); class_addfloat(dist_class, dist_float); class_addsymbol(dist_class, dist_symbol); class_addpointer(dist_class, dist_pointer); class_addlist(dist_class, dist_list); class_addmethod(dist_class, (t_method)dist_connect, gensym("connect"), A_GIMME, 0); class_addmethod(dist_class, (t_method)dist_disconnect, gensym("disconnect"), A_GIMME, 0); class_addmethod(dist_class, (t_method)dist_clear, gensym("clear"), 0); class_addmethod(dist_class, (t_method)dist_print, gensym("print"), 0); class_addmethod(dist_class, (t_method)dist_send, gensym("send"), A_GIMME, 0); class_addanything(dist_class, dist_anything); #ifndef MAXLIB logpost(NULL, 4, version); #else class_addcreator((t_newmethod)dist_new, gensym("dist"), A_GIMME, 0); class_sethelpsymbol(dist_class, gensym("maxlib/dist-help.pd")); #endif }
///////////////////////////////////////////////////////// // enumerate devices // ///////////////////////////////////////////////////////// void pix_video :: enumerateMess() { std::vector<std::string>data; std::vector<std::string>backends; unsigned int i=0; for(i=0; i<m_videoHandles.size(); i++) { // a.insert(a.end(), b.begin(), b.end()); if(m_videoHandles[i]) { std::string name=m_videoHandles[i]->getName(); logpost(NULL, 5, "enumerating: %s", name.c_str()); std::vector<std::string>temp=m_videoHandles[i]->enumerate(); unsigned int i=0; for(i=0; i<temp.size(); i++) { backends.push_back(name); data.push_back(temp[i]); } } } if(data.size()<=0) { error("no devices found"); } t_atom ap[2]; SETFLOAT(ap, data.size()); outlet_anything(m_infoOut, gensym("devices"), 1, ap); for(i=0; i<data.size(); i++) { SETSYMBOL(ap+0, gensym(data[i].c_str())); SETSYMBOL(ap+1, gensym(backends[i].c_str())); outlet_anything(m_infoOut, gensym("device"), 2, ap); // post("%d: %s", i, data[i].c_str()); } }
void nroute_setup(void) { /* the object's class: */ nroute_class = class_new(gensym("nroute"), (t_newmethod)nroute_new, 0, sizeof(t_nroute), 0, A_GIMME, 0); #else void maxlib_nroute_setup(void) { /* the object's class: */ nroute_class = class_new(gensym("maxlib/nroute"), (t_newmethod)nroute_new, 0, sizeof(t_nroute), 0, A_GIMME, 0); class_addcreator((t_newmethod)nroute_new, gensym("nroute"), A_GIMME, 0); #endif /* a class for the proxy inlet: */ proxy_class = class_new(gensym("maxlib/nroute_proxy"), NULL, NULL, sizeof(t_proxy), CLASS_PD|CLASS_NOINLET, A_NULL); class_addmethod(nroute_class, (t_method)nroute_setpos, gensym("right"), A_FLOAT, 0); class_addfloat(nroute_class, nroute_float); class_addlist(nroute_class, nroute_list); class_addanything(nroute_class, nroute_any); class_addanything(proxy_class, nroute_setmatch); #ifndef MAXLIB logpost(NULL, 4, version); #else class_sethelpsymbol(nroute_class, gensym("maxlib/nroute-help.pd")); #endif }
void sync_setup(void) { sync_class = class_new(gensym("sync"), (t_newmethod)sync_new, 0, sizeof(t_sync), 0, A_GIMME, 0); #else void maxlib_sync_setup(void) { sync_class = class_new(gensym("maxlib_sync"), (t_newmethod)sync_new, 0, sizeof(t_sync), 0, A_GIMME, 0); #endif /* a class for the proxy inlet: */ proxy_class = class_new(gensym("maxlib_sync_proxy"), NULL, NULL, sizeof(t_proxy), CLASS_PD|CLASS_NOINLET, A_NULL); class_addfloat(proxy_class, sync_float_input); class_addanything(proxy_class, sync_input); class_addfloat(sync_class, sync_float); class_addmethod(sync_class, (t_method)sync_set_trigger, gensym("trigger"), A_GIMME, 0); class_addmethod(sync_class, (t_method)sync_set_require, gensym("require"), A_GIMME, 0); class_addmethod(sync_class, (t_method)sync_set_mode, gensym("mode"), A_SYMBOL, 0); #ifndef MAXLIB logpost(NULL, 4, version); #else class_addcreator((t_newmethod)sync_new, gensym("sync"), A_GIMME, 0); class_sethelpsymbol(sync_class, gensym("maxlib/sync-help.pd")); #endif }
///////////////////////////////////////////////////////// // spits out a list of installed codecs and stores them // ///////////////////////////////////////////////////////// void pix_record :: getCodecList() { m_pimpl->clearCodecHandle(); unsigned int i=0; for(i=0; i<m_handles.size(); i++) { std::vector<std::string>c=m_handles[i]->getCodecs(); unsigned int j; for(j=0; j<c.size(); j++) { m_pimpl->addCodecHandle(m_handles[i], c[j]); } } for(i=0; i<m_pimpl->m_codecs.size(); i++) { const std::string id=m_pimpl->m_codecs[i]; std::vector<PIMPL::codechandle>handles=m_pimpl->m_codechandle[id]; unsigned int j=0; for(j=0; j<handles.size(); j++) { gem::plugins::record*handle=handles[j].handle; const std::string codecname=handles[j].codec; const std::string descr=handle->getCodecDescription(codecname); t_atom ap[3]; logpost(NULL, 6, "codec%d: '%s': %s", i, codecname.c_str(), (descr.empty()?"":descr.c_str())); SETFLOAT (ap+0, static_cast<t_float>(i)); SETSYMBOL(ap+1, gensym(codecname.c_str())); SETSYMBOL(ap+2, gensym(descr.c_str())); outlet_anything(m_outInfo, gensym("codec"), 3, ap); } } }
static void colorpanel_list(t_colorpanel *x, t_symbol *s, int argc, t_atom *argv) { t_symbol *tmp_symbol = s; /* <-- this gets rid of the unused variable warning */ int i; unsigned int tmp_int; char color_buffer[3]; char color_string[MAXPDSTRING]; strncpy(color_string,"#",MAXPDSTRING); if(argc > 3) logpost(x, 2, "[colorpanel] warning more than three elements in list"); for(i=0; i<3; i++) { tmp_symbol = atom_getsymbolarg(i, argc, argv); if(tmp_symbol == &s_) { tmp_int = (unsigned int)(atom_getfloatarg(i, argc , argv) * 255); snprintf(color_buffer, 3, "%02x", (tmp_int > 255 ? 255 : tmp_int)); strncat(color_string, color_buffer, 3); } else { pd_error(x,"[colorpanel] symbols are not allowed in the color list"); return; } } memcpy(x->current_color, color_string, 7); colorpanel_bang(x); }
void netserver_setup(void) { netserver_class = class_new(gensym("netserver"),(t_newmethod)netserver_new, (t_method)netserver_free, sizeof(t_netserver), 0, A_DEFFLOAT, 0); class_addmethod(netserver_class, (t_method)netserver_print, gensym("print"), 0); class_addmethod(netserver_class, (t_method)netserver_send, gensym("send"), A_GIMME, 0); class_addmethod(netserver_class, (t_method)netserver_client_send, gensym("client"), A_GIMME, 0); class_addmethod(netserver_class, (t_method)netserver_broadcast, gensym("broadcast"), A_GIMME, 0); /* syslog log level messages */ class_addmethod(netserver_class, (t_method)netserver_emerg, gensym("emerg"), 0); class_addmethod(netserver_class, (t_method)netserver_emerg, gensym("emergency"), 0); class_addmethod(netserver_class, (t_method)netserver_alert, gensym("alert"), 0); class_addmethod(netserver_class, (t_method)netserver_crit, gensym("crit"), 0); class_addmethod(netserver_class, (t_method)netserver_crit, gensym("critical"), 0); class_addmethod(netserver_class, (t_method)netserver_err, gensym("err"), 0); class_addmethod(netserver_class, (t_method)netserver_err, gensym("error"), 0); class_addmethod(netserver_class, (t_method)netserver_err, gensym("quiet"), 0); class_addmethod(netserver_class, (t_method)netserver_warning, gensym("warning"), 0); class_addmethod(netserver_class, (t_method)netserver_notice, gensym("notice"), 0); class_addmethod(netserver_class, (t_method)netserver_info, gensym("info"), 0); class_addmethod(netserver_class, (t_method)netserver_info, gensym("verbose"), 0); class_addmethod(netserver_class, (t_method)netserver_debug, gensym("debug"), 0); logpost(NULL, 4, version); }
/* print settings */ static void mp3streamout_print(t_mp3streamout *x) { const char * buf = 0; logpost(NULL, 4, mp3streamout_version); post(" LAME mp3 settings:\n" " output sample rate: %d Hz\n" " bitrate: %d kbit/s", x->x_samplerate, x->x_bitrate); switch(x->x_mp3mode) { case 0 : buf = "stereo"; break; case 1 : buf = "joint stereo"; break; case 2 : buf = "dual channel"; break; case 3 : buf = "mono"; break; } post(" mode: %s\n" " quality: %d", buf, x->x_mp3quality); #ifdef _WIN32 if(x->x_lamechunk!=0)post(" calculated mp3 chunk size: %d", x->x_lamechunk); #else post(" mp3 chunk size: %d", x->x_lamechunk); #endif if(x->x_samplerate!=sys_getsr()) { post(" resampling from %d to %d Hz!", (int)sys_getsr(), x->x_samplerate); } }
double BLSSS::find_posterior_mode() { BinomialLogitUnNormalizedLogPosterior logpost(m_, pri_.get()); const Selector &inc(m_->coef().inc()); Vector beta(m_->included_coefficients()); int dim = beta.size(); if (dim == 0) { return negative_infinity(); // TODO: This logic prohibits an empty model. Better to return // the actual value of the un-normalized posterior, which in // this case would just be the likelihood portion. } else { Vector gradient(dim); Matrix hessian(dim, dim); double logf; std::string error_message; bool ok = max_nd2_careful(beta, gradient, hessian, logf, Target(logpost), dTarget(logpost), d2Target(logpost), 1e-5, error_message); if (ok) { m_->set_included_coefficients(beta, inc); return logf; } else { return negative_infinity(); } } }
void pix_video :: getPropertyMess(int argc, t_atom*argv) { if(argc) { int i=0; m_readprops.clear(); for(i=0; i<argc; i++) { addProperties(m_readprops, 1, argv+i); } } else { /* LATER: read all properties */ } t_atom ap[4]; if(m_videoHandle) { m_videoHandle->getProperties(m_readprops); std::vector<std::string>keys=m_readprops.keys(); unsigned int i=0; for(i=0; i<keys.size(); i++) { std::string key=keys[i]; SETSYMBOL(ap+0, gensym(key.c_str())); int ac=0; switch(m_readprops.type(key)) { default: case gem::Properties::UNSET: ac=0; break; case gem::Properties::NONE: ac=1; break; case gem::Properties::DOUBLE: do { double d=0; if(m_readprops.get(key, d)) { ac=2; SETFLOAT(ap+1, d); } } while(0); break; case gem::Properties::STRING: do { std::string s; if(m_readprops.get(key, s)) { ac=2; SETSYMBOL(ap+1, gensym(s.c_str())); } } while(0); break; } if(ac) { outlet_anything(m_infoOut, gensym("prop"), ac, ap); } else { post("oops: %s", key.c_str()); } } } else { logpost(NULL, 5, "no open videodevice...remembering properties..."); } }
void pix_video :: applyPropertiesMess() { if(m_videoHandle) { m_videoHandle->setProperties(m_writeprops); } else { logpost(NULL, 5, "no open videodevice...remembering properties..."); } }
void pitch_setup(void) { pitch_class = class_new(gensym("pitch"), (t_newmethod)pitch_new, 0, sizeof(t_pitch), 0, A_DEFFLOAT, 0); class_addfloat(pitch_class, pitch_float); logpost(NULL, 4, version); }
void remote_setup(void) { remote_class = class_new(gensym("remote"), (t_newmethod)remote_new, 0, sizeof(t_remote), 0, A_DEFSYM, 0); class_addanything(remote_class, remote_anything); logpost(NULL, 4, version); }
void netrec_setup(void) { netrec_class = class_new(gensym("netrec"),(t_newmethod)netrec_new, (t_method)netrec_free, sizeof(t_netrec), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFSYM, 0); class_addmethod(netrec_class, (t_method)netrec_print, gensym("print"), 0); logpost(NULL, 4, version); }
void SLLTPS::draw_nu_slope() { NuPosteriorFast logpost(nu_slope_prior_.get(), &model_->nu_slope_complete_data_suf()); ScalarSliceSampler sampler(logpost, true); sampler.set_lower_limit(0.0); double nu = sampler.draw(model_->nu_slope()); model_->set_nu_slope(nu); }
void edge_setup(void) { edge_class = class_new(gensym("edge"), (t_newmethod)edge_new, 0, sizeof(t_edge), 0, A_DEFFLOAT, 0); class_addfloat(edge_class, edge_float); logpost(NULL, 4, version); }
void listfifo_setup(void) { listfifo_class = class_new(gensym("listfifo"), (t_newmethod)listfifo_new, (t_method)listfifo_free, sizeof(t_listfifo), 0, A_DEFFLOAT, 0); class_addbang(listfifo_class, listfifo_bang); class_addlist(listfifo_class, listfifo_list); logpost(NULL, 4, version); }
static void *hoa_new(t_symbol *s) { t_eobj *x = (t_eobj *)eobj_new(cream_class); if(x) { logpost(x, 3, "HOA Library by Pierre Guillot, Eliott Paris & Thomas Le Meur\n© 2013 - 2015 CICM | Paris 8 University\nVersion %s (%s) for Pure Data %i.%i\n",hoaversion, __DATE__, PD_MAJOR_VERSION, PD_MINOR_VERSION); } return (x); }
void listfunnel_setup(void) { listfunnel_class = class_new(gensym("listfunnel"), (t_newmethod)listfunnel_new, 0, sizeof(t_listfunnel), 0, 0, 0); class_addfloat(listfunnel_class, listfunnel_float); class_addlist(listfunnel_class, listfunnel_list); logpost(NULL, 4, version); }
void countund_setup(void) { logpost(NULL, 4, countund_version); countund_class = class_new(gensym("countund"), (t_newmethod)countund_new, (t_method)countund_free, sizeof(t_countund), 0, A_DEFFLOAT, 0); class_addmethod( countund_class, (t_method)countund_bang, &s_bang, 0); class_addmethod( countund_class, (t_method)countund_limit, gensym("limit"), A_FLOAT, 0); }
void plus_setup(void) { plus_class = class_new(gensym("plus"), (t_newmethod)plus_new, 0, sizeof(t_plus), 0, A_GIMME, 0); class_addfloat(plus_class, plus_float); class_addmethod(plus_class, (t_method)plus_ft1, gensym("ft1"), A_FLOAT, 0); class_addbang(plus_class, (t_method)plus_bang); logpost(NULL, 4, version); }
static void itov_set(t_itov *x, t_float lo, t_float hi, t_float nbins) { if (nbins<1) { nbins=1; logpost(x, 2, "[itov] minimum number of bins is 1"); } if (hi<=lo) { logpost(x, 2, "[itov] higher bound (%g) must be higher than lower bound (%g)", hi, lo); hi=lo+1.0f; } x->m_hi=hi; x->m_lo=lo; x->m_nbins=(int)nbins; x->m_scale=(t_float)x->m_nbins/(hi-lo); }