minteg *mk_minteg(
double (*h)(double parameter,double constant,double x),
double (*compute_constant)(double parameter),
double (*xlo)(double parameter,double constant),
double (*xhi)(double parameter,double constant),
double parameter_lo,
double parameter_hi,
int integ_array_size,
int integ_size
)
{
minteg *mit = AM_MALLOC(minteg);
int i;
mit -> integ_array_size = integ_array_size;
mit -> integ_size = integ_size;
mit -> h = h;
mit -> compute_constant = compute_constant;
mit -> xlo = xlo;
mit -> xhi = xhi;
mit -> parameter_lo = parameter_lo;
mit -> parameter_hi = parameter_hi;
mit -> integ_array = AM_MALLOC_ARRAY(integ_ptr,integ_array_size);
for ( i = 0 ; i < integ_array_size ; i++ )
mit -> integ_array[i] = NULL;
return(mit);
}
lr_predict *mk_in_lr_predict( PFILE *f)
{
int i, size;
double val;
dyv *dv, *b;
lr_predict *lrp;
lrp = AM_MALLOC( lr_predict);
dv = mk_dyv_read( f);
size = dyv_size( dv);
lrp->b0 = dyv_ref( dv, 0);
b = mk_dyv( size-1);
for (i=1; i<size; ++i) {
val = dyv_ref( dv, i);
dyv_set( b, i-1, val);
}
lrp->b = b;
free_dyv( dv);
return lrp;
}
lr_predict *mk_lr_predict( double b0, dyv *b)
{
lr_predict *lrp;
lrp = AM_MALLOC( lr_predict);
lrp->b0 = b0;
lrp->b = mk_copy_dyv( b);
return lrp;
}
lr_statearr *mk_array_of_null_lr_states( int size)
{
int i;
lr_statearr *lrsarr;
lrsarr = AM_MALLOC( lr_statearr);
lrsarr->size = size;
lrsarr->arr = AM_MALLOC_ARRAY( lr_state *, size);
for (i=0; i<size; ++i) lrsarr->arr[i] = NULL;
return lrsarr;
}
/* number of elements you want to add. */
dyv *mk_empty_dyv(int capacity) {
dyv *result = AM_MALLOC(dyv);
if ( capacity < 0 ) my_error("mk_empty_ivec : capacity < 0 illegal");
result -> dyv_code = DYV_CODE;
result -> array_size = capacity;
result -> size = 0;
result -> farr = am_malloc_realnums(capacity);
Dyvs_mallocked += 1;
return(result);
}
dyv *mk_dyv(int size)
{
dyv *result = AM_MALLOC(dyv);
result -> dyv_code = DYV_CODE;
result -> array_size = size;
result -> size = size;
result -> farr = am_malloc_realnums(size);
Dyvs_mallocked += 1;
return(result);
}
string_array *mk_string_array(int size)
{
string_array *result = AM_MALLOC(string_array);
int i;
result -> string_array_code = STRING_ARRAY_CODE;
result -> size = size;
result -> sarr_size = size;
result -> sarr = AM_MALLOC_ARRAY(char_ptr,size);
for ( i = 0 ; i < size ; i++ )
result->sarr[i] = mk_copy_string("<UnDeFiNeD>");
String_Arrays_mallocked += 1;
return(result);
}
integ *mk_integ(
double (*h)(double parameter,double constant,double x),
double xlo,
double xhi,
double parameter,
double constant,
int size
)
/*
Returns an it in which
it->integral[i] = integal_from_xlo_to(x_lo + h*i) of h(parameter,x) dx
------------------------------------------------
integal_from_xlo_to_x_hi of h(parameter,x) dx
*/
{
integ *it = AM_MALLOC(integ);
dyv *dig = mk_dyv(size);
int i;
double sum = 0.0;
double last_pdf = 0.0;
double delta = (xhi - xlo) / (size-1);
if ( h(parameter,constant,xhi) > 1e-6 )
my_error("Hmm... I was really hoping h(parameter,xhi) == 0");
dyv_set(dig,0,0.0);
for ( i = 1 ; i < size ; i++ )
{
double x = xlo + i * delta;
double this_pdf = h(parameter,constant,x);
if (i == 1) sum += delta * this_pdf;
else sum += delta * (this_pdf + last_pdf) / 2.0;
dyv_set(dig,i,sum);
last_pdf = this_pdf; /* added 2/26/97 JGS */
}
dyv_scalar_mult(dig,1.0 / sum,dig);
it -> integral = dig;
it -> xlo = xlo;
it -> xhi = xhi;
it -> parameter = parameter;
it -> constant = constant;
return(it);
}
lr_options *mk_copy_lr_options( lr_options *opts)
{
lr_options *newopts;
newopts = AM_MALLOC( lr_options);
newopts->rrlambda = opts->rrlambda;
newopts->lreps = opts->lreps;
newopts->lrmax = opts->lrmax;
newopts->cgbinit = opts->cgbinit;
newopts->cgdeveps = opts->cgdeveps;
newopts->cgeps = opts->cgeps;
newopts->cgmax = opts->cgmax;
newopts->cgwindow = opts->cgwindow;
newopts->cgdecay = opts->cgdecay;
return newopts;
}
lr_state *mk_copy_lr_state( lr_state *lrs)
{
lr_state *lrscopy;
lrscopy = AM_MALLOC( lr_state);
lrscopy->b0 = lrs->b0;
lrscopy->b = mk_copy_dyv( lrs->b);
lrscopy->n = mk_copy_dyv( lrs->n);
lrscopy->u = mk_copy_dyv( lrs->u);
lrscopy->w = mk_copy_dyv( lrs->w);
lrscopy->z = mk_copy_dyv( lrs->z);
lrscopy->converged = lrs->converged;
return lrscopy;
}
lr_state *mk_lr_state( lr_train *lrt, lr_options *opts)
{
lr_state *lrs;
lrs = AM_MALLOC( lr_state);
lrs->b0 = 0.0;
lrs->b = mk_zero_dyv(lrt->numatts-1);
lrs->n = mk_zero_dyv(lrt->numrows);
lrs->u = mk_zero_dyv(lrt->numrows);
lrs->w = mk_zero_dyv(lrt->numrows);
lrs->z = mk_zero_dyv(lrt->numrows);
lrs->converged = 0;
return lrs;
}
generic_array *mk_empty_generic_array(
void (*free_data)(void *data),
void * (*mk_copy_data)(void *data),
void (*fprintf_data)(FILE *s,char *m1,void *data,char *m2) /* May be NULL */
)
{
generic_array *ga = AM_MALLOC(generic_array);
ga -> size = 0;
ga -> array_size = INITIAL_GENERIC_ARRAY_SIZE;
ga -> array = AM_MALLOC_ARRAY(void *,ga->array_size);
ga -> free_data = free_data;
ga -> mk_copy_data = mk_copy_data;
ga -> fprintf_data = fprintf_data;
return(ga);
}
lr_train *mk_copy_lr_train( const lr_train *source)
{
lr_train *dest;
dest = AM_MALLOC(lr_train);
dest->opts = mk_copy_lr_options( source->opts);
/* Don't copy spardat or factors dym. Just keep pointer. */
dest->X = source->X;
dest->M = source->M;
dest->numatts = source->numatts;
dest->numrows = source->numrows;
dest->y = mk_copy_dyv(source->y);
dest->likesat = source->likesat;
dest->lrs = mk_copy_lr_state( source->lrs);
return dest;
}
lr_train *mk_lr_train_from_dym( dym *factors, dyv *outputs, lr_options *opts)
{
/* Set rows to NULL if you want all rows from ds to be used. */
int numrows, numatts;
lr_train *lrt;
numrows = dym_rows( factors);
numatts = dym_cols( factors)+1; /* Number of factors including constant. */
/* Create lr lrt structure. */
lrt = AM_MALLOC(lr_train);
/* Copy in opts. */
lrt->opts = mk_copy_lr_options( opts);
/* Assign factors and outputs into lr structure. */
lrt->X = NULL;
lrt->M = factors;
/* Outputs. */
lrt->y = mk_copy_dyv( outputs);
if (!dyv_is_binary( outputs)) {
my_error( "mk_lr_train: Error: outputs are not binary.\n");
}
/* Set log likelihood of saturated model. */
lrt->likesat = 0.0;
/* Initialize remainder of lr struct */
lrt->numatts = numatts;
lrt->numrows = numrows;
/* Create lr_state member. */
lrt->lrs = mk_lr_state( lrt, opts);
/* Now that the structure is complete, update n and u to prepare for
iterations. */
lr_train_update_n(lrt);
lr_train_update_u(lrt);
return lrt;
}
lr_options *mk_lr_options(void)
{
lr_options *opts;
opts = AM_MALLOC( lr_options);
/* Options which are always available. */
opts->rrlambda = 10.0;
/* Termination criteria for lr iterations. */
opts->lreps = 0.05;
opts->lrmax = 30;
/* cg options are available in conjuagate gradient runs. */
opts->cgbinit = 1;
opts->cgdeveps = 0.005; /* suggestion: 0.005 */
opts->cgeps = 0.000; /* multiplied by initial CG rsqr. */
opts->cgmax = 200;
opts->cgwindow = 3; /* Number of bad iterations allowed. */
opts->cgdecay = 1000.0; /* Factor worse than best-seen that is allowed. */
return opts;
}
lr_train *mk_lr_train_from_spardat( spardat *X, lr_options *opts)
{
/* Copies spardat X. */
int numrows, numatts;
lr_train *lrt;
numrows = spardat_num_rows(X);
numatts = spardat_num_atts(X)+1; /* Add 1 for constant att. */
lrt = AM_MALLOC(lr_train);
/* Copy in opts. */
lrt->opts = mk_copy_lr_options( opts);
/* Do not make a copy of the caller's spardat; too expensive. */
lrt->X = X;
lrt->M = NULL;
/* Initialize reaminder of lr struct */
lrt->numatts = numatts;
lrt->numrows = numrows;
/* Futz with 0-1 probabilities. */
lrt->y = mk_dyv_from_ivec( X->row_to_outval);
/* Set log likelihood of saturated model. */
lrt->likesat = 0.0;
/* Make lr_state member. */
lrt->lrs = mk_lr_state( lrt, opts);
/* Now that the structure is complete, update n and u to prepare for
iterations. */
lr_train_update_n(lrt);
lr_train_update_u(lrt);
return lrt;
}
