void
init_iac(void)
{
#ifndef NOSPARE
dx_define("update-excitation",xupdate_excitation);
dx_define("update-inhibition",xupdate_inhibition);
dx_define("update-iac-activation",xupdate_IAC_activation);
dx_define("update-art-activation",xupdate_ART_activation);
#endif
}
void init_idx3(void)
{
#ifdef Midx_madotma
dx_define("idx-dot",Xidx_madotma);
#endif
#ifdef Midx_madotmaacc
dx_define("idx-dotacc",Xidx_madotmaacc);
#endif
#ifdef Midx_madotm0
dx_define("idx-dotm0",Xidx_madotm0);
#endif
#ifdef Midx_madotm0acc
dx_define("idx-dotm0acc",Xidx_madotm0acc);
#endif
#ifdef Midx_maaddm0
dx_define("idx-addm0",Xidx_maaddm0);
#endif
#ifdef Midx_maaddm0acc
dx_define("idx-addm0acc",Xidx_maaddm0acc);
#endif
#ifdef Midx_masqrdist
dx_define("idx-sqrdist",Xidx_masqrdist);
#endif
#ifdef Midx_masqrdistacc
dx_define("idx-sqrdistacc",Xidx_masqrdistacc);
#endif
}
void
init_adaptknn(void)
{
dx_define("knn",xknn);
dx_define("knn-class",xknn_class);
dx_define("codebook-distances",xcodebook_distances);
dx_define("codebook-distorsion",xcodebook_distorsion);
dx_define("perf-knn",xperf_knn);
dx_define("k-means",xk_means);
dx_define("k-means-internal",xk_means_internal);
dx_define("learn-lvq",xlearn_lvq);
}
void init_nan(void)
{
if (sizeof(flt)==4 && sizeof(real)==8 && sizeof(int)==4) {
/* Setup bit patterns */
int a = 1;
a = *(char*) &a;
ieee_nanf[0] = 0xffc00000;
ieee_inftyf[0] = 0x7f800000;
ieee_nand[a] = 0xfff80000;
ieee_nand[1-a] = 0x00000000;
ieee_inftyd[a] = 0x7ff00000;
ieee_inftyd[1-a] = 0x00000000;
/* Setup FPE IRQ with first evaluation of IEEE compliance */
ieee_present = ( sizeof(real)==8 && sizeof(int)==4 );
set_fpe_irq();
/* Check that NaN works as expected */
if (ieee_present) {
char *nand = (char *)ieee_nand;
char *inftyd = (char *)ieee_inftyd;
if (!isnanD(*(real*)nand + 3.0) ||
!isnanD(*(real*)nand - 3.0e40) ||
!isinfD(*(real*)inftyd - 3.0e40) ) {
ieee_present = 0;
set_fpe_irq();
}
}
}
/* Define functions */
/* dx_define("nan" , xnan ); */
dx_define("nanp" , xnanp );
/* dx_define("infinity", xinfinity); */
dx_define("infinityp", xinfinityp);
dx_define("not-nan", xnot_nan);
dx_define("eps", xeps);
dy_define("progn-without-fpe", yprogn_without_fpe);
}
void init_idx4(void)
{
#ifdef Midx_m2dotm1
dx_define("idx-m2dotm1", Xidx_m2dotm1);
#endif
#ifdef Midx_m4dotm2
dx_define("idx-m4dotm2", Xidx_m4dotm2);
#endif
#ifdef Midx_m2dotm1acc
dx_define("idx-m2dotm1acc", Xidx_m2dotm1acc);
#endif
#ifdef Midx_m4dotm2acc
dx_define("idx-m4dotm2acc", Xidx_m4dotm2acc);
#endif
#ifdef Midx_maadd
dx_define("idx-add",Xidx_maadd);
#endif
#ifdef Midx_masub
dx_define("idx-sub",Xidx_masub);
#endif
#ifdef Midx_mamul
dx_define("idx-mul",Xidx_mamul);
#endif
#ifdef Midx_madiv
dx_define("idx-div",Xidx_madiv);
#endif
#ifdef Midx_m1extm1
dx_define("idx-m1extm1",Xidx_m1extm1);
#endif
#ifdef Midx_m1extm1acc
dx_define("idx-m1extm1acc",Xidx_m1extm1acc);
#endif
#ifdef Midx_m2extm2
dx_define("idx-m2extm2",Xidx_m2extm2);
#endif
#ifdef Midx_m2extm2acc
dx_define("idx-m2extm2acc",Xidx_m2extm2acc);
#endif
/*
dx_define("idx-m1permute",Xidx_m1permute);
dx_define("idx-m2permute",Xidx_m2permute);
*/
}
void init_oostruct(void)
{
mt_object = MM_REGTYPE("object", SIZEOF_OBJECT,
clear_object, mark_object, finalize_object);
mt_object2 = MM_REGTYPE("object2", SIZEOF_OBJECT2,
clear_object, mark_object, finalize_object);
mt_method_hash =
MM_REGTYPE("method-hash", 0,
clear_method_hash, mark_method_hash, 0);
pre_init_oostruct();
MM_ROOT(unreachables);
class_class->backptr = new_at(class_class, class_class);
class_define("Class", class_class);
/*
* mm_alloc object_class to avoid hickup in mark_class
*/
object_class = new_builtin_class(NIL);
object_class->dispose = (dispose_func_t *)oostruct_dispose;
object_class->listeval = oostruct_listeval;
object_class->compare = oostruct_compare;
object_class->hash = oostruct_hash;
object_class->getslot = oostruct_getslot;
object_class->setslot = oostruct_setslot;
class_define("object", object_class);
dx_define("allslots", xallslots);
dx_define("slots",xslots);
dx_define("super",xsuper);
dx_define("subclasses",xsubclasses);
dx_define("methods",xmethods);
dx_define("classname",xclassname);
dy_define("classof", yclassof);
dx_define("isa",xisa);
dx_define("emptyp",xemptyp);
dx_define("make-class",xmake_class);
dx_define("builtin-class-p",xbuiltin_class_p);
dy_define("new",ynew);
dx_define("new-empty",xnew_empty);
dx_define("delete",xdelete);
dy_define("with-object",ywith_object);
dx_define("getmethod",xgetmethod);
dx_define("putmethod",xputmethod);
dy_define("send",ysend);
dx_define("sender",xsender);
at_this = var_define("this");
at_progn = var_define("progn");
at_destroy = var_define("-destructor");
at_listeval = var_define("-listeval");
at_emptyp = var_define("-emptyp");
at_mexpand = var_define("macroexpand");
at_unknown = var_define("-unknown");
at_pname = var_define("pname");
}
void init_lbfgs_interface()
{
dx_define("lbfgs-params", xlbfgs_params);
dx_define("lbfgs", xlbfgs);
}
void
init_event(void)
{
/* EVENT QUEUE */
head = tail = cons(NIL,NIL);
protect(head);
/* EVENTS FUNCTION */
at_handle = var_define("handle");
dx_define("set-event-handler",xseteventhandler);
dx_define("process-pending-events",xprocess_pending_events);
dx_define("sendevent",xsendevent);
dx_define("testevent",xtestevent);
dx_define("checkevent",xcheckevent);
dx_define("waitevent",xwaitevent);
dx_define("eventinfo",xeventinfo);
/* TIMER FUNCTIONS */
dx_define("create-timer", xcreate_timer);
dx_define("create-timer-absolute", xcreate_timer_absolute);
dx_define("kill-timer", xkill_timer);
dx_define("sleep", xsleep);
}
void
init_network(void)
{
/* Network Creation */
dx_define("alloc-net",xalloc_net);
dx_define("newneurons",xnewneurons);
#ifndef NONEURTYPE
dx_define("set-neurtype-regular", xset_neurtype_regular);
dx_define("get-neurtype", xget_neurtype);
#endif
dx_define("clear_net",xclear_net);
dx_define("connect",xconnect);
dx_define("cut-connection", xcut_connection);
#ifdef ITERATIVE
dx_define("dup-connection",xdup_connection);
#ifdef WMATRIX
w_matrix_var = var_define("weight_matrix");
#endif
#endif
/* Topology functions */
dx_define("amont",xamont);
dx_define("aval",xaval);
/* File functions */
dx_define("save-net/merge",xsave_net);
dx_define("save-ascii-net/merge",xsave_ascii_net);
dx_define("merge-net",xmerge_net);
/* Network to matrix transferts */
dx_define("weight-to-matrix",xweight_to_matrix);
dx_define("matrix-to-weight",xmatrix_to_weight);
#ifdef ITERATIVE
dx_define("acc-to-matrix",xacc_to_matrix);
dx_define("matrix-to-acc",xmatrix_to_acc);
dx_define("delta-to-matrix",xdelta_to_matrix);
dx_define("matrix-to-delta",xmatrix_to_delta);
#ifdef NEWTON
dx_define("hess-to-matrix",xhess_to_matrix);
dx_define("matrix-to-hess",xmatrix_to_hess);
#endif
#endif
}
void init_storage()
{
assert(ST_FIRST==0);
assert(sizeof(char)==sizeof(uchar));
#ifdef HAVE_MMAP
size_t storage_size = offsetof(storage_t, mmap_addr);
#else
size_t storage_size = sizeof(storage_t);
#endif
mt_storage = MM_REGTYPE("storage", storage_size,
clear_storage, mark_storage, 0);
/* set up storage_classes */
abstract_storage_class = new_builtin_class(NIL);
class_define("storage", abstract_storage_class);
Generic_storage_class_init(ST_BOOL, Bool);
Generic_storage_class_init(ST_AT, Atom);
Generic_storage_class_init(ST_FLOAT, Float);
Generic_storage_class_init(ST_DOUBLE, Double);
Generic_storage_class_init(ST_INT, Int);
Generic_storage_class_init(ST_SHORT, Short);
Generic_storage_class_init(ST_CHAR, Char);
Generic_storage_class_init(ST_UCHAR, UChar);
Generic_storage_class_init(ST_GPTR, Gptr);
Generic_storage_class_init(ST_MPTR, Mptr);
at *p = var_define("storage-classes");
at *l = NIL;
for (storage_type_t st=ST_FIRST; st<ST_LAST; st++)
l = new_cons(storage_class[st]->backptr, l);
var_set(p, reverse(l));
var_lock(p);
dx_define("new-storage", xnew_storage);
dx_define("new-storage/managed", xnew_storage_managed);
dx_define("new-storage/foreign", xnew_storage_foreign);
#ifdef HAVE_MMAP
dx_define("new-storage/mmap",xnew_storage_mmap);
#endif
dx_define("storage-alloc",xstorage_alloc);
dx_define("storage-realloc",xstorage_realloc);
dx_define("storage-clear",xstorage_clear);
dx_define("storagep",xstoragep);
dx_define("storage-readonlyp",xstorage_readonlyp);
dx_define("storage-set-readonly", xstorage_set_readonly);
dx_define("storage-load",xstorage_load);
dx_define("storage-save",xstorage_save);
dx_define("storage-nelems",xstorage_nelems);
dx_define("storage-nbytes",xstorage_nbytes);
}
void init_dump(void)
{
dx_define("dump", xdump);
}
void
init_gbp(void)
{
dx_define("update-weighted-sum",xupdate_weighted_sum);
dx_define("update-state-only",xupdate_state_only);
dx_define("update-state",xupdate_state);
dx_define("update-back-sum",xupdate_back_sum);
dx_define("update-gradient-only",xupdate_gradient_only);
dx_define("update-gradient",xupdate_gradient);
dx_define("update-deltastate",xupdate_deltastate);
dx_define("init-grad-lms",xinit_grad_lms);
dx_define("init-grad-thlms",xinit_grad_thlms);
#ifdef NEWTON
dx_define("update-ggradient",xupdate_ggradient);
dx_define("update-lmggradient",xupdate_lmggradient);
dx_define("update-w-newton",xupdate_w_newton);
#endif
dx_define("update-weight",xupdate_weight);
#ifdef ITERATIVE
dx_define("clear-acc",xclear_acc);
dx_define("update-acc",xupdate_acc);
#ifdef NEWTON
dx_define("clear-hess",xclear_hess);
dx_define("update-hess",xupdate_hess);
dx_define("hessian-scale",xhessian_scale);
#endif
dx_define("update-delta",xupdate_delta);
dx_define("update-wghtonly",xupdate_wghtonly);
dx_define("update-wghtonly-conjgrad",xupdate_wghtonly_conjgrad);
#endif
}
void init_event(void)
{
mt_event_timer =
MM_REGTYPE("event_timer", sizeof(event_timer_t),
clear_event_timer, mark_event_timer, 0);
MM_ROOT(timers);
/* set up event queue */
MM_ROOT(head);
head = tail = new_cons(NIL, NIL);
/* EVENTS FUNCTION */
at_handle = var_define("handle");
dx_define("set-event-handler", xseteventhandler);
dx_define("process-pending-events", xprocess_pending_events);
dx_define("sendevent", xsendevent);
dx_define("testevent", xtestevent);
dx_define("checkevent", xcheckevent);
dx_define("waitevent", xwaitevent);
dx_define("eventinfo", xeventinfo);
/* TIMER FUNCTIONS */
dx_define("create-timer", xcreate_timer);
dx_define("create-timer-absolute", xcreate_timer_absolute);
dx_define("kill-timer", xkill_timer);
dx_define("sleep", xsleep);
}
void init_interf(void)
{
dx_define("nfanin",xnfanin);
dx_define("nfield",xnfield);
dx_define("nval",xnval);
dx_define("nsum",xnsum);
dx_define("ngrad",xngrad);
dx_define("nbacksum",xnbacksum);
dx_define("nepsilon",xnepsilon);
#ifdef DESIRED
dx_define("ndesired",xndesired);
dx_define("nfreedom",xnfreedom);
#endif
#ifdef NEWTON
dx_define("nggrad",xnggrad);
dx_define("nsqbacksum",xnsqbacksum);
dx_define("nsigma",xnsigma);
#endif
#ifndef NOSPARE
dx_define("nspare",xnspare);
dx_define("nspare1",xnspare1);
dx_define("nspare2",xnspare2);
dx_define("nspare3",xnspare3);
#endif
dx_define("sval",xsval);
dx_define("sdelta",xsdelta);
dx_define("mean-sqr-weight",xweight_sqr_mean);
dx_define("mean-sqr-delta",xdelta_sqr_mean);
#ifdef SYNEPSILON
dx_define("sepsilon",xsepsilon);
#ifdef NEWTON
dx_define("ssigma",xssigma);
#endif
#endif
#ifdef ITERATIVE
dx_define("scounter",xscounter);
dx_define("sacc",xsacc);
dx_define("sindex",xsindex);
#ifdef NEWTON
dx_define("shess",xshess);
#endif
#endif
}
