void tm_entity_stationary_init( tm_entity_stationary_t* ent, int _ent_type )
{
assert( ent && _ent_type >= 0 && _ent_type < n_entity_types );
elem_init( &ent->e, 0 );
ent->ent_id = -1;
ent->ent_type = _ent_type;
}
Elem *qlist_insert(Qlist *ql, char *word, int sword) {
Elem *el = elem_create();
elem_init(el,word,sword);
el->next = ql->end;
el->prev = ql->end->prev;
ql->end->prev->next = el;
ql->end->prev = el;
return el;
}
int main()
{
flint_rand_t state;
long iter;
printf("poly_divrem_basecase....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000; iter++)
{
ring_t ZZ, ZZp, ZZpx[3];
ring_struct * ring;
elem_ptr p;
long size[3];
elem_poly_t A, B, C, Q, Q2, R, R2;
ring_init_limb(ZZ);
ELEM_TMP_INIT(p, ZZ);
elem_set_ui(p, n_randtest_prime(state, 0), ZZ);
ring_init_mod(ZZp, ZZ, p);
ring_init_poly(ZZpx[0], ZZp);
ring_init_poly(ZZpx[1], ZZpx[0]);
ring_init_poly(ZZpx[2], ZZpx[1]);
ring = ZZpx[n_randint(state, 2)];
size[0] = 1 + n_randint(state, 30);
size[1] = 1 + n_randint(state, 30);
size[2] = 1 + n_randint(state, 30);
elem_init(A, ring);
elem_init(B, ring);
elem_init(C, ring);
elem_init(Q, ring);
elem_init(Q2, ring);
elem_init(R, ring);
elem_init(R2, ring);
elem_randtest(A, state, size, ring);
elem_randtest_not_zero(B, state, size, ring);
elem_mul(C, A, B, ring);
elem_poly_divrem_basecase(Q, R, C, B, ring);
if (!elem_equal(Q, A, ring) || !elem_is_zero(R, ring))
{
printf("FAIL: (A * B) / B = A\n");
elem_print(A, ring); printf("\n\n");
elem_print(B, ring); printf("\n\n");
elem_print(C, ring); printf("\n\n");
elem_print(Q, ring); printf("\n\n");
elem_print(R, ring); printf("\n\n");
abort();
}
elem_divrem(Q, R, A, B, ring);
elem_mul(C, Q, B, ring);
elem_add(C, C, R, ring);
if (!elem_equal(C, A, ring))
{
printf("FAIL: Q * B + R = A\n");
elem_print(A, ring); printf("\n\n");
elem_print(B, ring); printf("\n\n");
elem_print(C, ring); printf("\n\n");
elem_print(Q, ring); printf("\n\n");
elem_print(R, ring); printf("\n\n");
abort();
}
elem_randtest(A, state, size, ring);
elem_randtest_not_zero(B, state, size, ring);
elem_poly_divrem_basecase(Q, R, A, B, ring);
elem_poly_divrem_basecase(A, R2, A, B, ring);
if (!elem_equal(A, Q, ring) || !elem_equal(R, R2, ring))
{
printf("FAIL: aliasing Q, A\n");
elem_print(A, ring); printf("\n\n");
elem_print(B, ring); printf("\n\n");
elem_print(Q, ring); printf("\n\n");
elem_print(R, ring); printf("\n\n");
elem_print(R2, ring); printf("\n\n");
abort();
}
elem_randtest(A, state, size, ring);
elem_randtest_not_zero(B, state, size, ring);
elem_poly_divrem_basecase(Q, R, A, B, ring);
elem_poly_divrem_basecase(Q2, A, A, B, ring);
if (!elem_equal(A, R, ring) || !elem_equal(Q, Q2, ring))
{
printf("FAIL: aliasing R, A\n");
elem_print(A, ring); printf("\n\n");
elem_print(B, ring); printf("\n\n");
elem_print(Q, ring); printf("\n\n");
elem_print(Q2, ring); printf("\n\n");
elem_print(R, ring); printf("\n\n");
abort();
}
elem_randtest(A, state, size, ring);
elem_randtest_not_zero(B, state, size, ring);
elem_poly_divrem_basecase(Q, R, A, B, ring);
elem_poly_divrem_basecase(Q2, B, A, B, ring);
if (!elem_equal(B, R, ring) || !elem_equal(Q, Q2, ring))
{
printf("FAIL: aliasing R, B\n");
elem_print(A, ring); printf("\n\n");
elem_print(B, ring); printf("\n\n");
elem_print(Q, ring); printf("\n\n");
elem_print(Q2, ring); printf("\n\n");
elem_print(R, ring); printf("\n\n");
abort();
}
elem_randtest(A, state, size, ring);
elem_randtest_not_zero(B, state, size, ring);
elem_poly_divrem_basecase(Q, R, A, B, ring);
elem_poly_divrem_basecase(B, R2, A, B, ring);
if (!elem_equal(B, Q, ring) || !elem_equal(R, R2, ring))
{
printf("FAIL: aliasing Q, B\n");
elem_print(A, ring); printf("\n\n");
elem_print(B, ring); printf("\n\n");
elem_print(Q, ring); printf("\n\n");
elem_print(R, ring); printf("\n\n");
elem_print(R2, ring); printf("\n\n");
abort();
}
elem_clear(A, ring);
elem_clear(B, ring);
elem_clear(C, ring);
elem_clear(Q, ring);
elem_clear(Q2, ring);
elem_clear(R, ring);
elem_clear(R2, ring);
ring_clear(ZZpx[2]);
ring_clear(ZZpx[1]);
ring_clear(ZZpx[0]);
ring_clear(ZZp);
ELEM_TMP_CLEAR(p, ZZ);
ring_clear(ZZ);
}
printf("PASS\n");
flint_randclear(state);
return EXIT_SUCCESS;
}
Bool zpl_read_with_args(char** argv, int argc, Bool with_management, void* user_data)
{
const char* options = "D:mP:sv:";
unsigned long seed = 13021967UL;
char** param_table;
int param_count = 0;
int c;
int i;
Prog* prog = NULL;
Set* set;
void* lp = NULL;
Bool ret = FALSE;
char* inppipe = NULL;
Bool use_startval = FALSE;
stkchk_init();
yydebug = 0;
yy_flex_debug = 0;
param_table = malloc(sizeof(*param_table));
zpl_print_banner(stdout, FALSE);
/* getopt might be called more than once
*/
optind = 1;
while((c = getopt(argc, argv, options)) != -1)
{
switch(c)
{
case 'D' :
param_table =
realloc(param_table, ((unsigned int)param_count + 1) * sizeof(*param_table));
param_table[param_count] = strdup(optarg);
if (verbose >= VERB_DEBUG)
printf("Parameter %d [%s]\n", param_count, param_table[param_count]);
param_count++;
break;
case 'm' :
use_startval = TRUE;
break;
case 'P' :
inppipe = strdup(optarg);
break;
case 's' :
seed = (unsigned long)atol(optarg);
break;
case 'v' :
verbose = atoi(optarg);
break;
case '?':
fprintf(stderr, "Unknown option '%c'\n", c);
return FALSE;
default :
abort();
}
}
if ((argc - optind) < 1)
{
fprintf(stderr, "Filename missing\n");
free(param_table);
return FALSE;
}
blk_init();
str_init();
rand_init(seed);
numb_init(with_management);
elem_init();
set_init();
mio_init();
interns_init();
local_init();
if (0 == setjmp( zpl_read_env))
{
is_longjmp_ok = TRUE;
/* Make symbol to hold entries of internal variables
*/
set = set_pseudo_new();
(void)symbol_new(SYMBOL_NAME_INTERNAL, SYM_VAR, set, 100, NULL);
set_free(set);
/* Now store the param defines
*/
for(i = 0; i < param_count; i++)
zpl_add_parameter(param_table[i]);
prog = prog_new();
for(i = optind; i < argc; i++)
prog_load(prog, inppipe, argv[i]);
if (prog_is_empty(prog))
fprintf(stderr, "*** Error 168: No program statements to execute\n");
else
{
if (verbose >= VERB_DEBUG)
prog_print(stderr, prog);
lp = xlp_alloc(argv[optind], use_startval, user_data);
prog_execute(prog, lp);
ret = TRUE;
}
}
is_longjmp_ok = FALSE;
if (lp != NULL)
xlp_free(lp);
/* Now clean up.
*/
if (inppipe != NULL)
free(inppipe);
for(i = 0; i < param_count; i++)
free(param_table[i]);
free(param_table);
if (prog != NULL)
prog_free(prog);
local_exit();
interns_exit();
mio_exit();
symbol_exit();
define_exit();
set_exit();
elem_exit();
numb_exit();
str_exit();
blk_exit();
return ret;
}
Bool zpl_read(const char* filename, Bool with_management, void* user_data)
{
Prog* prog = NULL;
Set* set;
void* lp = NULL;
Bool ret = FALSE;
stkchk_init();
yydebug = 0;
yy_flex_debug = 0;
zpl_print_banner(stdout, FALSE);
blk_init();
str_init();
rand_init(13021967UL);
numb_init(with_management);
elem_init();
set_init();
mio_init();
interns_init();
local_init();
if (0 == setjmp(zpl_read_env))
{
is_longjmp_ok = TRUE;
set = set_pseudo_new();
(void)symbol_new(SYMBOL_NAME_INTERNAL, SYM_VAR, set, 100, NULL);
set_free(set);
prog = prog_new();
prog_load(prog, NULL, filename);
if (prog_is_empty(prog))
fprintf(stderr, "*** Error 168: No program statements to execute\n");
else
{
if (verbose >= VERB_DEBUG)
prog_print(stderr, prog);
lp = xlp_alloc(filename, FALSE, user_data);
prog_execute(prog, lp);
ret = TRUE;
}
}
is_longjmp_ok = FALSE;
if (lp != NULL)
xlp_free(lp);
if (prog != NULL)
prog_free(prog);
local_exit();
interns_exit();
mio_exit();
symbol_exit();
define_exit();
set_exit();
elem_exit();
numb_exit();
str_exit();
blk_exit();
return ret;
}
gint read_about(gchar *filename, struct model_pak *model)
{
gint i, flag, frame, num_tokens, tot_tokens;
gint natom=0, ntype=0;
GString *title;
gchar **buff, **curr_token, *ptr, *tmp, line[LINELEN];
struct core_pak *core;
GSList *clist;
FILE *fp;
fp = fopen(filename, "rt");
if (!fp)
return(1);
flag=frame=0;
while (!fgetline(fp, line))
{
/* space group info */
if (g_ascii_strncasecmp(" Symmetries :", line, 13) == 0)
{
ptr = g_strrstr(line, "(#");
model->sginfo.spacenum = (gint) str_to_float(ptr+2);
}
/* default cell dimensions */
/* NB: gdis wants transposed ABINIT matrix */
if (g_ascii_strncasecmp(" Real(R)+Recip(G)", line, 17) == 0)
{
for (i=0; i<3; i++)
{
if (fgetline(fp, line))
{
gui_text_show(ERROR, "unexpected end of file reading cell dimensions\n");
fclose(fp);
return(2);
}
buff = tokenize(line, &num_tokens);
model->latmat[0+i] = str_to_float(*(buff+1))*AU2ANG;
model->latmat[3+i] = str_to_float(*(buff+2))*AU2ANG;
model->latmat[6+i] = str_to_float(*(buff+3))*AU2ANG;
g_strfreev(buff);
}
model->construct_pbc = TRUE;
model->periodic = 3;
/* last part of data in output file before minimisation */
break;
}
/* optimisation type */
if (g_ascii_strncasecmp(" optcell", line, 10) == 0)
{
buff = tokenize(line, &num_tokens);
optcell = (gint) str_to_float(*(buff+1));
g_strfreev(buff);
}
/* coordinates */
if (g_ascii_strncasecmp(" natom", line, 10) == 0)
{
buff = tokenize(line, &num_tokens);
natom = (gint) str_to_float(*(buff+1));
g_strfreev(buff);
}
/* NEW - cope with format change and avoid false positives */
// if (g_ascii_strncasecmp(" ntype", line, 10) == 0)
if (g_strrstr(line, " ntyp"))
{
buff = tokenize(line, &num_tokens);
ntype = (gint) str_to_float(*(buff+1));
g_strfreev(buff);
}
/* NEW - cope with format change and avoid false positives */
// if (g_ascii_strncasecmp(" type", line, 10) == 0)
if (g_strrstr(line, " typ"))
{
tot_tokens = 0;
buff = tokenize(line, &num_tokens);
curr_token = buff + 1;
while (tot_tokens < natom)
{
if (*curr_token == NULL)
{
g_strfreev(buff);
buff = get_tokenized_line(fp, &num_tokens);
curr_token = buff;
}
/* NB: number here is the internal reference to pseudopotential number */
core = core_new(*curr_token, NULL, model);
model->cores = g_slist_prepend(model->cores, core);
tot_tokens++;
curr_token++;
}
model->cores = g_slist_reverse(model->cores);
g_strfreev(buff);
flag++;
}
if (g_ascii_strncasecmp(" xangst", line, 10) == 0)
{
clist = model->cores;
if (clist == NULL)
{
gui_text_show(ERROR, "no atoms found\n");
fclose(fp);
return(2);
}
buff = tokenize(line+10, &num_tokens);
for (i=0; i<natom; i++)
{
core = clist->data;
core->x[0] = str_to_float(*(buff+0));
core->x[1] = str_to_float(*(buff+1));
core->x[2] = str_to_float(*(buff+2));
g_strfreev(buff);
buff = get_tokenized_line(fp, &num_tokens);
clist = g_slist_next(clist);
}
}
/* process the list of atom nuc charges to get atomic numbers */
if (g_ascii_strncasecmp(" znucl", line, 10) == 0)
{
buff = tokenize(line, &num_tokens);
for (clist=model->cores ; clist ; clist=g_slist_next(clist))
{
core = clist->data;
if (core->atom_code > 0 && core->atom_code < num_tokens)
{
/* assign the atomic number */
core->atom_code = str_to_float(*(buff+core->atom_code));
/* wipe the label clean so the element symbol is used */
g_free(core->atom_label);
core->atom_label = NULL;
/* refresh atom's element data */
elem_init(core, model);
}
}
}
}
/* Additional info */
while (!fgetline(fp, line))
{
/* energy */
/* NEW - cope with format change */
if (g_strrstr(line, "Etotal="))
{
buff = g_strsplit(line, "=", 2);
if (buff)
{
model->abinit.energy = str_to_float(*(buff+1));
/* display energy in properties panel */
tmp = g_strdup_printf("%f Hartrees", model->abinit.energy);
property_add_ranked(1, "Total energy", tmp, model);
g_free(tmp);
}
g_strfreev(buff);
}
/* gradient */
else if ((g_ascii_strncasecmp(line, " frms,max,avg=", 14) == 0) && g_strrstr(line, "h/b"))
{
// printf("reading gradient\n");
buff = tokenize(line, &num_tokens);
if (num_tokens > 2)
{
model->abinit.max_grad = str_to_float(*(buff+2));
model->abinit.rms_grad = str_to_float(*(buff+1));
property_add_ranked(1, "Gradient", *(buff+2), model);
}
g_strfreev(buff);
// printf("gradient is %lf\n", model->abinit.max_grad);
}
/* coordinates */
else if ((g_ascii_strncasecmp(line, " Cartesian coordinates (bohr)", 29) == 0 && optcell == 0)
|| (g_ascii_strncasecmp(line, " Unit cell characteristics :", 28) == 0 && optcell > 0))
{
/* go through all frames to count them */
read_about_block(fp, model);
animate_frame_store(model);
frame++;
}
}
fclose(fp);
/* done */
if (flag)
{
g_free(model->filename);
model->filename = g_strdup(filename);
g_free(model->basename);
model->basename = parse_strip(filename);
model->num_frames = model->cur_frame = frame;
model->cur_frame--;
title = g_string_new("");
g_string_append_printf(title, "E");
g_string_append_printf(title, " = %.4f Ha, ", model->abinit.energy);
g_string_append_printf(title, "max grad = %.5f", model->abinit.max_grad);
model->title = g_strdup(title->str);
g_string_free(title, TRUE);
model_prep(model);
}
else
return(2);
return(0);
}
int main(int argc, char* const* argv)
{
Prog* prog;
Set* set;
void* lp;
const char* extension = "";
char* filter = strdup("%s");
char* outfile;
char* tblfile;
char* ordfile;
char* mstfile;
char* basefile = NULL;
char* inppipe = NULL;
char* outpipe;
LpFormat format = LP_FORM_LPF;
FILE* fp;
Bool write_order = FALSE;
Bool write_mst = FALSE;
Bool presolve = FALSE;
int name_length = 0;
char* prog_text;
unsigned long seed = 13021967UL;
char** param_table;
int param_count = 0;
int c;
int i;
FILE* (*openfile)(const char*, const char*) = fopen;
int (*closefile)(FILE*) = fclose;
stkchk_init();
yydebug = 0;
yy_flex_debug = 0;
verbose = VERB_NORMAL;
param_table = malloc(sizeof(*param_table));
while((c = getopt(argc, argv, options)) != -1)
{
switch(c)
{
case 'b' :
yydebug = 1;
break;
case 'D' :
param_table =
realloc(param_table, ((unsigned int)param_count + 1) * sizeof(*param_table));
param_table[param_count] = strdup(optarg);
param_count++;
break;
case 'h' :
zpl_print_banner(stdout, TRUE);
printf(usage, argv[0]);
puts(help);
exit(0);
case 'f' :
yy_flex_debug = 1;
break;
case 'F' :
free(filter);
filter = strdup(optarg);
openfile = popen;
closefile = pclose;
break;
case 'l' :
name_length = atoi(optarg);
break;
case 'm' :
write_mst = TRUE;
break;
case 'n' :
if (*optarg != 'c')
{
fprintf(stderr, usage, argv[0]);
exit(0);
}
switch(optarg[1])
{
case 'm' :
conname_format(CON_FORM_MAKE);
break;
case 'n' :
conname_format(CON_FORM_NAME);
break;
case 'f' :
conname_format(CON_FORM_FULL);
break;
default :
fprintf(stderr, usage, argv[0]);
exit(0);
}
break;
case 'o' :
basefile = strdup(optarg);
break;
case 'O' :
presolve = TRUE;
break;
case 'P' :
inppipe = strdup(optarg);
break;
case 's' :
seed = (unsigned long)atol(optarg);
break;
case 'r' :
write_order = TRUE;
break;
case 't' :
switch(tolower(*optarg))
{
case 'h' :
format = LP_FORM_HUM;
break;
case 'm' :
format = LP_FORM_MPS;
break;
case 'l' :
format = LP_FORM_LPF;
break;
case 'p' :
format = LP_FORM_PIP;
break;
case 'r' :
format = LP_FORM_RLP;
break;
default :
if (verbose > VERB_QUIET)
fprintf(stderr,
"--- Warning 103: Output format \"%s\" not supported, using LP format\n",
optarg);
format = LP_FORM_LPF;
break;
}
break;
case 'v' :
verbose = atoi(optarg);
break;
case 'V' :
printf("%s\n", VERSION);
exit(0);
case '?':
fprintf(stderr, usage, argv[0]);
exit(0);
default :
abort();
}
}
if ((argc - optind) < 1)
{
fprintf(stderr, usage, argv[0]);
exit(0);
}
zpl_print_banner(stdout, TRUE);
if (basefile == NULL)
basefile = strip_extension(strdup(strip_path(argv[optind])));
switch(format)
{
case LP_FORM_LPF :
extension = ".lp";
break;
case LP_FORM_MPS :
extension = ".mps";
break;
case LP_FORM_HUM :
extension = ".hum";
break;
case LP_FORM_RLP :
extension = ".rlp";
break;
case LP_FORM_PIP :
extension = ".pip";
break;
default :
abort();
}
assert(extension != NULL);
outfile = add_extention(basefile, extension);
tblfile = add_extention(basefile, ".tbl");
ordfile = add_extention(basefile, ".ord");
mstfile = add_extention(basefile, ".mst");
outpipe = malloc(strlen(basefile) + strlen(filter) + 256);
assert(outpipe != NULL);
blk_init();
str_init();
rand_init(seed);
numb_init(TRUE);
elem_init();
set_init();
mio_init();
interns_init();
local_init();
/* Make symbol to hold entries of internal variables
*/
set = set_pseudo_new();
(void)symbol_new(SYMBOL_NAME_INTERNAL, SYM_VAR, set, 100, NULL);
set_free(set);
/* Now store the param defines
*/
for(i = 0; i < param_count; i++)
zpl_add_parameter(param_table[i]);
/* Next we read in the zpl program(s)
*/
prog = prog_new();
for(i = optind; i < argc; i++)
prog_load(prog, inppipe, argv[i]);
if (prog_is_empty(prog))
{
fprintf(stderr, "*** Error 168: No program statements to execute\n");
exit(EXIT_FAILURE);
}
if (verbose >= VERB_DEBUG)
prog_print(stderr, prog);
lp = xlp_alloc(argv[optind], write_mst || write_order, NULL);
zlp_setnamelen(lp, name_length);
prog_execute(prog, lp);
/* Presolve
*/
if (presolve)
fprintf(stderr, "--- Warning: Presolve no longer support. If you need it, send me an email\n");
#if 0
if (!zlp_presolve())
exit(EXIT_SUCCESS);
#endif
if (verbose >= VERB_NORMAL)
zlp_stat(lp);
/* Write order file
*/
if (write_order)
{
sprintf(outpipe, filter, ordfile, "ord");
if (verbose >= VERB_NORMAL)
printf("Writing [%s]\n", outpipe);
if (NULL == (fp = (*openfile)(outpipe, "w")))
{
fprintf(stderr, "*** Error 104: File open failed ");
perror(ordfile);
exit(EXIT_FAILURE);
}
zlp_orderfile(lp, fp, format);
check_write_ok(fp, ordfile);
(void)(*closefile)(fp);
}
/* Write MST file
*/
if (write_mst)
{
sprintf(outpipe, filter, mstfile, "mst");
if (verbose >= VERB_NORMAL)
printf("Writing [%s]\n", outpipe);
if (NULL == (fp = (*openfile)(outpipe, "w")))
{
fprintf(stderr, "*** Error 104: File open failed ");
perror(mstfile);
exit(EXIT_FAILURE);
}
zlp_mstfile(lp, fp, format);
check_write_ok(fp, mstfile);
(void)(*closefile)(fp);
}
/* Write Output
*/
sprintf(outpipe, filter, outfile, "lp");
if (verbose >= VERB_NORMAL)
printf("Writing [%s]\n", outpipe);
if (NULL == (fp = (*openfile)(outpipe, "w")))
{
fprintf(stderr, "*** Error 104: File open failed ");
perror(outfile);
exit(EXIT_FAILURE);
}
if (format != LP_FORM_RLP)
prog_text = prog_tostr(prog, format == LP_FORM_MPS ? "* " : "\\ ", title, 128);
else
{
prog_text = malloc(strlen(title) + 4);
assert(prog_text != NULL);
sprintf(prog_text, "\\%s\n", title);
}
zlp_write(lp, fp, format, prog_text);
check_write_ok(fp, outfile);
(void)(*closefile)(fp);
/* We do not need the translation table for human readable format
* Has to be written after the LP file, so the scaling has been done.
*/
if (format != LP_FORM_HUM)
{
/* Write translation table
*/
sprintf(outpipe, filter, tblfile, "tbl");
if (verbose >= VERB_NORMAL)
printf("Writing [%s]\n", outpipe);
if (NULL == (fp = (*openfile)(outpipe, "w")))
{
fprintf(stderr, "*** Error 104: File open failed");
perror(tblfile);
exit(EXIT_FAILURE);
}
zlp_transtable(lp, fp, format);
check_write_ok(fp, tblfile);
(void)(*closefile)(fp);
}
free(prog_text);
if (verbose >= VERB_DEBUG)
symbol_print_all(stderr);
#if defined(__INSURE__) || !defined(NDEBUG) || defined(FREEMEM)
/* Now clean up.
*/
if (inppipe != NULL)
free(inppipe);
for(i = 0; i < param_count; i++)
free(param_table[i]);
free(param_table);
prog_free(prog);
local_exit();
interns_exit();
xlp_free(lp);
mio_exit();
symbol_exit();
define_exit();
set_exit();
elem_exit();
numb_exit();
str_exit();
blk_exit();
free(mstfile);
free(ordfile);
free(outfile);
free(tblfile);
free(basefile);
free(filter);
free(outpipe);
if (verbose >= VERB_NORMAL)
{
mem_display(stdout);
stkchk_maximum(stdout);
}
#endif /* __INSURE__ || !NDEBUG || FREEMEM */
return 0;
}
int
main(void)
{
flint_rand_t state;
long i;
printf("inv....");
fflush(stdout);
flint_randinit(state);
/* Test aliasing */
for (i = 0; i < 40 * flint_test_multiplier(); i++)
{
elem_mat_t A, Ainv;
elem_poly_t den1, den2;
ring_t ZZ, ZZx, MM;
long n;
long size[3] = {5, 5, 5};
int ns1, ns2;
int result;
n = n_randint(state, 8);
ring_init_fmpz(ZZ);
ring_init_poly(ZZx, ZZ);
ring_init_mat(MM, ZZx);
elem_mat_init(A, n, n, MM);
elem_mat_init(Ainv, n, n, MM);
elem_init(den1, ZZx);
elem_init(den2, ZZx);
elem_mat_randtest(A, state, size, MM);
ns1 = elem_mat_inv(Ainv, den1, A, MM);
ns2 = elem_mat_inv(A, den2, A, MM);
result = ns1 == ns2;
if (result && ns1 != 0)
{
result = elem_equal(den1, den2, ZZx) &&
elem_mat_equal(A, Ainv, MM);
}
if (!result)
{
printf("FAIL (aliasing)!\n");
elem_mat_print(A, MM); printf("\n");
elem_mat_print(Ainv, MM); printf("\n");
abort();
}
elem_mat_clear(A, MM);
elem_mat_clear(Ainv, MM);
elem_clear(den1, ZZx);
elem_clear(den2, ZZx);
}
/* Check A^(-1) = A = 1 */
for (i = 0; i < 100 * flint_test_multiplier(); i++)
{
elem_mat_t A, Ainv, B, Iden;
elem_poly_t den, det;
ring_t ZZ, ZZx, MM;
long n;
long size[3] = {5, 5, 5};
int nonsingular;
n = n_randint(state, 8);
ring_init_fmpz(ZZ);
ring_init_poly(ZZx, ZZ);
ring_init_mat(MM, ZZx);
elem_mat_init(A, n, n, MM);
elem_mat_init(Ainv, n, n, MM);
elem_mat_init(B, n, n, MM);
elem_mat_init(Iden, n, n, MM);
elem_init(den, ZZx);
elem_init(det, ZZx);
elem_mat_randtest(A, state, size, MM);
nonsingular = elem_mat_inv(Ainv, den, A, MM);
elem_mat_det(det, A, MM);
if (n == 0)
{
if (nonsingular == 0 || !elem_is_one(den, ZZx))
{
printf("FAIL: expected empty matrix to pass\n");
abort();
}
}
else
{
/*
if (!elem_equal(den, det, ZZx))
{
elem_neg(det, det, ZZx);
printf("FAIL: den != det(A)\n");
abort();
}
*/
if (nonsingular)
{
elem_mat_mul(B, Ainv, A, MM);
elem_mat_one(Iden, MM);
elem_mat_scalar_mul(Iden, Iden, den, MM);
if (!elem_mat_equal(B, Iden, MM))
{
printf("FAIL:\n");
printf("A:\n");
elem_mat_print(A, MM);
printf("Ainv:\n");
elem_mat_print(Ainv, MM);
printf("B:\n");
elem_mat_print(B, MM);
printf("den:\n");
elem_print(den, ZZx);
abort();
}
}
else
{
if (!elem_is_zero(det, ZZx) || !elem_is_zero(den, ZZx))
{
printf("FAIL (reported invertible):\n");
printf("A:\n");
elem_mat_print(A, MM);
printf("Ainv:\n");
elem_mat_print(Ainv, MM);
printf("den:\n");
elem_print(den, ZZx);
abort();
}
}
}
elem_clear(den, ZZx);
elem_clear(det, ZZx);
elem_mat_clear(A, MM);
elem_mat_clear(Ainv, MM);
elem_mat_clear(B, MM);
elem_mat_clear(Iden, MM);
}
flint_randclear(state);
_fmpz_cleanup();
printf("PASS\n");
return 0;
}
