/*--------------------------------------------------------------------------*/
fint hov_forward_(fint* ftag,
fint* fm,
fint* fn,
fint* fd,
fint* fp,
fdouble* fbase,
fdouble* fx,
fdouble* fvalue,
fdouble* fy) {
int rc= -1;
int tag=*ftag, m=*fm, n=*fn, d=*fd, p=*fp;
double* base = myalloc1(n);
double* value = myalloc1(m);
double*** X = myalloc3(n,p,d);
double*** Y = myalloc3(m,p,d);
spread1(n,fbase,base);
spread3(n,p,d,fx,X);
rc= hov_forward(tag,m,n,d,p,base,X,value,Y);
pack3(m,p,d,Y,fy);
pack1(m,value,fvalue);
free((char*)**X);
free((char*)*X);
free((char*)X);
free((char*)**Y);
free((char*)*Y);
free((char*)Y);
free((char*)base);
free((char*)value);
return rc;
}
BEGIN_C_DECLS
/*--------------------------------------------------------------------------*/
fint hos_forward_(fint* ftag,
fint* fm,
fint* fn,
fint* fd,
fint* fk,
fdouble* fbase,
fdouble* fx,
fdouble* fvalue,
fdouble* fy) {
int rc= -1;
int tag=*ftag, m=*fm, n=*fn, d=*fd, k=*fk;
double* base = myalloc1(n);
double* value = myalloc1(m);
double** X = myalloc2(n,d);
double** Y = myalloc2(m,d);
spread1(n,fbase,base);
spread2(n,d,fx,X);
rc= hos_forward(tag,m,n,d,k,base,X,value,Y);
pack2(m,d,Y,fy);
pack1(m,value,fvalue);
free((char*)*X);
free((char*)X);
free((char*)*Y);
free((char*)Y);
free((char*)base);
free((char*)value);
return rc;
}
gui::ImageSpace::ImageSpace() {
set_border_width(BORDER_WIDTH);
originalImage_.set_label("Original Image");
currentImage_.set_label("Current Image");
pack1(originalImage_, false, false);
pack2(currentImage_, false, false);
show_all_children();
}
JPaned::JPaned(){
drawing = new Gtk::DrawingArea();
playerlist = new PlayerList();
drawing->override_background_color(
Gdk::RGBA("BLACK"), Gtk::STATE_FLAG_NORMAL);
pack1(*drawing, Gtk::EXPAND);
pack2(*playerlist, Gtk::FILL);
show_all();
drawing->add_events(Gdk::POINTER_MOTION_MASK);
drawing->signal_motion_notify_event().connect(
sigc::mem_fun(*this, &JPaned::motion));}
/* gradient(tag, n, x[n], g[n]) */
fint gradient_(fint* ftag,
fint* fn,
fdouble* fargument,
fdouble* fresult) {
int rc= -1;
int tag=*ftag, n=*fn;
double* argument=myalloc1(n);
double* result=myalloc1(n);
spread1(n,fargument,argument);
rc= gradient(tag,n,argument,result);
pack1(n,result,fresult);
free((char*)result);
free((char*)argument);
return rc;
}
int main(int argc, char*argv[]){
string filename;
if(argc == 2)
filename = argv[1];
else{
cout << "usage | pack_creator filename \n";
exit(1);
}
pack pack1(filename);
for(int i=0; i<6; i++){
pack1.new_pack();
cout << "--Pack " << i+1 << "--\n";
pack1.print_pack();
}
}
/*--------------------------------------------------------------------------*/
fint fos_reverse_(fint* ftag,
fint* fm,
fint* fn,
fdouble* fu,
fdouble* fz) {
int rc=-1;
int tag=*ftag, m=*fm, n=*fn;
double* u = myalloc1(m);
double* Z = myalloc1(n);
spread1(m,fu,u);
rc=fos_reverse(tag,m,n,u,Z);
pack1(n,Z,fz);
free((char*)Z);
free((char*)u);
return rc;
}
/*--------------------------------------------------------------------------*/
fint zos_forward_(fint* ftag,
fint* fm,
fint* fn,
fint* fk,
fdouble* fbase,
fdouble* fvalue) {
int rc=-1;
int tag=*ftag, m=*fm, n=*fn, k=*fk;
double* base=myalloc1(n);
double* value = myalloc1(m);
spread1(n,fbase,base);
rc=zos_forward(tag,m,n,k,base,value);
pack1(m,value,fvalue);
free((char*)base);
free((char*)value);
return rc;
}
void PackUnix::pack(OutputFile *fo)
{
Filter ft(ph.level);
ft.addvalue = 0;
b_len = 0;
progid = 0;
// set options
blocksize = opt->o_unix.blocksize;
if (blocksize <= 0)
blocksize = BLOCKSIZE;
if ((off_t)blocksize > file_size)
blocksize = file_size;
// init compression buffers
ibuf.alloc(blocksize);
obuf.allocForCompression(blocksize);
fi->seek(0, SEEK_SET);
pack1(fo, ft); // generate Elf header, etc.
p_info hbuf;
set_te32(&hbuf.p_progid, progid);
set_te32(&hbuf.p_filesize, file_size);
set_te32(&hbuf.p_blocksize, blocksize);
fo->write(&hbuf, sizeof(hbuf));
// append the compressed body
if (pack2(fo, ft)) {
// write block end marker (uncompressed size 0)
b_info hdr; memset(&hdr, 0, sizeof(hdr));
set_le32(&hdr.sz_cpr, UPX_MAGIC_LE32);
fo->write(&hdr, sizeof(hdr));
}
pack3(fo, ft); // append loader
pack4(fo, ft); // append PackHeader and overlay_offset; update Elf header
// finally check the compression ratio
if (!checkFinalCompressionRatio(fo))
throwNotCompressible();
}
/* hess_vec(tag, n, x[n], v[n], w[n]) */
fint hess_vec_(fint* ftag,
fint* fn,
fdouble *fargument,
fdouble *ftangent,
fdouble *fresult) {
int rc= -1;
int tag=*ftag, n=*fn;
double *argument = myalloc1(n);
double *tangent = myalloc1(n);
double *result = myalloc1(n);
spread1(n,fargument,argument);
spread1(n,ftangent,tangent);
rc= hess_vec(tag,n,argument,tangent,result);
pack1(n,result,fresult);
free((char*)argument);
free((char*)tangent);
free((char*)result);
return rc;
}
/* jac_vec(tag, m, n, x[n], v[n], u[m]); */
fint jac_vec_(fint* ftag,
fint* fm,
fint* fn,
fdouble* fargument,
fdouble* ftangent,
fdouble* fcolumn) {
int rc= -1;
int tag=*ftag, m=*fm, n=*fn;
double* argument = myalloc1(n);
double* tangent = myalloc1(n);
double* column = myalloc1(m);
spread1(n,ftangent,tangent);
spread1(n,fargument,argument);
rc= jac_vec(tag,m,n,argument,tangent,column);
pack1(m,column,fcolumn);
free((char*)argument);
free((char*)tangent);
free((char*)column);
return rc;
}
/* vec_jac(tag, m, n, repeat, x[n], u[m], v[n]) */
fint vec_jac_(fint* ftag,
fint* fm,
fint* fn,
fint* frepeat,
fdouble* fargument,
fdouble* flagrange,
fdouble* frow) {
int rc= -1;
int tag=*ftag, m=*fm, n=*fn, repeat=*frepeat;
double* argument = myalloc1(n);
double* lagrange = myalloc1(m);
double* row = myalloc1(n);
spread1(m,flagrange,lagrange);
spread1(n,fargument,argument);
rc= vec_jac(tag,m,n,repeat,argument,lagrange, row);
pack1(n,row,frow);
free((char*)argument);
free((char*)lagrange);
free((char*)row);
return rc;
}
BEGIN_C_DECLS
/****************************************************************************/
/* DRIVERS FOR OPTIMIZATION AND NONLINEAR EQUATIONS */
/*--------------------------------------------------------------------------*/
/* function */
/* function(tag, m, n, x[n], y[m]) */
fint function_(fint* ftag,
fint* fm,
fint* fn,
fdouble* fargument,
fdouble* fresult) {
int rc= -1;
int tag=*ftag, m=*fm, n=*fn;
double* argument = myalloc1(n);
double* result = myalloc1(m);
spread1(n,fargument,argument);
rc= function(tag,m,n,argument,result);
pack1(m,result,fresult);
free((char*)argument);
free((char*)result);
return rc;
}
/* lagra_hess_vec(tag, m, n, x[n], v[n], u[m], w[n]) */
fint lagra_hess_vec_(fint* ftag,
fint* fm,
fint* fn,
fdouble *fargument,
fdouble *ftangent,
fdouble *flagrange,
fdouble *fresult) {
int rc=-1;
int tag=*ftag, m=*fm, n=*fn;
double *argument = myalloc1(n);
double *tangent = myalloc1(n);
double *lagrange = myalloc1(m);
double *result = myalloc1(n);
spread1(n,fargument,argument);
spread1(n,ftangent,tangent);
spread1(m,flagrange,lagrange);
rc= lagra_hess_vec(tag,m,n,argument,tangent,lagrange,result);
pack1(n,result,fresult);
free((char*)argument);
free((char*)tangent);
free((char*)lagrange);
free((char*)result);
return rc;
}
