int write_member_points_sc(vec_mp point_to_write)
{
FILE *OUT = NULL;
int ii;
remove("member_points");
OUT = safe_fopen_write("member_points");
vec_mp result;
init_vec_mp(result,0);
dehomogenize(&result,point_to_write);
fprintf(OUT,"2\n\n");
for(ii=0;ii<result->size;ii++)
{
print_mp(OUT,0,&result->coord[ii]); fprintf(OUT,"\n");
}
comp_mp temp; init_mp(temp);
fprintf(OUT,"\n");
for(ii=0;ii<result->size;ii++)
{
conjugate_mp(temp, &result->coord[ii]);
print_mp(OUT,0,temp); fprintf(OUT,"\n");
}
fclose(OUT);
clear_vec_mp(result); clear_mp(temp);
return 0;
}
void init()
{
T_ = NULL;
same_point_tolerance_ = 1e-5;
num_projections_ = 0;
projections_ = NULL;
curr_projection_ = -1;
curr_input_index_ = -2;
this->num_vertices_ = 0;
this->num_natural_variables_ = 0;
init_vec_mp(checker_1_,0);
init_vec_mp(checker_2_,0);
init_mp(this->diff_);
mpf_init(abs_);
mpf_init(zerothresh_);
mpf_set_d(zerothresh_, 1e-8);
}
void mshowfat(int argc, char **argv, int mtype)
{
Arg_t arg;
int c, ret;
/* get command line options */
init_clash_handling(& arg.ch);
/* get command line options */
while ((c = getopt(argc, argv, "")) != EOF) {
switch (c) {
case '?':
usage();
break;
}
}
if (argc - optind < 1)
usage();
/* only 1 file to copy... */
init_mp(&arg.mp);
arg.mp.arg = (void *) &arg;
arg.mp.callback = dos_showfat;
arg.mp.unixcallback = unix_showfat;
arg.mp.lookupflags = ACCEPT_PLAIN | ACCEPT_DIR | DO_OPEN;
ret=main_loop(&arg.mp, argv + optind, argc - optind);
exit(ret);
}
void mshortname(int argc, char **argv, int type)
{
struct MainParam_t mp;
int c;
if(helpFlag(argc, argv))
usage(0);
while ((c = getopt(argc, argv, "i:h")) != EOF) {
switch (c) {
case 'i':
set_cmd_line_image(optarg);
break;
case 'h':
usage(0);
case '?':
usage(1);
}
}
if(optind == argc) {
usage(0);
}
if (optind >= argc)
usage(1);
init_mp(&mp);
mp.callback = print_short_name;
mp.arg = NULL;
mp.lookupflags = ACCEPT_PLAIN | ACCEPT_DIR;
exit(main_loop(&mp, argv + optind, argc - optind));
}
void mdel(int argc, char **argv, int deltype)
{
Arg_t arg;
MainParam_t mp;
int c,i;
arg.verbose = 0;
if(helpFlag(argc, argv))
usage(0);
while ((c = getopt(argc, argv, "i:vh")) != EOF) {
switch (c) {
case 'i':
set_cmd_line_image(optarg);
break;
case 'v':
arg.verbose = 1;
break;
case 'h':
usage(0);
default:
usage(1);
}
}
if(argc == optind)
usage(1);
init_mp(&mp);
mp.callback = del_file;
mp.arg = (void *) &arg;
mp.openflags = O_RDWR;
arg.deltype = deltype;
switch(deltype){
case 0:
mp.lookupflags = ACCEPT_PLAIN; /* mdel */
break;
case 1:
mp.lookupflags = ACCEPT_DIR; /* mrd */
break;
case 2:
mp.lookupflags = ACCEPT_DIR | ACCEPT_PLAIN; /* mdeltree */
break;
}
mp.lookupflags |= NO_DOTS;
for(i=optind;i<argc;i++) {
int b,l;
if(argv[i][0] && argv[i][1] == ':')
b = 2;
else
b = 0;
l = strlen(argv[i]+b);
if(l > 1 && argv[i][b+l-1] == '/')
argv[i][b+l-1] = '\0';
}
exit(main_loop(&mp, argv + optind, argc - optind));
}
void sphere_eval_data_mp::init()
{
this->is_solution_checker_d = &check_issoln_sphere_d;
this->is_solution_checker_mp = &check_issoln_sphere_mp;
this->evaluator_function_d = &sphere_eval_d;
this->evaluator_function_mp = &sphere_eval_mp;
this->precision_changer = &change_sphere_eval_prec;
this->dehomogenizer = &sphere_dehom;
this->num_static_linears = 0; // we will copy these out of the witness set.
static_linear = static_linear_full_prec = NULL;
starting_linear = (vec_mp *) br_malloc(2*sizeof(vec_mp));;
for (int ii=0; ii<2; ii++) {
init_vec_mp(starting_linear[ii],0);
}
init_vec_mp(center, 0);
init_mp(radius);
if (MPType==2) {
init_vec_mp2(center_full_prec,0,1024);
init_mp2(radius_full_prec,1024);
starting_linear_full_prec = (vec_mp *) br_malloc(2*sizeof(vec_mp));
for (int ii=0; ii<2; ii++) {
init_vec_mp2(starting_linear_full_prec[ii],0,1024);
}
init_mp2(two_full_prec,1024);
set_zero_mp(two_full_prec);
mpf_set_str(two_full_prec->r, "2.0", 10);
}
init_mp(two);
set_zero_mp(two);
mpf_set_str(two->r, "2.0", 10);
num_natural_vars = 0;
}
void cstart()
{
disp_str("cstart begin\n");
// init_gdt();
// init_8259A();
// init_idt();
cpu_info();
cpuid(1);
disp_int(rdmsr(0x1B));disp_str("\n");
init_mp();
disp_str("cstart finish\n");
while(1);
}
void mmd(int argc, char **argv, int type)
{
Arg_t arg;
int c;
/* get command line options */
init_clash_handling(& arg.ch);
/* get command line options */
if(helpFlag(argc, argv))
usage(0);
while ((c = getopt(argc, argv, "i:D:oh")) != EOF) {
switch (c) {
case 'i':
set_cmd_line_image(optarg);
break;
case '?':
usage(1);
case 'o':
handle_clash_options(&arg.ch, c);
break;
case 'D':
if(handle_clash_options(&arg.ch, *optarg))
usage(1);
break;
case 'h':
usage(0);
default:
usage(1);
break;
}
}
if (argc - optind < 1)
usage(1);
init_mp(&arg.mp);
arg.mp.arg = (void *) &arg;
arg.mp.openflags = O_RDWR;
arg.mp.callback = createDirCallback;
arg.mp.lookupflags = OPEN_PARENT | DO_OPEN_DIRS;
exit(main_loop(&arg.mp, argv + optind, argc - optind));
}
void mcd(int argc, char **argv, int type)
{
struct MainParam_t mp;
if (argc > 2) {
fprintf(stderr, "Mtools version %s, dated %s\n",
mversion, mdate);
fprintf(stderr, "Usage: %s: [-V] msdosdirectory\n", argv[0]);
exit(1);
}
init_mp(&mp);
mp.lookupflags = ACCEPT_DIR | NO_DOTS;
mp.dirCallback = mcd_callback;
if (argc == 1) {
printf("%s\n", mp.mcwd);
exit(0);
} else
exit(main_loop(&mp, argv + 1, 1));
}
void mdu(int argc, char **argv, int type)
{
Arg_t arg;
int c;
arg.all = 0;
arg.inDir = 0;
arg.summary = 0;
while ((c = getopt(argc, argv, "as")) != EOF) {
switch (c) {
case 'a':
arg.all = 1;
break;
case 's':
arg.summary = 1;
break;
case '?':
usage();
}
}
if (optind >= argc)
usage();
if(arg.summary && arg.all) {
fprintf(stderr,"-a and -s options are mutually exclusive\n");
usage();
}
init_mp(&arg.mp);
arg.mp.callback = file_mdu;
arg.mp.openflags = O_RDONLY;
arg.mp.dirCallback = dir_mdu;
arg.mp.arg = (void *) &arg;
arg.mp.lookupflags = ACCEPT_PLAIN | ACCEPT_DIR | DO_OPEN_DIRS | NO_DOTS;
exit(main_loop(&arg.mp, argv + optind, argc - optind));
}
void mdir(int argc, char **argv, int type)
{
int ret;
MainParam_t mp;
int faked;
int c;
const char *fakedArgv[] = { "." };
concise = 0;
recursive = 0;
wide = all = 0;
/* first argument */
if(helpFlag(argc, argv))
usage(0);
while ((c = getopt(argc, argv, "i:waXbfds/h")) != EOF) {
switch(c) {
case 'i':
set_cmd_line_image(optarg, 0);
break;
case 'w':
wide = 1;
break;
case 'a':
all = 1;
break;
case 'b':
case 'X':
concise = 1;
/*recursive = 1;*/
break;
case 's':
case '/':
recursive = 1;
break;
case 'f':
fast = 1;
break;
case 'd':
debug = 1;
break;
#if 0
case 't': /* test mode */
testmode = 1;
break;
#endif
case 'h':
usage(0);
default:
usage(1);
}
}
/* fake an argument */
faked = 0;
if (optind == argc) {
argv = (char **)fakedArgv;
argc = 1;
optind = 0;
}
init_mp(&mp);
currentDrive = '\0';
currentDir = 0;
RootDir = 0;
dirPath = 0;
#if 0
if (testmode) {
mp.lookupflags = ACCEPT_DIR | NO_DOTS;
mp.dirCallback = test_directory;
} else
#endif
if(recursive) {
mp.lookupflags = ACCEPT_DIR | DO_OPEN_DIRS | NO_DOTS;
mp.dirCallback = list_recurs_directory;
} else {
mp.lookupflags = ACCEPT_DIR | ACCEPT_PLAIN | DO_OPEN_DIRS;
mp.dirCallback = list_non_recurs_directory;
mp.callback = list_file;
}
mp.longname = global_longname;
mp.shortname = global_shortname;
ret=main_loop(&mp, argv + optind, argc - optind);
leaveDirectory(ret);
leaveDrive(ret);
exit(ret);
}
void mlabel(int argc, char **argv, int type)
{
char *newLabel;
int verbose, clear, interactive, show;
direntry_t entry;
int result=0;
char longname[VBUFSIZE];
char shortname[45];
ClashHandling_t ch;
struct MainParam_t mp;
Stream_t *RootDir;
int c;
int mangled;
enum { SER_NONE, SER_RANDOM, SER_SET } set_serial = SER_NONE;
long serial = 0;
int need_write_boot = 0;
int have_boot = 0;
char *eptr;
union bootsector boot;
Stream_t *Fs=0;
int r;
struct label_blk_t *labelBlock;
int isRo=0;
int *isRop=NULL;
init_clash_handling(&ch);
ch.name_converter = label_name;
ch.ignore_entry = -2;
verbose = 0;
clear = 0;
show = 0;
if(helpFlag(argc, argv))
usage(0);
while ((c = getopt(argc, argv, "i:vcsnN:h")) != EOF) {
switch (c) {
case 'i':
set_cmd_line_image(optarg, 0);
break;
case 'v':
verbose = 1;
break;
case 'c':
clear = 1;
break;
case 's':
show = 1;
break;
case 'n':
set_serial = SER_RANDOM;
srandom((long)time (0));
serial=random();
break;
case 'N':
set_serial = SER_SET;
serial = strtol(optarg, &eptr, 16);
if(*eptr) {
fprintf(stderr,
"%s not a valid serial number\n",
optarg);
exit(1);
}
break;
case 'h':
usage(0);
default:
usage(1);
}
}
if (argc - optind != 1 || !argv[optind][0] || argv[optind][1] != ':')
usage(1);
init_mp(&mp);
newLabel = argv[optind]+2;
if(strlen(newLabel) > VBUFSIZE) {
fprintf(stderr, "Label too long\n");
FREE(&RootDir);
exit(1);
}
interactive = !show && !clear &&!newLabel[0] &&
(set_serial == SER_NONE);
if(!clear && !newLabel[0]) {
isRop = &isRo;
}
RootDir = open_root_dir(argv[optind][0], isRop ? 0 : O_RDWR, isRop);
if(isRo) {
show = 1;
interactive = 0;
}
if(!RootDir) {
fprintf(stderr, "%s: Cannot initialize drive\n", argv[0]);
exit(1);
}
initializeDirentry(&entry, RootDir);
r=vfat_lookup(&entry, 0, 0, ACCEPT_LABEL | MATCH_ANY,
shortname, longname);
if (r == -2) {
FREE(&RootDir);
exit(1);
}
if(show || interactive){
if(isNotFound(&entry))
printf(" Volume has no label\n");
else if (*longname)
printf(" Volume label is %s (abbr=%s)\n",
longname, shortname);
else
printf(" Volume label is %s\n", shortname);
}
/* ask for new label */
if(interactive){
newLabel = longname;
fprintf(stderr,"Enter the new volume label : ");
if(fgets(newLabel, VBUFSIZE, stdin) == NULL) {
newLabel[0] = '\0';
fprintf(stderr, "\n");
}
if(newLabel[0])
newLabel[strlen(newLabel)-1] = '\0';
}
if((!show || newLabel[0]) && !isNotFound(&entry)){
/* if we have a label, wipe it out before putting new one */
if(interactive && newLabel[0] == '\0')
if(ask_confirmation("Delete volume label (y/n): ")){
FREE(&RootDir);
exit(0);
}
entry.dir.attr = 0; /* for old mlabel */
wipeEntry(&entry);
}
if (newLabel[0] != '\0') {
ch.ignore_entry = 1;
result = mwrite_one(RootDir,newLabel,0,labelit,NULL,&ch) ?
0 : 1;
}
have_boot = 0;
if( (!show || newLabel[0]) || set_serial != SER_NONE) {
Fs = GetFs(RootDir);
have_boot = (force_read(Fs,boot.characters,0,sizeof(boot)) ==
sizeof(boot));
}
if(WORD_S(fatlen)) {
labelBlock = &boot.boot.ext.old.labelBlock;
} else {
labelBlock = &boot.boot.ext.fat32.labelBlock;
}
if(!show || newLabel[0]){
dos_name_t dosname;
const char *shrtLabel;
doscp_t *cp;
if(!newLabel[0])
shrtLabel = "NO NAME ";
else
shrtLabel = newLabel;
cp = GET_DOSCONVERT(Fs);
label_name(cp, shrtLabel, verbose, &mangled, &dosname);
if(have_boot && boot.boot.descr >= 0xf0 &&
labelBlock->dos4 == 0x29) {
strncpy(labelBlock->label, dosname.base, 11);
need_write_boot = 1;
}
}
if((set_serial != SER_NONE) & have_boot) {
if(have_boot && boot.boot.descr >= 0xf0 &&
labelBlock->dos4 == 0x29) {
set_dword(labelBlock->serial, serial);
need_write_boot = 1;
}
}
if(need_write_boot) {
force_write(Fs, (char *)&boot, 0, sizeof(boot));
}
FREE(&RootDir);
exit(result);
}
void mbadblocks(int argc, char **argv, int type)
{
unsigned int i;
unsigned int startSector=2;
unsigned int endSector=0;
struct MainParam_t mp;
Fs_t *Fs;
Stream_t *Dir;
int ret;
char *filename = NULL;
char c;
unsigned int badClus;
int sectorMode=0;
int writeMode=0;
while ((c = getopt(argc, argv, "i:s:cwS:E:")) != EOF) {
switch(c) {
case 'i':
set_cmd_line_image(optarg, 0);
break;
case 'c':
checkListTwice(filename);
filename = strdup(optarg);
break;
case 's':
checkListTwice(filename);
filename = strdup(optarg);
sectorMode = 1;
break;
case 'S':
startSector = atol(optarg);
break;
case 'E':
endSector = atol(optarg);
break;
case 'w':
writeMode = 1;
break;
case 'h':
usage(0);
default:
usage(1);
}
}
if (argc != optind+1 ||
!argv[optind][0] || argv[optind][1] != ':' || argv[optind][2]) {
usage(1);
}
init_mp(&mp);
Dir = open_root_dir(argv[optind][0], O_RDWR, NULL);
if (!Dir) {
fprintf(stderr,"%s: Cannot initialize drive\n", argv[0]);
exit(1);
}
Fs = (Fs_t *)GetFs(Dir);
in_len = Fs->cluster_size * Fs->sector_size;
in_buf = malloc(in_len);
if(!in_buf) {
printOom();
ret = 1;
goto exit_0;
}
if(writeMode) {
int i;
pat_buf=malloc(in_len * N_PATTERN);
if(!pat_buf) {
printOom();
ret = 1;
goto exit_0;
}
srandom(time(NULL));
for(i=0; i < in_len * N_PATTERN; i++) {
pat_buf[i] = random();
}
}
for(i=0; i < Fs->clus_start; i++ ){
ret = READS(Fs->Next, in_buf,
sectorsToBytes((Stream_t*)Fs, i), Fs->sector_size);
if( ret < 0 ){
perror("early error");
goto exit_0;
}
if(ret < (signed int) Fs->sector_size){
fprintf(stderr,"end of file in file_read\n");
ret = 1;
goto exit_0;
}
}
ret = 0;
badClus = Fs->last_fat + 1;
if(startSector < 2)
startSector = 2;
if(endSector > Fs->num_clus + 2 || endSector <= 0)
endSector = Fs->num_clus + 2;
if(filename) {
char line[80];
FILE *f = fopen(filename, "r");
if(f == NULL) {
fprintf(stderr, "Could not open %s (%s)\n",
filename, strerror(errno));
ret = 1;
goto exit_0;
}
while(fgets(line, sizeof(line), f)) {
char *ptr = line + strspn(line, " \t");
long offset = strtoul(ptr, 0, 0);
if(sectorMode)
offset = (offset-Fs->clus_start)/Fs->cluster_size + 2;
if(offset < 2) {
fprintf(stderr, "Sector before start\n");
} else if(offset >= Fs->num_clus) {
fprintf(stderr, "Sector beyond end\n");
} else {
mark(Fs, offset, badClus);
ret = 1;
}
}
} else {
Stream_t *dev;
dev = Fs->Next;
if(dev->Next)
dev = dev->Next;
in_len = Fs->cluster_size * Fs->sector_size;
if(writeMode) {
/* Write pattern */
for(i=startSector; i< endSector; i++){
if(got_signal)
break;
progress(i, Fs->num_clus);
ret |= scan(Fs, dev, i, badClus,
pat_buf + in_len * (i % N_PATTERN),
1);
}
/* Flush cache, so that we are sure we read the data
back from disk, rather than from the cache */
if(!got_signal)
DISCARD(dev);
/* Read data back, and compare to pattern */
for(i=startSector; i< endSector; i++){
if(got_signal)
break;
progress(i, Fs->num_clus);
ret |= scan(Fs, dev, i, badClus,
pat_buf + in_len * (i % N_PATTERN),
0);
}
} else {
for(i=startSector; i< endSector; i++){
if(got_signal)
break;
progress(i, Fs->num_clus);
ret |= scan(Fs, dev, i, badClus, NULL, 0);
}
}
}
exit_0:
FREE(&Dir);
exit(ret);
}
void mcopy(int argc, char **argv, int mtype)
{
Arg_t arg;
int c, ret, fastquit;
int todir;
/* get command line options */
init_clash_handling(& arg.ch);
/* get command line options */
todir = 0;
arg.recursive = 0;
#ifdef OS_Minix
arg.preserveTime = 1; /* Copy file time as DOS does. */
#else
arg.preserveTime = 0;
#endif
arg.preserveAttributes = 0;
arg.nowarn = 0;
arg.textmode = 0;
arg.verbose = 0;
arg.type = mtype;
fastquit = 0;
while ((c = getopt(argc, argv, "abB/sptnmvQD:o")) != EOF) {
switch (c) {
case 's':
case '/':
arg.recursive = 1;
break;
case 'p':
arg.preserveAttributes = 1;
break;
case 'a':
case 't':
arg.textmode = 1;
break;
case 'n':
arg.nowarn = 1;
break;
case 'm':
arg.preserveTime = 1;
break;
case 'v':
arg.verbose = 1;
break;
case 'Q':
fastquit = 1;
break;
case 'B':
case 'b':
batchmode = 1;
break;
case 'o':
handle_clash_options(&arg.ch, c);
break;
case 'D':
if(handle_clash_options(&arg.ch, *optarg))
usage();
break;
case '?':
usage();
default:
break;
}
}
if (argc - optind < 1)
usage();
init_mp(&arg.mp);
arg.mp.lookupflags = ACCEPT_PLAIN | ACCEPT_DIR | DO_OPEN | NO_DOTS;
arg.mp.fast_quit = fastquit;
arg.mp.arg = (void *) &arg;
arg.mp.openflags = O_RDONLY;
/* last parameter is "-", use mtype mode */
if(!mtype && !strcmp(argv[argc-1], "-")) {
arg.type = mtype = 1;
argc--;
}
if(mtype){
/* Mtype = copying to stdout */
arg.mp.targetName = strdup("-");
arg.mp.unixTarget = strdup("");
arg.mp.callback = dos_to_unix;
arg.mp.dirCallback = unix_copydir;
arg.mp.unixcallback = unix_to_unix;
} else {
char *target;
if (argc - optind == 1) {
/* copying to the current directory */
target = ".";
} else {
/* target is the last item mentioned */
argc--;
target = argv[argc];
}
ret = target_lookup(&arg.mp, target);
if(!arg.mp.targetDir && !arg.mp.unixTarget) {
fprintf(stderr,"Bad target %s\n", target);
exit(1);
}
/* callback functions */
if(arg.mp.unixTarget) {
arg.mp.callback = dos_to_unix;
arg.mp.dirCallback = directory_dos_to_unix;
arg.mp.unixcallback = unix_to_unix;
} else {
arg.mp.dirCallback = dos_copydir;
arg.mp.callback = dos_to_dos;
arg.mp.unixcallback = unix_to_dos;
}
}
exit(main_loop(&arg.mp, argv + optind, argc - optind));
}
int sphere_dehom(point_d out_d, point_mp out_mp, int *out_prec, point_d in_d, point_mp in_mp, int in_prec, void const *ED_d, void const *ED_mp)
{
sphere_eval_data_d *BED_d = NULL;
sphere_eval_data_mp *BED_mp = NULL;
*out_prec = in_prec;
if (in_prec < 64)
{ // compute out_d
sphere_eval_data_d *BED_d = (sphere_eval_data_d *)ED_d;
comp_d denom;
change_size_vec_d(out_d,in_d->size-1);
out_d->size = in_d->size-1;
set_d(denom, &in_d->coord[0]);
for (int ii=0; ii<BED_d->num_variables-1; ++ii) {
set_d(&out_d->coord[ii],&in_d->coord[ii+1]);
div_d(&out_d->coord[ii],&out_d->coord[ii],denom); // result[ii] = dehom_me[ii+1]/dehom_me[0].
}
// print_point_to_screen_matlab(in_d,"in");
// print_point_to_screen_matlab(out_d,"out");
}
else
{ // compute out_mp
sphere_eval_data_mp *BED_mp = (sphere_eval_data_mp *)ED_mp;
setprec_point_mp(out_mp, *out_prec);
comp_mp denom; init_mp(denom);
change_size_vec_mp(out_mp,in_mp->size-1);
out_mp->size = in_mp->size-1;
set_mp(denom, &in_mp->coord[0]);
for (int ii=0; ii<BED_mp->num_variables-1; ++ii) {
set_mp(&out_mp->coord[ii],&in_mp->coord[ii+1]);
div_mp(&out_mp->coord[ii],&out_mp->coord[ii],denom); // result[ii] = dehom_me[ii+1]/dehom_me[0].
}
clear_mp(denom);
// set prec on out_mp
// print_point_to_screen_matlab(in_mp,"in");
// print_point_to_screen_matlab(out_mp,"out");
}
BED_d = NULL;
BED_mp = NULL;
return 0;
}
//this derived from basic_eval_d
int sphere_eval_mp(point_mp funcVals, point_mp parVals, vec_mp parDer, mat_mp Jv, mat_mp Jp, point_mp current_variable_values, comp_mp pathVars, void const *ED)
{ // evaluates a special homotopy type, built for bertini_real
// print_comp_mp_matlab(pathVars,"pathvars");
sphere_eval_data_mp *BED = (sphere_eval_data_mp *)ED; // to avoid having to cast every time
BED->SLP_memory.set_globals_to_this();
int ii, jj, mm; // counters
int offset;
comp_mp one_minus_s, gamma_s;
comp_mp temp, temp2;
comp_mp func_val_sphere, func_val_start;
init_mp(one_minus_s); init_mp(gamma_s);
init_mp(temp); init_mp(temp2);
init_mp(func_val_start);
init_mp(func_val_sphere);
set_one_mp(one_minus_s);
sub_mp(one_minus_s, one_minus_s, pathVars); // one_minus_s = (1 - s)
mul_mp(gamma_s, BED->gamma, pathVars); // gamma_s = gamma * s
vec_mp patchValues; init_vec_mp(patchValues, 0);
vec_mp temp_function_values; init_vec_mp(temp_function_values,0);
vec_mp AtimesF; init_vec_mp(AtimesF,BED->randomizer()->num_rand_funcs()); AtimesF->size = BED->randomizer()->num_rand_funcs();// declare // initialize
mat_mp temp_jacobian_functions; init_mat_mp(temp_jacobian_functions,BED->randomizer()->num_base_funcs(),BED->num_variables);
temp_jacobian_functions->rows = BED->randomizer()->num_base_funcs(); temp_jacobian_functions->cols = BED->num_variables;
mat_mp temp_jacobian_parameters; init_mat_mp(temp_jacobian_parameters,0,0);
mat_mp Jv_Patch; init_mat_mp(Jv_Patch, 0, 0);
mat_mp AtimesJ; init_mat_mp(AtimesJ,BED->randomizer()->num_rand_funcs(),BED->num_variables);
AtimesJ->rows = BED->randomizer()->num_rand_funcs(); AtimesJ->cols = BED->num_variables;
//set the sizes
change_size_vec_mp(funcVals,BED->num_variables); funcVals->size = BED->num_variables;
change_size_mat_mp(Jv, BED->num_variables, BED->num_variables); Jv->rows = Jv->cols = BED->num_variables; // -> this should be square!!!
for (ii=0; ii<BED->num_variables; ii++)
for (jj=0; jj<BED->num_variables; jj++)
set_zero_mp(&Jv->entry[ii][jj]);
// evaluate the SLP to get the system's whatnot.
evalProg_mp(temp_function_values, parVals, parDer, temp_jacobian_functions, temp_jacobian_parameters, current_variable_values, pathVars, BED->SLP);
// evaluate the patch
patch_eval_mp(patchValues, parVals, parDer, Jv_Patch, Jp, current_variable_values, pathVars, &BED->patch); // Jp is ignored
// we assume that the only parameter is s = t and setup parVals & parDer accordingly.
// note that you can only really do this AFTER you are done calling other evaluators.
// set parVals & parDer correctly
// i.e. these must remain here, or below. \/
change_size_point_mp(parVals, 1);
change_size_vec_mp(parDer, 1);
change_size_mat_mp(Jp, BED->num_variables, 1); Jp->rows = BED->num_variables; Jp->cols = 1;
for (ii=0; ii<BED->num_variables; ii++)
set_zero_mp(&Jp->entry[ii][0]);
parVals->size = parDer->size = 1;
set_mp(&parVals->coord[0], pathVars); // s = t
set_one_mp(&parDer->coord[0]); // ds/dt = 1
///////////////////////////
//
// the original (randomized) functions.
//
///////////////////////////////////
BED->randomizer()->randomize(AtimesF,AtimesJ,temp_function_values,temp_jacobian_functions,¤t_variable_values->coord[0]);
for (ii=0; ii<AtimesF->size; ii++) // for each function, after (real orthogonal) randomization
set_mp(&funcVals->coord[ii], &AtimesF->coord[ii]);
for (ii = 0; ii < BED->randomizer()->num_rand_funcs(); ii++)
for (jj = 0; jj < BED->num_variables; jj++)
set_mp(&Jv->entry[ii][jj],&AtimesJ->entry[ii][jj]);
//Jp is 0 for the equations.
///////////////////
//
// the sphere equation.
//
//////////////////////////
offset = BED->randomizer()->num_rand_funcs();
mul_mp(func_val_sphere, BED->radius, BED->radius);
neg_mp(func_val_sphere, func_val_sphere);
mul_mp(func_val_sphere, func_val_sphere, ¤t_variable_values->coord[0]);
mul_mp(func_val_sphere, func_val_sphere, ¤t_variable_values->coord[0]);
//f_sph = -r^2*h^2
for (int ii=1; ii<BED->num_natural_vars; ii++) {
mul_mp(temp2, &BED->center->coord[ii-1], ¤t_variable_values->coord[0]); // temp2 = c_{i-1}*h
sub_mp(temp, ¤t_variable_values->coord[ii], temp2); // temp = x_i - h*c_{i-1}
mul_mp(temp2, temp, temp); // temp2 = (x_i - h*c_{i-1})^2
add_mp(func_val_sphere, func_val_sphere, temp2); // f_sph += (x_i - h*c_{i-1})^2
}
set_one_mp(func_val_start);
for (mm=0; mm<2; ++mm) {
dot_product_mp(temp, BED->starting_linear[mm], current_variable_values);
mul_mp(func_val_start, func_val_start, temp);
//f_start *= L_i (x)
}
// combine the function values
mul_mp(temp, one_minus_s, func_val_sphere);
mul_mp(temp2, gamma_s, func_val_start);
add_mp(&funcVals->coord[offset], temp, temp2);
// f = (1-t) f_sph + gamma t f_start
//// / / / / / / now the derivatives wrt x
// first we store the derivatives of the target function, the sphere. then we will add the part for the linear product start.
//ddx for sphere
for (int ii=1; ii<BED->num_natural_vars; ii++) {
mul_mp(temp2, &BED->center->coord[ii-1], ¤t_variable_values->coord[0]); // temp2 = c_{i-1}*h
sub_mp(temp, ¤t_variable_values->coord[ii], temp2) // temp = x_i - c_{i-1}*h
mul_mp(&Jv->entry[offset][ii], BED->two, temp); // Jv = 2*(x_i - c_{i-1}*h)
mul_mp(&Jv->entry[offset][ii], &Jv->entry[offset][ii], one_minus_s); // Jv = (1-t)*2*(x_i - c_{i-1}*h)
mul_mp(temp2, &BED->center->coord[ii-1], temp); // temp2 = c_{i-1} * ( x_i - c_{i-1} * h )
add_mp(&Jv->entry[offset][0], &Jv->entry[offset][0], temp2); // Jv[0] += c_{i-1} * ( x_i - c_{i-1} * h )
}
// multiply these entries by (1-t)
// the homogenizing var deriv
mul_mp(temp, ¤t_variable_values->coord[0], BED->radius);
mul_mp(temp, temp, BED->radius); // temp = r^2 h
add_mp(&Jv->entry[offset][0], &Jv->entry[offset][0], temp); // Jv[0] = \sum_{i=1}^n {c_{i-1} * ( x_i - c_{i-1} * h )} + r^2 h
neg_mp(&Jv->entry[offset][0], &Jv->entry[offset][0]); // Jv[0] = -Jv[0]
mul_mp(&Jv->entry[offset][0], &Jv->entry[offset][0], BED->two); // Jv[0] *= 2
mul_mp(&Jv->entry[offset][0], &Jv->entry[offset][0], one_minus_s); // Jv[0] *= (1-t)
// f = \sum{ ( x_i - c_{i-1} * h )^2 } - r^2 h^2
//Jv = -2(1-t) ( \sum_{i=1}^n { c_{i-1} * ( x_i - c_{i-1} * h ) } + r^2 h )
// a hardcoded product rule for the two linears.
for (int ii=0; ii<BED->num_variables; ii++) {
dot_product_mp(temp, BED->starting_linear[0], current_variable_values);
mul_mp(temp, temp, &BED->starting_linear[1]->coord[ii]);
dot_product_mp(temp2, BED->starting_linear[1], current_variable_values);
mul_mp(temp2, temp2, &BED->starting_linear[0]->coord[ii]);
add_mp(temp, temp, temp2);
mul_mp(temp2, temp, gamma_s);
//temp2 = gamma s * (L_1(x) * L_0[ii] + L_0(x) * L_1[ii])
//temp2 now has the value of the derivative of the start system wrt x_i
add_mp(&Jv->entry[offset][ii], &Jv->entry[offset][ii], temp2);
}
// finally, the Jp entry for sphere equation's homotopy.
//Jp = -f_sph + gamma f_start
neg_mp(&Jp->entry[offset][0], func_val_sphere);
mul_mp(temp, BED->gamma, func_val_start);
add_mp(&Jp->entry[offset][0], &Jp->entry[offset][0], temp);
//////////////
//
// function values for the static linears
//
////////////////////
offset++;
for (mm=0; mm<BED->num_static_linears; ++mm) {
dot_product_mp(&funcVals->coord[mm+offset], BED->static_linear[mm], current_variable_values);
}
for (mm=0; mm<BED->num_static_linears; ++mm) {
for (ii=0; ii<BED->num_variables; ii++) {
set_mp(&Jv->entry[offset+mm][ii], &BED->static_linear[mm]->coord[ii]);
}
}
//Jp is 0 for the static linears
//////////////
//
// the entries for the patch equations.
//
////////////////////
if (offset+BED->num_static_linears != BED->num_variables-BED->patch.num_patches) {
std::cout << color::red() << "mismatch in offset!\nleft: " <<
offset+BED->num_static_linears << " right " << BED->num_variables-BED->patch.num_patches << color::console_default() << std::endl;
mypause();
}
offset = BED->num_variables-BED->patch.num_patches;
for (ii=0; ii<BED->patch.num_patches; ii++)
set_mp(&funcVals->coord[ii+offset], &patchValues->coord[ii]);
for (ii = 0; ii<BED->patch.num_patches; ii++) // for each patch equation
{ // Jv = Jv_Patch
for (jj = 0; jj<BED->num_variables; jj++) // for each variable
set_mp(&Jv->entry[ii+offset][jj], &Jv_Patch->entry[ii][jj]);
}
//Jp is 0 for the patch.
// done! yay!
if (BED->verbose_level()==16 || BED->verbose_level()==-16) {
//uncomment to see screen output of important variables at each solve step.
print_comp_matlab(pathVars, "t_mp");
print_comp_matlab(BED->gamma, "gamma_mp");
print_point_to_screen_matlab(current_variable_values,"currvars_mp");
print_point_to_screen_matlab(funcVals,"F_mp");
print_matrix_to_screen_matlab(Jv,"Jv_mp");
print_matrix_to_screen_matlab(Jp,"Jp_mp");
}
BED->SLP_memory.set_globals_null();
clear_mp(temp);
clear_mp(temp2);
clear_mp(gamma_s);
clear_mp(one_minus_s);
clear_mp(func_val_sphere);
clear_mp(func_val_start);
clear_vec_mp(patchValues);
clear_vec_mp(temp_function_values);
clear_vec_mp(AtimesF);
clear_mat_mp(temp_jacobian_functions);
clear_mat_mp(temp_jacobian_parameters);
clear_mat_mp(Jv_Patch);
clear_mat_mp(AtimesJ);
return 0;
}
void mattrib(int argc, char **argv, int type)
{
Arg_t arg;
int view;
int c;
int concise;
int replay;
char *ptr;
int wantUsage;
arg.add = 0;
arg.remove = 0xff;
arg.recursive = 0;
arg.doPrintName = 1;
view = 0;
concise = 0;
replay = 0;
wantUsage = 0;
if(helpFlag(argc, argv))
usage(0);
while ((c = getopt(argc, argv, "i:/ahrsAHRSXp")) != EOF) {
switch (c) {
case 'h':
wantUsage = 1;
/* FALL THROUGH */
default:
arg.remove &= ~letterToCode(c);
break;
case 'i':
set_cmd_line_image(optarg, 0);
break;
case 'p':
replay = 1;
break;
case '/':
arg.recursive = 1;
break;
case 'X':
concise = 1;
break;
case '?':
usage(1);
}
}
if(optind == argc && wantUsage) {
usage(0);
}
for(;optind < argc;optind++) {
switch(argv[optind][0]) {
case '+':
for(ptr = argv[optind] + 1; *ptr; ptr++)
arg.add |= letterToCode(*ptr);
continue;
case '-':
for(ptr = argv[optind] + 1; *ptr; ptr++)
arg.remove &= ~letterToCode(*ptr);
continue;
}
break;
}
if(arg.remove == 0xff && !arg.add)
view = 1;
if (optind >= argc)
usage(1);
init_mp(&arg.mp);
if(view){
if(concise) {
arg.mp.callback = concise_view_attrib;
arg.doPrintName = (argc - optind > 1 ||
arg.recursive ||
strpbrk(argv[optind], "*[?") != 0);
} else if (replay) {
arg.mp.callback = replay_attrib;
} else
arg.mp.callback = view_attrib;
arg.mp.openflags = O_RDONLY;
} else {
arg.mp.callback = attrib_file;
arg.mp.openflags = O_RDWR;
}
if(arg.recursive)
arg.mp.dirCallback = recursive_attrib;
arg.mp.arg = (void *) &arg;
arg.mp.lookupflags = ACCEPT_PLAIN | ACCEPT_DIR;
if(arg.recursive)
arg.mp.lookupflags |= DO_OPEN_DIRS | NO_DOTS;
exit(main_loop(&arg.mp, argv + optind, argc - optind));
}
void WitnessSet::sort_for_inside_sphere(comp_mp radius, vec_mp center)
{
int num_good_pts = 0;
std::vector<int> is_ok;
vec_mp temp_vec; init_vec_mp(temp_vec,0);
comp_mp temp; init_mp(temp);
for (unsigned int ii = 0; ii<num_points(); ++ii) {
dehomogenize(&temp_vec, point(ii),num_natty_vars_);
temp_vec->size = center->size;
norm_of_difference(temp->r, temp_vec, center);
if ( mpf_cmp(temp->r, radius->r) < 0 ){
is_ok.push_back(1);
num_good_pts++;
}
else
{
is_ok.push_back(0);
}
}
vec_mp *transferme = (vec_mp *)br_malloc(num_good_pts*sizeof(vec_mp));
int counter = 0;
for (unsigned int ii=0; ii<num_points(); ++ii) {
if (is_ok[ii]==1) {
init_vec_mp2(transferme[counter],0,1024); transferme[counter]->size = 0;
vec_cp_mp(transferme[counter], point(ii));
counter++;
}
}
if (counter!= num_good_pts) {
printf("counter mismatch\n");
br_exit(271);
}
for (unsigned int ii=0; ii<num_points(); ii++) {
clear_vec_mp(point(ii));
}
free(pts_mp_);
num_pts_ = num_good_pts;
pts_mp_ = transferme;
clear_vec_mp(temp_vec);
clear_mp(temp);
return;
}