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; }