My Project
Macros | Functions
extra.cc File Reference
#include "kernel/mod2.h"
#include "misc/sirandom.h"
#include "resources/omFindExec.h"
#include "factory/factory.h"
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include "misc/options.h"
#include "coeffs/coeffs.h"
#include "coeffs/mpr_complex.h"
#include "resources/feResource.h"
#include "polys/monomials/ring.h"
#include "kernel/polys.h"
#include "polys/monomials/maps.h"
#include "polys/matpol.h"
#include "polys/weight.h"
#include "polys/shiftop.h"
#include "coeffs/bigintmat.h"
#include "kernel/fast_mult.h"
#include "kernel/digitech.h"
#include "kernel/combinatorics/stairc.h"
#include "kernel/ideals.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/GBEngine/syz.h"
#include "kernel/GBEngine/kutil.h"
#include "kernel/GBEngine/kverify.h"
#include "kernel/linear_algebra/linearAlgebra.h"
#include "kernel/combinatorics/hutil.h"
#include "kernel/GBEngine/tgb.h"
#include "kernel/linear_algebra/minpoly.h"
#include "numeric/mpr_base.h"
#include "tok.h"
#include "ipid.h"
#include "lists.h"
#include "cntrlc.h"
#include "ipshell.h"
#include "sdb.h"
#include "feOpt.h"
#include "fehelp.h"
#include "distrib.h"
#include "misc_ip.h"
#include "attrib.h"
#include "links/silink.h"
#include "links/ssiLink.h"
#include "walk.h"
#include "Singular/newstruct.h"
#include "Singular/blackbox.h"
#include "Singular/pyobject_setup.h"
#include "kernel/GBEngine/ringgb.h"
#include "kernel/GBEngine/f5gb.h"
#include "kernel/spectrum/spectrum.h"
#include "polys/nc/nc.h"
#include "polys/nc/ncSAMult.h"
#include "polys/nc/sca.h"
#include "kernel/GBEngine/nc.h"
#include "ipconv.h"
#include "kernel/GBEngine/ratgring.h"
#include "polys/flintconv.h"
#include "polys/clapconv.h"
#include "kernel/GBEngine/kstdfac.h"
#include "polys/clapsing.h"
#include "eigenval_ip.h"
#include "gms.h"
#include "Singular/links/simpleipc.h"
#include "pcv.h"
#include "kernel/fglm/fglm.h"
#include "hc_newton.h"

Go to the source code of this file.

Macros

#define HAVE_WALK   1
 
#define HAVE_EXTENDED_SYSTEM   1
 
#define TEST_FOR(A)   if(strcmp(s,A)==0) res->data=(void *)1; else
 
#define SINGULAR_PROCS_DIR   "/libexec/singular/MOD"
 
#define HAVE_SHEAFCOH_TRICKS   1
 

Functions

static BOOLEAN jjEXTENDED_SYSTEM (leftv res, leftv h)
 
unsigned long ** singularMatrixToLongMatrix (matrix singularMatrix)
 
poly longCoeffsToSingularPoly (unsigned long *polyCoeffs, const int degree)
 
BOOLEAN jjSYSTEM (leftv res, leftv args)
 

Macro Definition Documentation

◆ HAVE_EXTENDED_SYSTEM

#define HAVE_EXTENDED_SYSTEM   1

Definition at line 141 of file extra.cc.

◆ HAVE_SHEAFCOH_TRICKS

#define HAVE_SHEAFCOH_TRICKS   1

◆ HAVE_WALK

#define HAVE_WALK   1

Definition at line 11 of file extra.cc.

◆ SINGULAR_PROCS_DIR

#define SINGULAR_PROCS_DIR   "/libexec/singular/MOD"

◆ TEST_FOR

#define TEST_FOR (   A)    if(strcmp(s,A)==0) res->data=(void *)1; else

Function Documentation

◆ jjEXTENDED_SYSTEM()

static BOOLEAN jjEXTENDED_SYSTEM ( leftv  res,
leftv  h 
)
static

Definition at line 2361 of file extra.cc.

2362{
2363 if(h->Typ() == STRING_CMD)
2364 {
2365 char *sys_cmd=(char *)(h->Data());
2366 h=h->next;
2367 /*==================== test syz strat =================*/
2368 if (strcmp(sys_cmd, "syz") == 0)
2369 {
2370 if ((h!=NULL) && (h->Typ()==STRING_CMD))
2371 {
2372 const char *s=(const char *)h->Data();
2373 if (strcmp(s,"posInT_EcartFDegpLength")==0)
2375 else if (strcmp(s,"posInT_FDegpLength")==0)
2377 else if (strcmp(s,"posInT_pLength")==0)
2379 else if (strcmp(s,"posInT0")==0)
2381 else if (strcmp(s,"posInT1")==0)
2383 else if (strcmp(s,"posInT2")==0)
2385 else if (strcmp(s,"posInT11")==0)
2387 else if (strcmp(s,"posInT110")==0)
2389 else if (strcmp(s,"posInT13")==0)
2391 else if (strcmp(s,"posInT15")==0)
2393 else if (strcmp(s,"posInT17")==0)
2395 else if (strcmp(s,"posInT17_c")==0)
2397 else if (strcmp(s,"posInT19")==0)
2399 else PrintS("valid posInT:0,1,2,11,110,13,15,17,17_c,19,_EcartFDegpLength,_FDegpLength,_pLength,_EcartpLength\n");
2400 }
2401 else
2402 {
2405 }
2406 si_opt_2|=Sy_bit(23);
2407 return FALSE;
2408 }
2409 else
2410 /*==================== locNF ======================================*/
2411 if(strcmp(sys_cmd,"locNF")==0)
2412 {
2413 const short t[]={4,VECTOR_CMD,MODUL_CMD,INT_CMD,INTVEC_CMD};
2414 if (iiCheckTypes(h,t,1))
2415 {
2416 poly f=(poly)h->Data();
2417 h=h->next;
2418 ideal m=(ideal)h->Data();
2420 h=h->next;
2421 int n=(int)((long)h->Data());
2422 h=h->next;
2423 intvec *v=(intvec *)h->Data();
2424
2425 /* == now the work starts == */
2426
2427 int * iv=iv2array(v, currRing);
2428 poly r=0;
2429 poly hp=ppJetW(f,n,iv);
2430 int s=MATCOLS(m);
2431 int j=0;
2432 matrix T=mp_InitI(s,1,0, currRing);
2433
2434 while (hp != NULL)
2435 {
2436 if (pDivisibleBy(m->m[j],hp))
2437 {
2438 if (MATELEM(T,j+1,1)==0)
2439 {
2440 MATELEM(T,j+1,1)=pDivideM(pHead(hp),pHead(m->m[j]));
2441 }
2442 else
2443 {
2444 pAdd(MATELEM(T,j+1,1),pDivideM(pHead(hp),pHead(m->m[j])));
2445 }
2446 hp=ppJetW(ksOldSpolyRed(m->m[j],hp,0),n,iv);
2447 j=0;
2448 }
2449 else
2450 {
2451 if (j==s-1)
2452 {
2453 r=pAdd(r,pHead(hp));
2454 hp=pLmDeleteAndNext(hp); /* hp=pSub(hp,pHead(hp));*/
2455 j=0;
2456 }
2457 else
2458 {
2459 j++;
2460 }
2461 }
2462 }
2463
2466 for (int k=1;k<=MATROWS(Temp);k++)
2467 {
2468 MATELEM(R,k,1)=MATELEM(Temp,k,1);
2469 }
2470
2472 L->Init(2);
2473 L->m[0].rtyp=MATRIX_CMD; L->m[0].data=(void *)R;
2474 L->m[1].rtyp=MATRIX_CMD; L->m[1].data=(void *)T;
2475 res->data=L;
2476 res->rtyp=LIST_CMD;
2477 // iv aufraeumen
2478 omFree(iv);
2479 return FALSE;
2480 }
2481 else
2482 return TRUE;
2483 }
2484 else
2485 /*==================== poly debug ==================================*/
2486 if(strcmp(sys_cmd,"p")==0)
2487 {
2488# ifdef RDEBUG
2489 p_DebugPrint((poly)h->Data(), currRing);
2490# else
2491 WarnS("Sorry: not available for release build!");
2492# endif
2493 return FALSE;
2494 }
2495 else
2496 /*==================== setsyzcomp ==================================*/
2497 if(strcmp(sys_cmd,"setsyzcomp")==0)
2498 {
2499 if ((h!=NULL) && (h->Typ()==INT_CMD))
2500 {
2501 int k = (int)(long)h->Data();
2502 if ( currRing->order[0] == ringorder_s )
2503 {
2505 }
2506 }
2507 }
2508 /*==================== ring debug ==================================*/
2509 if(strcmp(sys_cmd,"r")==0)
2510 {
2511# ifdef RDEBUG
2512 rDebugPrint((ring)h->Data());
2513# else
2514 WarnS("Sorry: not available for release build!");
2515# endif
2516 return FALSE;
2517 }
2518 else
2519 /*==================== changeRing ========================*/
2520 /* The following code changes the names of the variables in the
2521 current ring to "x1", "x2", ..., "xN", where N is the number
2522 of variables in the current ring.
2523 The purpose of this rewriting is to eliminate indexed variables,
2524 as they may cause problems when generating scripts for Magma,
2525 Maple, or Macaulay2. */
2526 if(strcmp(sys_cmd,"changeRing")==0)
2527 {
2528 int varN = currRing->N;
2529 char h[12];
2530 for (int i = 1; i <= varN; i++)
2531 {
2532 omFree(currRing->names[i - 1]);
2533 sprintf(h, "x%d", i);
2534 currRing->names[i - 1] = omStrDup(h);
2535 }
2537 res->rtyp = INT_CMD;
2538 res->data = (void*)0L;
2539 return FALSE;
2540 }
2541 else
2542 /*==================== mtrack ==================================*/
2543 if(strcmp(sys_cmd,"mtrack")==0)
2544 {
2545 #ifdef OM_TRACK
2546 om_Opts.MarkAsStatic = 1;
2547 FILE *fd = NULL;
2548 int max = 5;
2549 while (h != NULL)
2550 {
2552 if (fd == NULL && h->Typ()==STRING_CMD)
2553 {
2554 char *fn=(char*) h->Data();
2555 fd = fopen(fn, "w");
2556 if (fd == NULL)
2557 Warn("Can not open %s for writing og mtrack. Using stdout",fn);
2558 }
2559 else if (h->Typ() == INT_CMD)
2560 {
2561 max = (int)(long)h->Data();
2562 }
2563 h = h->Next();
2564 }
2565 omPrintUsedTrackAddrs((fd == NULL ? stdout : fd), max);
2566 if (fd != NULL) fclose(fd);
2567 om_Opts.MarkAsStatic = 0;
2568 return FALSE;
2569 #else
2570 WerrorS("system(\"mtrack\",..) is not implemented in this version");
2571 return TRUE;
2572 #endif
2573 }
2574 else
2575 /*==================== backtrace ==================================*/
2576 #ifndef OM_NDEBUG
2577 if(strcmp(sys_cmd,"backtrace")==0)
2578 {
2580 return FALSE;
2581 }
2582 else
2583 #endif
2584
2585#if !defined(OM_NDEBUG)
2586 /*==================== omMemoryTest ==================================*/
2587 if (strcmp(sys_cmd,"omMemoryTest")==0)
2588 {
2589
2590#ifdef OM_STATS_H
2591 PrintS("\n[om_Info]: \n");
2592 omUpdateInfo();
2593#define OM_PRINT(name) Print(" %-22s : %10ld \n", #name, om_Info . name)
2594 OM_PRINT(MaxBytesSystem);
2595 OM_PRINT(CurrentBytesSystem);
2596 OM_PRINT(MaxBytesSbrk);
2597 OM_PRINT(CurrentBytesSbrk);
2598 OM_PRINT(MaxBytesMmap);
2599 OM_PRINT(CurrentBytesMmap);
2600 OM_PRINT(UsedBytes);
2601 OM_PRINT(AvailBytes);
2602 OM_PRINT(UsedBytesMalloc);
2603 OM_PRINT(AvailBytesMalloc);
2604 OM_PRINT(MaxBytesFromMalloc);
2605 OM_PRINT(CurrentBytesFromMalloc);
2606 OM_PRINT(MaxBytesFromValloc);
2607 OM_PRINT(CurrentBytesFromValloc);
2608 OM_PRINT(UsedBytesFromValloc);
2609 OM_PRINT(AvailBytesFromValloc);
2610 OM_PRINT(MaxPages);
2611 OM_PRINT(UsedPages);
2612 OM_PRINT(AvailPages);
2613 OM_PRINT(MaxRegionsAlloc);
2614 OM_PRINT(CurrentRegionsAlloc);
2615#undef OM_PRINT
2616#endif
2617
2618#ifdef OM_OPTS_H
2619 PrintS("\n[om_Opts]: \n");
2620#define OM_PRINT(format, name) Print(" %-22s : %10" format"\n", #name, om_Opts . name)
2621 OM_PRINT("d", MinTrack);
2622 OM_PRINT("d", MinCheck);
2623 OM_PRINT("d", MaxTrack);
2624 OM_PRINT("d", MaxCheck);
2625 OM_PRINT("d", Keep);
2626 OM_PRINT("d", HowToReportErrors);
2627 OM_PRINT("d", MarkAsStatic);
2628 OM_PRINT("u", PagesPerRegion);
2629 OM_PRINT("p", OutOfMemoryFunc);
2630 OM_PRINT("p", MemoryLowFunc);
2631 OM_PRINT("p", ErrorHook);
2632#undef OM_PRINT
2633#endif
2634
2635#ifdef OM_ERROR_H
2636 Print("\n\n[om_ErrorStatus] : '%s' (%s)\n",
2639 Print("[om_InternalErrorStatus]: '%s' (%s)\n",
2642
2643#endif
2644
2645// omTestMemory(1);
2646// omtTestErrors();
2647 return FALSE;
2648 }
2649 else
2650#endif
2651 /*==================== pDivStat =============================*/
2652 #if defined(PDEBUG) || defined(PDIV_DEBUG)
2653 if(strcmp(sys_cmd,"pDivStat")==0)
2654 {
2655 extern void pPrintDivisbleByStat();
2657 return FALSE;
2658 }
2659 else
2660 #endif
2661 /*==================== red =============================*/
2662 #if 0
2663 if(strcmp(sys_cmd,"red")==0)
2664 {
2665 if ((h!=NULL) &&(h->Typ()==IDEAL_CMD))
2666 {
2667 res->rtyp=IDEAL_CMD;
2668 res->data=(void *)kStdred((ideal)h->Data(),NULL,testHomog,NULL);
2670 return FALSE;
2671 }
2672 else
2673 WerrorS("ideal expected");
2674 }
2675 else
2676 #endif
2677 /*==================== fastcomb =============================*/
2678 if(strcmp(sys_cmd,"fastcomb")==0)
2679 {
2680 if ((h!=NULL) &&(h->Typ()==IDEAL_CMD))
2681 {
2682 if (h->next!=NULL)
2683 {
2684 if (h->next->Typ()!=POLY_CMD)
2685 {
2686 WarnS("Wrong types for poly= comb(ideal,poly)");
2687 }
2688 }
2689 res->rtyp=POLY_CMD;
2690 res->data=(void *) fglmLinearCombination(
2691 (ideal)h->Data(),(poly)h->next->Data());
2692 return FALSE;
2693 }
2694 else
2695 WerrorS("ideal expected");
2696 }
2697 else
2698 /*==================== comb =============================*/
2699 if(strcmp(sys_cmd,"comb")==0)
2700 {
2701 if ((h!=NULL) &&(h->Typ()==IDEAL_CMD))
2702 {
2703 if (h->next!=NULL)
2704 {
2705 if (h->next->Typ()!=POLY_CMD)
2706 {
2707 WarnS("Wrong types for poly= comb(ideal,poly)");
2708 }
2709 }
2710 res->rtyp=POLY_CMD;
2711 res->data=(void *)fglmNewLinearCombination(
2712 (ideal)h->Data(),(poly)h->next->Data());
2713 return FALSE;
2714 }
2715 else
2716 WerrorS("ideal expected");
2717 }
2718 else
2719 #if 0 /* debug only */
2720 /*==================== listall ===================================*/
2721 if(strcmp(sys_cmd,"listall")==0)
2722 {
2723 void listall(int showproc);
2724 int showproc=0;
2725 if ((h!=NULL) && (h->Typ()==INT_CMD)) showproc=(int)((long)h->Data());
2726 listall(showproc);
2727 return FALSE;
2728 }
2729 else
2730 #endif
2731 #if 0 /* debug only */
2732 /*==================== proclist =================================*/
2733 if(strcmp(sys_cmd,"proclist")==0)
2734 {
2735 void piShowProcList();
2736 piShowProcList();
2737 return FALSE;
2738 }
2739 else
2740 #endif
2741 /* ==================== newton ================================*/
2742 #ifdef HAVE_NEWTON
2743 if(strcmp(sys_cmd,"newton")==0)
2744 {
2745 if ((h->Typ()!=POLY_CMD)
2746 || (h->next->Typ()!=INT_CMD)
2747 || (h->next->next->Typ()!=INT_CMD))
2748 {
2749 WerrorS("system(\"newton\",<poly>,<int>,<int>) expected");
2750 return TRUE;
2751 }
2752 poly p=(poly)(h->Data());
2753 int l=pLength(p);
2754 short *points=(short *)omAlloc(currRing->N*l*sizeof(short));
2755 int i,j,k;
2756 k=0;
2757 poly pp=p;
2758 for (i=0;pp!=NULL;i++)
2759 {
2760 for(j=1;j<=currRing->N;j++)
2761 {
2762 points[k]=pGetExp(pp,j);
2763 k++;
2764 }
2765 pIter(pp);
2766 }
2767 hc_ERG r=hc_KOENIG(currRing->N, // dimension
2768 l, // number of points
2769 (short*) points, // points: x_1, y_1,z_1, x_2,y_2,z2,...
2770 currRing->OrdSgn==-1,
2771 (int) (h->next->Data()), // 1: Milnor, 0: Newton
2772 (int) (h->next->next->Data()) // debug
2773 );
2774 //----<>---Output-----------------------
2775
2776
2777 // PrintS("Bin jetzt in extra.cc bei der Auswertung.\n"); // **********
2778
2779
2781 L->Init(6);
2782 L->m[0].rtyp=STRING_CMD; // newtonnumber;
2783 L->m[0].data=(void *)omStrDup(r.nZahl);
2784 L->m[1].rtyp=INT_CMD;
2785 L->m[1].data=(void *)(long)r.achse; // flag for unoccupied axes
2786 L->m[2].rtyp=INT_CMD;
2787 L->m[2].data=(void *)(long)r.deg; // #degenerations
2788 if ( r.deg != 0) // only if degenerations exist
2789 {
2790 L->m[3].rtyp=INT_CMD;
2791 L->m[3].data=(void *)(long)r.anz_punkte; // #points
2792 //---<>--number of points------
2793 int anz = r.anz_punkte; // number of points
2794 int dim = (currRing->N); // dimension
2795 intvec* v = new intvec( anz*dim );
2796 for (i=0; i<anz*dim; i++) // copy points
2797 (*v)[i] = r.pu[i];
2798 L->m[4].rtyp=INTVEC_CMD;
2799 L->m[4].data=(void *)v;
2800 //---<>--degenerations---------
2801 int deg = r.deg; // number of points
2802 intvec* w = new intvec( r.speicher ); // necessary memory
2803 i=0; // start copying
2804 do
2805 {
2806 (*w)[i] = r.deg_tab[i];
2807 i++;
2808 }
2809 while (r.deg_tab[i-1] != -2); // mark for end of list
2810 L->m[5].rtyp=INTVEC_CMD;
2811 L->m[5].data=(void *)w;
2812 }
2813 else
2814 {
2815 L->m[3].rtyp=INT_CMD; L->m[3].data=(char *)0;
2816 L->m[4].rtyp=DEF_CMD;
2817 L->m[5].rtyp=DEF_CMD;
2818 }
2819
2820 res->data=(void *)L;
2821 res->rtyp=LIST_CMD;
2822 // free all pointer in r:
2823 delete[] r.nZahl;
2824 delete[] r.pu;
2825 delete[] r.deg_tab; // Ist das ein Problem??
2826
2827 omFreeSize((ADDRESS)points,currRing->N*l*sizeof(short));
2828 return FALSE;
2829 }
2830 else
2831 #endif
2832 /*==== connection to Sebastian Jambor's code ======*/
2833 /* This code connects Sebastian Jambor's code for
2834 computing the minimal polynomial of an (n x n) matrix
2835 with entries in F_p to SINGULAR. Two conversion methods
2836 are needed; see further up in this file:
2837 (1) conversion of a matrix with long entries to
2838 a SINGULAR matrix with number entries, where
2839 the numbers are coefficients in currRing;
2840 (2) conversion of an array of longs (encoding the
2841 coefficients of the minimal polynomial) to a
2842 SINGULAR poly living in currRing. */
2843 if (strcmp(sys_cmd, "minpoly") == 0)
2844 {
2845 if ((h == NULL) || (h->Typ() != MATRIX_CMD) || h->next != NULL)
2846 {
2847 Werror("expected exactly one argument: %s",
2848 "a square matrix with number entries");
2849 return TRUE;
2850 }
2851 else
2852 {
2853 matrix m = (matrix)h->Data();
2854 int n = m->rows();
2855 unsigned long p = (unsigned long)n_GetChar(currRing->cf);
2856 if (n != m->cols())
2857 {
2858 WerrorS("expected exactly one argument: "
2859 "a square matrix with number entries");
2860 return TRUE;
2861 }
2862 unsigned long** ml = singularMatrixToLongMatrix(m);
2863 unsigned long* polyCoeffs = computeMinimalPolynomial(ml, n, p);
2864 poly theMinPoly = longCoeffsToSingularPoly(polyCoeffs, n);
2865 res->rtyp = POLY_CMD;
2866 res->data = (void *)theMinPoly;
2867 for (int i = 0; i < n; i++) delete[] ml[i];
2868 delete[] ml;
2869 delete[] polyCoeffs;
2870 return FALSE;
2871 }
2872 }
2873 else
2874 /*==================== sdb_flags =================*/
2875 #ifdef HAVE_SDB
2876 if (strcmp(sys_cmd, "sdb_flags") == 0)
2877 {
2878 if ((h!=NULL) && (h->Typ()==INT_CMD))
2879 {
2880 sdb_flags=(int)((long)h->Data());
2881 }
2882 else
2883 {
2884 WerrorS("system(\"sdb_flags\",`int`) expected");
2885 return TRUE;
2886 }
2887 return FALSE;
2888 }
2889 else
2890 #endif
2891 /*==================== sdb_edit =================*/
2892 #ifdef HAVE_SDB
2893 if (strcmp(sys_cmd, "sdb_edit") == 0)
2894 {
2895 if ((h!=NULL) && (h->Typ()==PROC_CMD))
2896 {
2897 procinfov p=(procinfov)h->Data();
2898 sdb_edit(p);
2899 }
2900 else
2901 {
2902 WerrorS("system(\"sdb_edit\",`proc`) expected");
2903 return TRUE;
2904 }
2905 return FALSE;
2906 }
2907 else
2908 #endif
2909 /*==================== GF =================*/
2910 #if 0 // for testing only
2911 if (strcmp(sys_cmd, "GF") == 0)
2912 {
2913 if ((h!=NULL) && (h->Typ()==POLY_CMD))
2914 {
2915 int c=rChar(currRing);
2916 setCharacteristic( c,nfMinPoly[0], currRing->parameter[0][0] );
2917 CanonicalForm F( convSingGFFactoryGF( (poly)h->Data(), currRing ) );
2918 res->rtyp=POLY_CMD;
2919 res->data=convFactoryGFSingGF( F, currRing );
2920 return FALSE;
2921 }
2922 else { WerrorS("wrong typ"); return TRUE;}
2923 }
2924 else
2925 #endif
2926 /*==================== SVD =================*/
2927 #ifdef HAVE_SVD
2928 if (strcmp(sys_cmd, "svd") == 0)
2929 {
2930 extern lists testsvd(matrix M);
2931 res->rtyp=LIST_CMD;
2932 res->data=(char*)(testsvd((matrix)h->Data()));
2933 return FALSE;
2934 }
2935 else
2936 #endif
2937 /*==================== redNF_ring =================*/
2938 #ifdef HAVE_RINGS
2939 if (strcmp(sys_cmd, "redNF_ring")==0)
2940 {
2941 ring r = currRing;
2942 poly f = (poly) h->Data();
2943 h = h->next;
2944 ideal G = (ideal) h->Data();
2945 res->rtyp=POLY_CMD;
2946 res->data=(poly) ringRedNF(f, G, r);
2947 return(FALSE);
2948 }
2949 else
2950 #endif
2951 /*==================== Roune Hilb =================*/
2952 if (strcmp(sys_cmd, "hilbroune") == 0)
2953 {
2954 if ((h!=NULL) && (h->Typ()==IDEAL_CMD))
2955 {
2956 slicehilb((ideal)h->Data());
2957 }
2958 else return TRUE;
2959 return FALSE;
2960 }
2961 else
2962 /*==================== F5 Implementation =================*/
2963 #ifdef HAVE_F5
2964 if (strcmp(sys_cmd, "f5")==0)
2965 {
2966 if (h->Typ()!=IDEAL_CMD)
2967 {
2968 WerrorS("ideal expected");
2969 return TRUE;
2970 }
2971
2972 ring r = currRing;
2973 ideal G = (ideal) h->Data();
2974 h = h->next;
2975 int opt;
2976 if(h != NULL) {
2977 opt = (int) (long) h->Data();
2978 }
2979 else {
2980 opt = 2;
2981 }
2982 h = h->next;
2983 int plus;
2984 if(h != NULL) {
2985 plus = (int) (long) h->Data();
2986 }
2987 else {
2988 plus = 0;
2989 }
2990 h = h->next;
2991 int termination;
2992 if(h != NULL) {
2993 termination = (int) (long) h->Data();
2994 }
2995 else {
2996 termination = 0;
2997 }
2998 res->rtyp=IDEAL_CMD;
2999 res->data=(ideal) F5main(G,r,opt,plus,termination);
3000 return FALSE;
3001 }
3002 else
3003 #endif
3004 /*==================== Testing groebner basis =================*/
3005 #ifdef HAVE_RINGS
3006 if (strcmp(sys_cmd, "NF_ring")==0)
3007 {
3008 ring r = currRing;
3009 poly f = (poly) h->Data();
3010 h = h->next;
3011 ideal G = (ideal) h->Data();
3012 res->rtyp=POLY_CMD;
3013 res->data=(poly) ringNF(f, G, r);
3014 return(FALSE);
3015 }
3016 else
3017 if (strcmp(sys_cmd, "spoly")==0)
3018 {
3019 poly f = pCopy((poly) h->Data());
3020 h = h->next;
3021 poly g = pCopy((poly) h->Data());
3022
3023 res->rtyp=POLY_CMD;
3024 res->data=(poly) plain_spoly(f,g);
3025 return(FALSE);
3026 }
3027 else
3028 if (strcmp(sys_cmd, "testGB")==0)
3029 {
3030 ideal I = (ideal) h->Data();
3031 h = h->next;
3032 ideal GI = (ideal) h->Data();
3033 res->rtyp = INT_CMD;
3034 res->data = (void *)(long) testGB(I, GI);
3035 return(FALSE);
3036 }
3037 else
3038 #endif
3039 /*==================== sca:AltVar ==================================*/
3040 #ifdef HAVE_PLURAL
3041 if ( (strcmp(sys_cmd, "AltVarStart") == 0) || (strcmp(sys_cmd, "AltVarEnd") == 0) )
3042 {
3043 ring r = currRing;
3044
3045 if((h!=NULL) && (h->Typ()==RING_CMD)) r = (ring)h->Data(); else
3046 {
3047 WerrorS("`system(\"AltVarStart/End\"[,<ring>])` expected");
3048 return TRUE;
3049 }
3050
3051 res->rtyp=INT_CMD;
3052
3053 if (rIsSCA(r))
3054 {
3055 if(strcmp(sys_cmd, "AltVarStart") == 0)
3056 res->data = (void*)(long)scaFirstAltVar(r);
3057 else
3058 res->data = (void*)(long)scaLastAltVar(r);
3059 return FALSE;
3060 }
3061
3062 WerrorS("`system(\"AltVarStart/End\",<ring>) requires a SCA ring");
3063 return TRUE;
3064 }
3065 else
3066 #endif
3067 /*==================== RatNF, noncomm rational coeffs =================*/
3068 #ifdef HAVE_RATGRING
3069 if (strcmp(sys_cmd, "intratNF") == 0)
3070 {
3071 poly p;
3072 poly *q;
3073 ideal I;
3074 int is, k, id;
3075 if ((h!=NULL) && (h->Typ()==POLY_CMD))
3076 {
3077 p=(poly)h->CopyD();
3078 h=h->next;
3079 // PrintS("poly is done\n");
3080 }
3081 else return TRUE;
3082 if ((h!=NULL) && (h->Typ()==IDEAL_CMD))
3083 {
3084 I=(ideal)h->CopyD();
3085 q = I->m;
3086 h=h->next;
3087 // PrintS("ideal is done\n");
3088 }
3089 else return TRUE;
3090 if ((h!=NULL) && (h->Typ()==INT_CMD))
3091 {
3092 is=(int)((long)(h->Data()));
3093 // res->rtyp=INT_CMD;
3094 // PrintS("int is done\n");
3095 // res->rtyp=IDEAL_CMD;
3097 {
3098 id = IDELEMS(I);
3099 int *pl=(int*)omAlloc0(IDELEMS(I)*sizeof(int));
3100 for(k=0; k < id; k++)
3101 {
3102 pl[k] = pLength(I->m[k]);
3103 }
3104 PrintS("starting redRat\n");
3105 //res->data = (char *)
3106 redRat(&p, q, pl, (int)IDELEMS(I),is,currRing);
3107 res->data=p;
3108 res->rtyp=POLY_CMD;
3109 // res->data = ncGCD(p,q,currRing);
3110 }
3111 else
3112 {
3113 res->rtyp=POLY_CMD;
3114 res->data=p;
3115 }
3116 }
3117 else return TRUE;
3118 return FALSE;
3119 }
3120 else
3121 /*==================== RatNF, noncomm rational coeffs =================*/
3122 if (strcmp(sys_cmd, "ratNF") == 0)
3123 {
3124 poly p,q;
3125 int is, htype;
3126 if ((h!=NULL) && ( (h->Typ()==POLY_CMD) || (h->Typ()==VECTOR_CMD) ) )
3127 {
3128 p=(poly)h->CopyD();
3129 h=h->next;
3130 htype = h->Typ();
3131 }
3132 else return TRUE;
3133 if ((h!=NULL) && ( (h->Typ()==POLY_CMD) || (h->Typ()==VECTOR_CMD) ) )
3134 {
3135 q=(poly)h->CopyD();
3136 h=h->next;
3137 }
3138 else return TRUE;
3139 if ((h!=NULL) && (h->Typ()==INT_CMD))
3140 {
3141 is=(int)((long)(h->Data()));
3142 res->rtyp=htype;
3143 // res->rtyp=IDEAL_CMD;
3145 {
3146 res->data = nc_rat_ReduceSpolyNew(q,p,is, currRing);
3147 // res->data = ncGCD(p,q,currRing);
3148 }
3149 else res->data=p;
3150 }
3151 else return TRUE;
3152 return FALSE;
3153 }
3154 else
3155 /*==================== RatSpoly, noncomm rational coeffs =================*/
3156 if (strcmp(sys_cmd, "ratSpoly") == 0)
3157 {
3158 poly p,q;
3159 int is;
3160 if ((h!=NULL) && (h->Typ()==POLY_CMD))
3161 {
3162 p=(poly)h->CopyD();
3163 h=h->next;
3164 }
3165 else return TRUE;
3166 if ((h!=NULL) && (h->Typ()==POLY_CMD))
3167 {
3168 q=(poly)h->CopyD();
3169 h=h->next;
3170 }
3171 else return TRUE;
3172 if ((h!=NULL) && (h->Typ()==INT_CMD))
3173 {
3174 is=(int)((long)(h->Data()));
3175 res->rtyp=POLY_CMD;
3176 // res->rtyp=IDEAL_CMD;
3178 {
3179 res->data = nc_rat_CreateSpoly(p,q,is,currRing);
3180 // res->data = ncGCD(p,q,currRing);
3181 }
3182 else res->data=p;
3183 }
3184 else return TRUE;
3185 return FALSE;
3186 }
3187 else
3188 #endif // HAVE_RATGRING
3189 /*==================== Rat def =================*/
3190 if (strcmp(sys_cmd, "ratVar") == 0)
3191 {
3192 int start,end;
3193 if ((h!=NULL) && (h->Typ()==POLY_CMD))
3194 {
3195 start=pIsPurePower((poly)h->Data());
3196 h=h->next;
3197 }
3198 else return TRUE;
3199 if ((h!=NULL) && (h->Typ()==POLY_CMD))
3200 {
3201 end=pIsPurePower((poly)h->Data());
3202 h=h->next;
3203 }
3204 else return TRUE;
3205 currRing->real_var_start=start;
3206 currRing->real_var_end=end;
3207 return (start==0)||(end==0)||(start>end);
3208 }
3209 else
3210 /*==================== t-rep-GB ==================================*/
3211 if (strcmp(sys_cmd, "unifastmult")==0)
3212 {
3213 poly f = (poly)h->Data();
3214 h=h->next;
3215 poly g=(poly)h->Data();
3216 res->rtyp=POLY_CMD;
3217 res->data=unifastmult(f,g,currRing);
3218 return(FALSE);
3219 }
3220 else
3221 if (strcmp(sys_cmd, "multifastmult")==0)
3222 {
3223 poly f = (poly)h->Data();
3224 h=h->next;
3225 poly g=(poly)h->Data();
3226 res->rtyp=POLY_CMD;
3227 res->data=multifastmult(f,g,currRing);
3228 return(FALSE);
3229 }
3230 else
3231 if (strcmp(sys_cmd, "mults")==0)
3232 {
3233 res->rtyp=INT_CMD ;
3234 res->data=(void*)(long) Mults();
3235 return(FALSE);
3236 }
3237 else
3238 if (strcmp(sys_cmd, "fastpower")==0)
3239 {
3240 ring r = currRing;
3241 poly f = (poly)h->Data();
3242 h=h->next;
3243 int n=(int)((long)h->Data());
3244 res->rtyp=POLY_CMD ;
3245 res->data=(void*) pFastPower(f,n,r);
3246 return(FALSE);
3247 }
3248 else
3249 if (strcmp(sys_cmd, "normalpower")==0)
3250 {
3251 poly f = (poly)h->Data();
3252 h=h->next;
3253 int n=(int)((long)h->Data());
3254 res->rtyp=POLY_CMD ;
3255 res->data=(void*) pPower(pCopy(f),n);
3256 return(FALSE);
3257 }
3258 else
3259 if (strcmp(sys_cmd, "MCpower")==0)
3260 {
3261 ring r = currRing;
3262 poly f = (poly)h->Data();
3263 h=h->next;
3264 int n=(int)((long)h->Data());
3265 res->rtyp=POLY_CMD ;
3266 res->data=(void*) pFastPowerMC(f,n,r);
3267 return(FALSE);
3268 }
3269 else
3270 if (strcmp(sys_cmd, "bit_subst")==0)
3271 {
3272 ring r = currRing;
3273 poly outer = (poly)h->Data();
3274 h=h->next;
3275 poly inner=(poly)h->Data();
3276 res->rtyp=POLY_CMD ;
3277 res->data=(void*) uni_subst_bits(outer, inner,r);
3278 return(FALSE);
3279 }
3280 else
3281 /*==================== gcd-varianten =================*/
3282 if (strcmp(sys_cmd, "gcd") == 0)
3283 {
3284 if (h==NULL)
3285 {
3286 #if 0
3287 Print("FLINT_P:%d (use Flints gcd for polynomials in char p)\n",isOn(SW_USE_FL_GCD_P));
3288 Print("FLINT_0:%d (use Flints gcd for polynomials in char 0)\n",isOn(SW_USE_FL_GCD_0));
3289 #endif
3290 Print("EZGCD:%d (use EZGCD for gcd of polynomials in char 0)\n",isOn(SW_USE_EZGCD));
3291 Print("EZGCD_P:%d (use EZGCD_P for gcd of polynomials in char p)\n",isOn(SW_USE_EZGCD_P));
3292 Print("CRGCD:%d (use chinese Remainder for gcd of polynomials in char 0)\n",isOn(SW_USE_CHINREM_GCD));
3293 #ifndef __CYGWIN__
3294 Print("homog:%d (use homog. test for factorization of polynomials)\n",singular_homog_flag);
3295 #endif
3296 return FALSE;
3297 }
3298 else
3299 if ((h!=NULL) && (h->Typ()==STRING_CMD)
3300 && (h->next!=NULL) && (h->next->Typ()==INT_CMD))
3301 {
3302 int d=(int)(long)h->next->Data();
3303 char *s=(char *)h->Data();
3304 #if 0
3305 if (strcmp(s,"FLINT_P")==0) { if (d) On(SW_USE_FL_GCD_P); else Off(SW_USE_FL_GCD_P); } else
3306 if (strcmp(s,"FLINT_0")==0) { if (d) On(SW_USE_FL_GCD_0); else Off(SW_USE_FL_GCD_0); } else
3307 #endif
3308 if (strcmp(s,"EZGCD")==0) { if (d) On(SW_USE_EZGCD); else Off(SW_USE_EZGCD); } else
3309 if (strcmp(s,"EZGCD_P")==0) { if (d) On(SW_USE_EZGCD_P); else Off(SW_USE_EZGCD_P); } else
3310 if (strcmp(s,"CRGCD")==0) { if (d) On(SW_USE_CHINREM_GCD); else Off(SW_USE_CHINREM_GCD); } else
3311 #ifndef __CYGWIN__
3312 if (strcmp(s,"homog")==0) { if (d) singular_homog_flag=1; else singular_homog_flag=0; } else
3313 #endif
3314 return TRUE;
3315 return FALSE;
3316 }
3317 else return TRUE;
3318 }
3319 else
3320 /*==================== subring =================*/
3321 if (strcmp(sys_cmd, "subring") == 0)
3322 {
3323 if (h!=NULL)
3324 {
3325 extern ring rSubring(ring r,leftv v); /* ipshell.cc*/
3326 res->data=(char *)rSubring(currRing,h);
3327 res->rtyp=RING_CMD;
3328 return res->data==NULL;
3329 }
3330 else return TRUE;
3331 }
3332 else
3333 /*==================== HNF =================*/
3334 #ifdef HAVE_NTL
3335 if (strcmp(sys_cmd, "HNF") == 0)
3336 {
3337 if (h!=NULL)
3338 {
3339 res->rtyp=h->Typ();
3340 if (h->Typ()==MATRIX_CMD)
3341 {
3342 res->data=(char *)singntl_HNF((matrix)h->Data(), currRing);
3343 return FALSE;
3344 }
3345 else if (h->Typ()==INTMAT_CMD)
3346 {
3347 res->data=(char *)singntl_HNF((intvec*)h->Data());
3348 return FALSE;
3349 }
3350 else if (h->Typ()==INTMAT_CMD)
3351 {
3352 res->data=(char *)singntl_HNF((intvec*)h->Data());
3353 return FALSE;
3354 }
3355 else
3356 {
3357 WerrorS("expected `system(\"HNF\",<matrix|intmat|bigintmat>)`");
3358 return TRUE;
3359 }
3360 }
3361 else return TRUE;
3362 }
3363 else
3364 /*================= probIrredTest ======================*/
3365 if (strcmp (sys_cmd, "probIrredTest") == 0)
3366 {
3367 if (h!=NULL && (h->Typ()== POLY_CMD) && ((h->next != NULL) && h->next->Typ() == STRING_CMD))
3368 {
3369 CanonicalForm F= convSingPFactoryP((poly)(h->Data()), currRing);
3370 char *s=(char *)h->next->Data();
3371 double error= atof (s);
3372 int irred= probIrredTest (F, error);
3373 res->rtyp= INT_CMD;
3374 res->data= (void*)(long)irred;
3375 return FALSE;
3376 }
3377 else return TRUE;
3378 }
3379 else
3380 #endif
3381 /*==================== mpz_t loader ======================*/
3382 if(strcmp(sys_cmd, "GNUmpLoad")==0)
3383 {
3384 if ((h != NULL) && (h->Typ() == STRING_CMD))
3385 {
3386 char* filename = (char*)h->Data();
3387 FILE* f = fopen(filename, "r");
3388 if (f == NULL)
3389 {
3390 WerrorS( "invalid file name (in paths use '/')");
3391 return FALSE;
3392 }
3393 mpz_t m; mpz_init(m);
3394 mpz_inp_str(m, f, 10);
3395 fclose(f);
3396 number n = n_InitMPZ(m, coeffs_BIGINT);
3397 res->rtyp = BIGINT_CMD;
3398 res->data = (void*)n;
3399 return FALSE;
3400 }
3401 else
3402 {
3403 WerrorS( "expected valid file name as a string");
3404 return TRUE;
3405 }
3406 }
3407 else
3408 /*==================== intvec matching ======================*/
3409 /* Given two non-empty intvecs, the call
3410 'system("intvecMatchingSegments", ivec, jvec);'
3411 computes all occurences of jvec in ivec, i.e., it returns
3412 a list of int indices k such that ivec[k..size(jvec)+k-1] = jvec.
3413 If no such k exists (e.g. when ivec is shorter than jvec), an
3414 intvec with the single entry 0 is being returned. */
3415 if(strcmp(sys_cmd, "intvecMatchingSegments")==0)
3416 {
3417 if ((h != NULL) && (h->Typ() == INTVEC_CMD) &&
3418 (h->next != NULL) && (h->next->Typ() == INTVEC_CMD) &&
3419 (h->next->next == NULL))
3420 {
3421 intvec* ivec = (intvec*)h->Data();
3422 intvec* jvec = (intvec*)h->next->Data();
3423 intvec* r = new intvec(1); (*r)[0] = 0;
3424 int validEntries = 0;
3425 for (int k = 0; k <= ivec->rows() - jvec->rows(); k++)
3426 {
3427 if (memcmp(&(*ivec)[k], &(*jvec)[0],
3428 sizeof(int) * jvec->rows()) == 0)
3429 {
3430 if (validEntries == 0)
3431 (*r)[0] = k + 1;
3432 else
3433 {
3434 r->resize(validEntries + 1);
3435 (*r)[validEntries] = k + 1;
3436 }
3437 validEntries++;
3438 }
3439 }
3440 res->rtyp = INTVEC_CMD;
3441 res->data = (void*)r;
3442 return FALSE;
3443 }
3444 else
3445 {
3446 WerrorS("expected two non-empty intvecs as arguments");
3447 return TRUE;
3448 }
3449 }
3450 else
3451 /* ================== intvecOverlap ======================= */
3452 /* Given two non-empty intvecs, the call
3453 'system("intvecOverlap", ivec, jvec);'
3454 computes the longest intvec kvec such that ivec ends with kvec
3455 and jvec starts with kvec. The length of this overlap is being
3456 returned. If there is no overlap at all, then 0 is being returned. */
3457 if(strcmp(sys_cmd, "intvecOverlap")==0)
3458 {
3459 if ((h != NULL) && (h->Typ() == INTVEC_CMD) &&
3460 (h->next != NULL) && (h->next->Typ() == INTVEC_CMD) &&
3461 (h->next->next == NULL))
3462 {
3463 intvec* ivec = (intvec*)h->Data();
3464 intvec* jvec = (intvec*)h->next->Data();
3465 int ir = ivec->rows(); int jr = jvec->rows();
3466 int r = jr; if (ir < jr) r = ir; /* r = min{ir, jr} */
3467 while ((r >= 1) && (memcmp(&(*ivec)[ir - r], &(*jvec)[0],
3468 sizeof(int) * r) != 0))
3469 r--;
3470 res->rtyp = INT_CMD;
3471 res->data = (void*)(long)r;
3472 return FALSE;
3473 }
3474 else
3475 {
3476 WerrorS("expected two non-empty intvecs as arguments");
3477 return TRUE;
3478 }
3479 }
3480 else
3481 /*==================== Hensel's lemma ======================*/
3482 if(strcmp(sys_cmd, "henselfactors")==0)
3483 {
3484 if ((h != NULL) && (h->Typ() == INT_CMD) &&
3485 (h->next != NULL) && (h->next->Typ() == INT_CMD) &&
3486 (h->next->next != NULL) && (h->next->next->Typ() == POLY_CMD) &&
3487 (h->next->next->next != NULL) &&
3488 (h->next->next->next->Typ() == POLY_CMD) &&
3489 (h->next->next->next->next != NULL) &&
3490 (h->next->next->next->next->Typ() == POLY_CMD) &&
3491 (h->next->next->next->next->next != NULL) &&
3492 (h->next->next->next->next->next->Typ() == INT_CMD) &&
3493 (h->next->next->next->next->next->next == NULL))
3494 {
3495 int xIndex = (int)(long)h->Data();
3496 int yIndex = (int)(long)h->next->Data();
3497 poly hh = (poly)h->next->next->Data();
3498 poly f0 = (poly)h->next->next->next->Data();
3499 poly g0 = (poly)h->next->next->next->next->Data();
3500 int d = (int)(long)h->next->next->next->next->next->Data();
3501 poly f; poly g;
3502 henselFactors(xIndex, yIndex, hh, f0, g0, d, f, g);
3504 L->Init(2);
3505 L->m[0].rtyp = POLY_CMD; L->m[0].data=(void*)f;
3506 L->m[1].rtyp = POLY_CMD; L->m[1].data=(void*)g;
3507 res->rtyp = LIST_CMD;
3508 res->data = (char *)L;
3509 return FALSE;
3510 }
3511 else
3512 {
3513 WerrorS( "expected argument list (int, int, poly, poly, poly, int)");
3514 return TRUE;
3515 }
3516 }
3517 else
3518 /*==================== Approx_Step =================*/
3519 #ifdef HAVE_PLURAL
3520 if (strcmp(sys_cmd, "astep") == 0)
3521 {
3522 ideal I;
3523 if ((h!=NULL) && (h->Typ()==IDEAL_CMD))
3524 {
3525 I=(ideal)h->CopyD();
3526 res->rtyp=IDEAL_CMD;
3527 if (rIsPluralRing(currRing)) res->data=Approx_Step(I);
3528 else res->data=I;
3530 }
3531 else return TRUE;
3532 return FALSE;
3533 }
3534 else
3535 #endif
3536 /*==================== PrintMat =================*/
3537 #ifdef HAVE_PLURAL
3538 if (strcmp(sys_cmd, "PrintMat") == 0)
3539 {
3540 int a;
3541 int b;
3542 ring r;
3543 int metric;
3544 if (h!=NULL)
3545 {
3546 if (h->Typ()==INT_CMD)
3547 {
3548 a=(int)((long)(h->Data()));
3549 h=h->next;
3550 }
3551 else if (h->Typ()==INT_CMD)
3552 {
3553 b=(int)((long)(h->Data()));
3554 h=h->next;
3555 }
3556 else if (h->Typ()==RING_CMD)
3557 {
3558 r=(ring)h->Data();
3559 h=h->next;
3560 }
3561 else
3562 return TRUE;
3563 }
3564 else
3565 return TRUE;
3566 if ((h!=NULL) && (h->Typ()==INT_CMD))
3567 {
3568 metric=(int)((long)(h->Data()));
3569 }
3570 res->rtyp=MATRIX_CMD;
3571 if (rIsPluralRing(r)) res->data=nc_PrintMat(a,b,r,metric);
3572 else res->data=NULL;
3573 return FALSE;
3574 }
3575 else
3576 #endif
3577/* ============ NCUseExtensions ======================== */
3578 #ifdef HAVE_PLURAL
3579 if(strcmp(sys_cmd,"NCUseExtensions")==0)
3580 {
3581 if ((h!=NULL) && (h->Typ()==INT_CMD))
3582 res->data=(void *)(long)setNCExtensions( (int)((long)(h->Data())) );
3583 else
3584 res->data=(void *)(long)getNCExtensions();
3585 res->rtyp=INT_CMD;
3586 return FALSE;
3587 }
3588 else
3589 #endif
3590/* ============ NCGetType ======================== */
3591 #ifdef HAVE_PLURAL
3592 if(strcmp(sys_cmd,"NCGetType")==0)
3593 {
3594 res->rtyp=INT_CMD;
3595 if( rIsPluralRing(currRing) )
3596 res->data=(void *)(long)ncRingType(currRing);
3597 else
3598 res->data=(void *)(-1L);
3599 return FALSE;
3600 }
3601 else
3602 #endif
3603/* ============ ForceSCA ======================== */
3604 #ifdef HAVE_PLURAL
3605 if(strcmp(sys_cmd,"ForceSCA")==0)
3606 {
3607 if( !rIsPluralRing(currRing) )
3608 return TRUE;
3609 int b, e;
3610 if ((h!=NULL) && (h->Typ()==INT_CMD))
3611 {
3612 b = (int)((long)(h->Data()));
3613 h=h->next;
3614 }
3615 else return TRUE;
3616 if ((h!=NULL) && (h->Typ()==INT_CMD))
3617 {
3618 e = (int)((long)(h->Data()));
3619 }
3620 else return TRUE;
3621 if( !sca_Force(currRing, b, e) )
3622 return TRUE;
3623 return FALSE;
3624 }
3625 else
3626 #endif
3627/* ============ ForceNewNCMultiplication ======================== */
3628 #ifdef HAVE_PLURAL
3629 if(strcmp(sys_cmd,"ForceNewNCMultiplication")==0)
3630 {
3631 if( !rIsPluralRing(currRing) )
3632 return TRUE;
3633 if( !ncInitSpecialPairMultiplication(currRing) ) // No Plural!
3634 return TRUE;
3635 return FALSE;
3636 }
3637 else
3638 #endif
3639/* ============ ForceNewOldNCMultiplication ======================== */
3640 #ifdef HAVE_PLURAL
3641 if(strcmp(sys_cmd,"ForceNewOldNCMultiplication")==0)
3642 {
3643 if( !rIsPluralRing(currRing) )
3644 return TRUE;
3645 if( !ncInitSpecialPowersMultiplication(currRing) ) // Enable Formula for Plural (depends on swiches)!
3646 return TRUE;
3647 return FALSE;
3648 }
3649 else
3650 #endif
3651/*==================== test64 =================*/
3652 #if 0
3653 if(strcmp(sys_cmd,"test64")==0)
3654 {
3655 long l=8;int i;
3656 for(i=1;i<62;i++)
3657 {
3658 l=l<<1;
3659 number n=n_Init(l,coeffs_BIGINT);
3660 Print("%ld= ",l);n_Print(n,coeffs_BIGINT);
3664 PrintS(" F:");
3666 PrintLn();
3668 }
3669 Print("SIZEOF_LONG=%d\n",SIZEOF_LONG);
3670 return FALSE;
3671 }
3672 else
3673 #endif
3674/*==================== n_SwitchChinRem =================*/
3675 if(strcmp(sys_cmd,"cache_chinrem")==0)
3676 {
3678 Print("caching inverse in chines remainder:%d\n",n_SwitchChinRem);
3679 if ((h!=NULL)&&(h->Typ()==INT_CMD))
3680 n_SwitchChinRem=(int)(long)h->Data();
3681 return FALSE;
3682 }
3683 else
3684/*==================== LU for bigintmat =================*/
3685#ifdef SINGULAR_4_2
3686 if(strcmp(sys_cmd,"LU")==0)
3687 {
3688 if ((h!=NULL) && (h->Typ()==CMATRIX_CMD))
3689 {
3690 // get the argument:
3691 bigintmat *b=(bigintmat *)h->Data();
3692 // just for tests: simply transpose
3693 bigintmat *bb=b->transpose();
3694 // return the result:
3695 res->rtyp=CMATRIX_CMD;
3696 res->data=(char*)bb;
3697 return FALSE;
3698 }
3699 else
3700 {
3701 WerrorS("system(\"LU\",<cmatrix>) expected");
3702 return TRUE;
3703 }
3704 }
3705 else
3706#endif
3707/*==================== sort =================*/
3708 if(strcmp(sys_cmd,"sort")==0)
3709 {
3710 extern BOOLEAN jjSORTLIST(leftv,leftv);
3711 if (h->Typ()==LIST_CMD)
3712 return jjSORTLIST(res,h);
3713 else
3714 return TRUE;
3715 }
3716 else
3717/*==================== uniq =================*/
3718 if(strcmp(sys_cmd,"uniq")==0)
3719 {
3720 extern BOOLEAN jjUNIQLIST(leftv, leftv);
3721 if (h->Typ()==LIST_CMD)
3722 return jjUNIQLIST(res,h);
3723 else
3724 return TRUE;
3725 }
3726 else
3727/*==================== GF(p,n) ==================================*/
3728 if(strcmp(sys_cmd,"GF")==0)
3729 {
3730 const short t[]={3,INT_CMD,INT_CMD,STRING_CMD};
3731 if (iiCheckTypes(h,t,1))
3732 {
3733 int p=(int)(long)h->Data();
3734 int n=(int)(long)h->next->Data();
3735 char *v=(char*)h->next->next->CopyD();
3736 GFInfo param;
3737 param.GFChar = p;
3738 param.GFDegree = n;
3739 param.GFPar_name = v;
3740 coeffs cf= nInitChar(n_GF, &param);
3741 res->rtyp=CRING_CMD;
3742 res->data=cf;
3743 return FALSE;
3744 }
3745 else
3746 return TRUE;
3747 }
3748 else
3749/*==================== power* ==================================*/
3750 #if 0
3751 if(strcmp(sys_cmd,"power1")==0)
3752 {
3753 res->rtyp=POLY_CMD;
3754 poly f=(poly)h->CopyD();
3755 poly g=pPower(f,2000);
3756 res->data=(void *)g;
3757 return FALSE;
3758 }
3759 else
3760 if(strcmp(sys_cmd,"power2")==0)
3761 {
3762 res->rtyp=POLY_CMD;
3763 poly f=(poly)h->Data();
3764 poly g=pOne();
3765 for(int i=0;i<2000;i++)
3766 g=pMult(g,pCopy(f));
3767 res->data=(void *)g;
3768 return FALSE;
3769 }
3770 if(strcmp(sys_cmd,"power3")==0)
3771 {
3772 res->rtyp=POLY_CMD;
3773 poly f=(poly)h->Data();
3774 poly p2=pMult(pCopy(f),pCopy(f));
3775 poly p4=pMult(pCopy(p2),pCopy(p2));
3776 poly p8=pMult(pCopy(p4),pCopy(p4));
3777 poly p16=pMult(pCopy(p8),pCopy(p8));
3778 poly p32=pMult(pCopy(p16),pCopy(p16));
3779 poly p64=pMult(pCopy(p32),pCopy(p32));
3780 poly p128=pMult(pCopy(p64),pCopy(p64));
3781 poly p256=pMult(pCopy(p128),pCopy(p128));
3782 poly p512=pMult(pCopy(p256),pCopy(p256));
3783 poly p1024=pMult(pCopy(p512),pCopy(p512));
3784 poly p1536=pMult(p1024,p512);
3785 poly p1792=pMult(p1536,p256);
3786 poly p1920=pMult(p1792,p128);
3787 poly p1984=pMult(p1920,p64);
3788 poly p2000=pMult(p1984,p16);
3789 res->data=(void *)p2000;
3790 pDelete(&p2);
3791 pDelete(&p4);
3792 pDelete(&p8);
3793 //pDelete(&p16);
3794 pDelete(&p32);
3795 //pDelete(&p64);
3796 //pDelete(&p128);
3797 //pDelete(&p256);
3798 //pDelete(&p512);
3799 //pDelete(&p1024);
3800 //pDelete(&p1536);
3801 //pDelete(&p1792);
3802 //pDelete(&p1920);
3803 //pDelete(&p1984);
3804 return FALSE;
3805 }
3806 else
3807 #endif
3808/* ccluster --------------------------------------------------------------*/
3809#ifdef HAVE_CCLUSTER
3810 if(strcmp(sys_cmd,"ccluster")==0)
3811 {
3812 if ((currRing!=NULL)
3814 {
3817
3818// printf("test t : %d\n", h->Typ()==POLY_CMD);
3819// printf("test t : %d\n", h->next->Typ()==POLY_CMD);
3820 int pol_with_complex_coeffs=0;
3821 if (h->next->Typ()==POLY_CMD)
3822 pol_with_complex_coeffs=1;
3823
3824 if ( (pol_with_complex_coeffs==0 && iiCheckTypes(h,t,1))
3825 ||(pol_with_complex_coeffs==1 && iiCheckTypes(h,t2,1)) )
3826 {
3827 // convert first arg. to fmpq_poly_t
3828 fmpq_poly_t fre, fim;
3829 convSingPFlintP(fre,(poly)h->Data(),currRing); h=h->next;
3830 if (pol_with_complex_coeffs==1)
3831 { // convert second arg. to fmpq_poly_t
3832 convSingPFlintP(fim,(poly)h->Data(),currRing); h=h->next;
3833 }
3834 // convert box-center(re,im), box-size, epsilon
3835 fmpq_t center_re,center_im,boxsize,eps;
3836 convSingNFlintN(center_re,(number)h->Data(),currRing->cf); h=h->next;
3837 convSingNFlintN(center_im,(number)h->Data(),currRing->cf); h=h->next;
3838 convSingNFlintN(boxsize,(number)h->Data(),currRing->cf); h=h->next;
3839 convSingNFlintN(eps,(number)h->Data(),currRing->cf); h=h->next;
3840 // alloc arrays
3841 int n=fmpq_poly_length(fre);
3842 fmpq_t* re_part=(fmpq_t*)omAlloc(n*sizeof(fmpq_t));
3843 fmpq_t* im_part=(fmpq_t*)omAlloc(n*sizeof(fmpq_t));
3844 int *mult =(int*) omAlloc(n*sizeof(int));
3845 for(int i=0; i<n;i++)
3846 { fmpq_init(re_part[i]); fmpq_init(im_part[i]); }
3847 // call cccluster, adjust n
3848 int verbosity =0; //nothing is printed
3849 int strategy = 23; //default strategy
3850 int nn=0;
3851 long nb_threads = (long) feOptValue(FE_OPT_CPUS);
3852 strategy = strategy+(nb_threads<<6);
3853// printf("nb threads: %ld\n", nb_threads);
3854// printf("strategy: %ld\n", strategy);
3855 if (pol_with_complex_coeffs==0)
3856 nn=ccluster_interface_poly_real(re_part,im_part,mult,fre,center_re,center_im,boxsize,eps,strategy,verbosity);
3857 else
3858 nn=ccluster_interface_poly_real_imag(re_part,im_part,mult,fre,fim,center_re,center_im,boxsize,eps,strategy,verbosity);
3859 // convert to list
3861 l->Init(nn);
3862 for(int i=0; i<nn;i++)
3863 {
3865 l->m[i].rtyp=LIST_CMD;
3866 l->m[i].data=ll;
3867 ll->Init(3);
3868 ll->m[0].rtyp=NUMBER_CMD;
3869 ll->m[1].rtyp=NUMBER_CMD;
3870 ll->m[2].rtyp=INT_CMD;
3871 ll->m[0].data=convFlintNSingN(re_part[i],currRing->cf);
3872 ll->m[1].data=convFlintNSingN(im_part[i],currRing->cf);
3873 ll->m[2].data=(void *)(long)mult[i];
3874 }
3875 //clear re, im, mults, fre, fim
3876 for(int i=n-1;i>=0;i--) { fmpq_clear(re_part[i]); fmpq_clear(im_part[i]); }
3877 omFree(re_part);
3878 omFree(im_part);
3879 omFree(mult);
3880 fmpq_clear(center_re); fmpq_clear(center_im); fmpq_clear(boxsize); fmpq_clear(eps);
3881 fmpq_poly_clear(fre);
3882 if (pol_with_complex_coeffs==1) fmpq_poly_clear(fim);
3883 // result
3884 res->rtyp=LIST_CMD;
3885 res->data=l;
3886 return FALSE;
3887 }
3888 }
3889 return TRUE;
3890 }
3891 else
3892#endif
3893/* ====== maEvalAt ============================*/
3894 if(strcmp(sys_cmd,"evaluate")==0)
3895 {
3896 extern number maEvalAt(const poly p,const number* pt, const ring r);
3897 if (h->Typ()!=POLY_CMD)
3898 {
3899 WerrorS("expected system(\"evaluate\",<poly>,..)");
3900 return TRUE;
3901 }
3902 poly p=(poly)h->Data();
3903 number *pt=(number*)omAlloc(sizeof(number)*currRing->N);
3904 for(int i=0;i<currRing->N;i++)
3905 {
3906 h=h->next;
3907 if ((h==NULL)||(h->Typ()!=NUMBER_CMD))
3908 {
3909 WerrorS("system(\"evaluate\",<poly>,<number>..) - expect number");
3910 return TRUE;
3911 }
3912 pt[i]=(number)h->Data();
3913 }
3914 res->data=maEvalAt(p,pt,currRing);
3915 res->rtyp=NUMBER_CMD;
3916 return FALSE;
3917 }
3918 else
3919/* ====== DivRem ============================*/
3920 if(strcmp(sys_cmd,"DivRem")==0)
3921 {
3922 const short t1[]={2,POLY_CMD,POLY_CMD};
3923 if (iiCheckTypes(h,t1,1))
3924 {
3925 poly p=(poly)h->CopyD();
3926 poly q=(poly)h->next->CopyD();
3927 poly rest;
3928 res->data=p_DivRem(p,q,rest,currRing);
3929 res->rtyp=POLY_CMD;
3930 Print("rest:");pWrite(rest);
3931 return FALSE;
3932 }
3933 else
3934 {
3935 WerrorS("expected system(\"DivRem\",<poly>,<poly>)");
3936 return TRUE;
3937 }
3938 }
3939 else
3940/*==================== Error =================*/
3941 Werror( "(extended) system(\"%s\",...) %s", sys_cmd, feNotImplemented );
3942 }
3943 return TRUE;
3944}
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
void * ADDRESS
Definition: auxiliary.h:119
lists testsvd(matrix M)
Definition: calcSVD.cc:27
bool isOn(int sw)
switches
void On(int sw)
switches
void Off(int sw)
switches
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:676
void FACTORY_PUBLIC setCharacteristic(int c)
Definition: cf_char.cc:28
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
int i
Definition: cfEzgcd.cc:132
int k
Definition: cfEzgcd.cc:99
int p
Definition: cfModGcd.cc:4077
g
Definition: cfModGcd.cc:4089
CanonicalForm cf
Definition: cfModGcd.cc:4082
CanonicalForm b
Definition: cfModGcd.cc:4102
EXTERN_VAR int singular_homog_flag
Definition: cf_algorithm.h:65
static const int SW_USE_CHINREM_GCD
set to 1 to use modular gcd over Z
Definition: cf_defs.h:41
static const int SW_USE_FL_GCD_P
set to 1 to use Flints gcd over F_p
Definition: cf_defs.h:47
static const int SW_USE_EZGCD_P
set to 1 to use EZGCD over F_q
Definition: cf_defs.h:37
static const int SW_USE_EZGCD
set to 1 to use EZGCD over Z
Definition: cf_defs.h:35
static const int SW_USE_FL_GCD_0
set to 1 to use Flints gcd over Q/Z
Definition: cf_defs.h:49
FILE * f
Definition: checklibs.c:9
CanonicalForm convSingPFactoryP(poly p, const ring r)
Definition: clapconv.cc:136
matrix singntl_HNF(matrix m, const ring s)
Definition: clapsing.cc:1794
factory's main class
Definition: canonicalform.h:86
Matrices of numbers.
Definition: bigintmat.h:51
Definition: intvec.h:23
void resize(int new_length)
Definition: intvec.cc:106
int rows() const
Definition: intvec.h:96
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
int rtyp
Definition: subexpr.h:91
void * data
Definition: subexpr.h:88
Definition: lists.h:24
sleftv * m
Definition: lists.h:46
INLINE_THIS void Init(int l=0)
int GFDegree
Definition: coeffs.h:95
@ n_GF
\GF{p^n < 2^16}
Definition: coeffs.h:32
static FORCE_INLINE number n_convFactoryNSingN(const CanonicalForm n, const coeffs r)
Definition: coeffs.h:978
void n_Print(number &a, const coeffs r)
print a number (BEWARE of string buffers!) mostly for debugging
Definition: numbers.cc:621
static FORCE_INLINE CanonicalForm n_convSingNFactoryN(number n, BOOLEAN setChar, const coeffs r)
Definition: coeffs.h:981
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:354
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:444
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
static FORCE_INLINE number n_InitMPZ(mpz_t n, const coeffs r)
conversion of a GMP integer to number
Definition: coeffs.h:542
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:538
const char * GFPar_name
Definition: coeffs.h:96
int GFChar
Definition: coeffs.h:94
Creation data needed for finite fields.
Definition: coeffs.h:93
poly uni_subst_bits(poly outer_uni, poly inner_multi, ring r)
Definition: digitech.cc:47
#define Print
Definition: emacs.cc:80
#define Warn
Definition: emacs.cc:77
#define WarnS
Definition: emacs.cc:78
void error(const char *fmt,...)
Definition: emacs.cc:55
unsigned long ** singularMatrixToLongMatrix(matrix singularMatrix)
Definition: extra.cc:175
poly longCoeffsToSingularPoly(unsigned long *polyCoeffs, const int degree)
Definition: extra.cc:207
ideal F5main(ideal id, ring r, int opt, int plus, int termination)
Definition: f5gb.cc:1889
const CanonicalForm int s
Definition: facAbsFact.cc:51
CanonicalForm res
Definition: facAbsFact.cc:60
const CanonicalForm & w
Definition: facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
CFList int bool & irred
[in,out] Is A irreducible?
Definition: facFactorize.h:34
int j
Definition: facHensel.cc:110
int probIrredTest(const CanonicalForm &F, double error)
given some error probIrredTest detects irreducibility or reducibility of F with confidence level 1-er...
Definition: facIrredTest.cc:63
poly unifastmult(poly f, poly g, ring r)
Definition: fast_mult.cc:272
poly pFastPowerMC(poly f, int n, ring r)
Definition: fast_mult.cc:588
static int max(int a, int b)
Definition: fast_mult.cc:264
poly pFastPower(poly f, int n, ring r)
Definition: fast_mult.cc:342
int Mults()
Definition: fast_mult.cc:14
poly multifastmult(poly f, poly g, ring r)
Definition: fast_mult.cc:290
void WerrorS(const char *s)
Definition: feFopen.cc:24
static void * feOptValue(feOptIndex opt)
Definition: feOpt.h:40
STATIC_VAR int nfMinPoly[16]
Definition: ffields.cc:549
void convSingPFlintP(fmpq_poly_t res, poly p, const ring r)
void convSingNFlintN(fmpz_t f, mpz_t z)
void convFlintNSingN(mpz_t z, fmpz_t f)
number maEvalAt(const poly p, const number *pt, const ring r)
evaluate the polynomial p at the pt given by the array pt
Definition: gen_maps.cc:167
#define EXTERN_VAR
Definition: globaldefs.h:6
@ IDEAL_CMD
Definition: grammar.cc:284
@ MATRIX_CMD
Definition: grammar.cc:286
@ PROC_CMD
Definition: grammar.cc:280
@ INTMAT_CMD
Definition: grammar.cc:279
@ MODUL_CMD
Definition: grammar.cc:287
@ VECTOR_CMD
Definition: grammar.cc:292
@ NUMBER_CMD
Definition: grammar.cc:288
@ POLY_CMD
Definition: grammar.cc:289
@ RING_CMD
Definition: grammar.cc:281
void slicehilb(ideal I)
Definition: hilb.cc:1168
STATIC_VAR coordinates * points
BOOLEAN jjSORTLIST(leftv, leftv arg)
Definition: iparith.cc:10178
BOOLEAN jjUNIQLIST(leftv, leftv arg)
Definition: iparith.cc:10187
VAR coeffs coeffs_BIGINT
Definition: ipid.cc:50
#define setFlag(A, F)
Definition: ipid.h:113
#define FLAG_STD
Definition: ipid.h:106
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
Definition: ipshell.cc:6566
ring rSubring(ring org_ring, sleftv *rv)
Definition: ipshell.cc:6012
STATIC_VAR jList * T
Definition: janet.cc:30
STATIC_VAR TreeM * G
Definition: janet.cc:31
STATIC_VAR Poly * h
Definition: janet.cc:971
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
Definition: kInline.h:1185
poly fglmLinearCombination(ideal source, poly monset)
Definition: fglmcomb.cc:415
poly fglmNewLinearCombination(ideal source, poly monset)
Definition: fglmcomb.cc:153
VAR int(* test_PosInL)(const LSet set, const int length, LObject *L, const kStrategy strat)
Definition: kstd2.cc:83
VAR int(* test_PosInT)(const TSet T, const int tl, LObject &h)
Definition: kstd2.cc:82
int posInT17(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5456
int posInT11(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5052
int posInT1(const TSet set, const int length, LObject &p)
Definition: kutil.cc:4996
int posInT0(const TSet, const int length, LObject &)
Definition: kutil.cc:4985
int posInT2(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5024
int posInT_pLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11783
int posInT13(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5294
int posInT17_c(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5563
int posInT_EcartFDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11692
int posInT15(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5361
int posInT110(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5205
int posInT19(const TSet set, const int length, LObject &p)
Definition: kutil.cc:5690
int posInT_FDegpLength(const TSet set, const int length, LObject &p)
Definition: kutil.cc:11746
static bool rIsSCA(const ring r)
Definition: nc.h:190
int & getNCExtensions()
Definition: old.gring.cc:82
static nc_type & ncRingType(nc_struct *p)
Definition: nc.h:159
int setNCExtensions(int iMask)
Definition: old.gring.cc:87
matrix nc_PrintMat(int a, int b, ring r, int metric)
returns matrix with the info on noncomm multiplication
Definition: old.gring.cc:2394
bool sca_Force(ring rGR, int b, int e)
Definition: sca.cc:1161
void henselFactors(const int xIndex, const int yIndex, const poly h, const poly f0, const poly g0, const int d, poly &f, poly &g)
Computes a factorization of a polynomial h(x, y) in K[[x]][y] up to a certain degree in x,...
VAR omBin slists_bin
Definition: lists.cc:23
VAR int n_SwitchChinRem
Definition: longrat.cc:3095
matrix mp_Transp(matrix a, const ring R)
Definition: matpol.cc:254
matrix mp_InitI(int r, int c, int v, const ring R)
make it a v * unit matrix
Definition: matpol.cc:129
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29
ip_smatrix * matrix
Definition: matpol.h:43
#define MATROWS(i)
Definition: matpol.h:26
#define MATCOLS(i)
Definition: matpol.h:27
void mult(unsigned long *result, unsigned long *a, unsigned long *b, unsigned long p, int dega, int degb)
Definition: minpoly.cc:647
unsigned long * computeMinimalPolynomial(unsigned long **matrix, unsigned n, unsigned long p)
Definition: minpoly.cc:428
#define pIter(p)
Definition: monomials.h:37
slists * lists
Definition: mpr_numeric.h:146
The main handler for Singular numbers which are suitable for Singular polynomials.
bool ncInitSpecialPowersMultiplication(ring r)
Definition: ncSAFormula.cc:50
BOOLEAN ncInitSpecialPairMultiplication(ring r)
Definition: ncSAMult.cc:266
ideal Approx_Step(ideal L)
Ann: ???
Definition: nc.cc:250
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define omFree(addr)
Definition: omAllocDecl.h:261
#define omAlloc0(size)
Definition: omAllocDecl.h:211
void omMarkAsStaticAddr(void *addr)
omError_t om_ErrorStatus
Definition: omError.c:13
const char * omError2String(omError_t error)
Definition: omError.c:54
const char * omError2Serror(omError_t error)
Definition: omError.c:65
omError_t om_InternalErrorStatus
Definition: omError.c:14
#define NULL
Definition: omList.c:12
omOpts_t om_Opts
Definition: omOpts.c:13
#define omPrintCurrentBackTrace(fd)
Definition: omRet2Info.h:39
VAR unsigned si_opt_2
Definition: options.c:6
#define Sy_bit(x)
Definition: options.h:31
void pPrintDivisbleByStat()
Definition: pDebug.cc:413
static unsigned pLength(poly a)
Definition: p_polys.h:191
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
poly p_DivRem(poly p, poly q, poly &rest, const ring r)
Definition: polys.cc:314
#define pAdd(p, q)
Definition: polys.h:203
#define pDelete(p_ptr)
Definition: polys.h:186
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
#define pLmDeleteAndNext(p)
like pLmDelete, returns pNext(p)
Definition: polys.h:78
#define ppJetW(p, m, iv)
Definition: polys.h:369
#define pDivideM(a, b)
Definition: polys.h:294
#define pPower(p, q)
Definition: polys.h:204
#define pMult(p, q)
Definition: polys.h:207
void pWrite(poly p)
Definition: polys.h:308
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
#define pIsPurePower(p)
Definition: polys.h:248
#define pDivisibleBy(a, b)
returns TRUE, if leading monom of a divides leading monom of b i.e., if there exists a expvector c > ...
Definition: polys.h:138
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
#define pOne()
Definition: polys.h:315
poly nc_rat_CreateSpoly(poly pp1, poly pp2, int ishift, const ring r)
Definition: ratgring.cc:340
int redRat(poly *h, poly *reducer, int *red_length, int rl, int ishift, ring r)
Definition: ratgring.cc:593
poly nc_rat_ReduceSpolyNew(const poly p1, poly p2, int ishift, const ring r)
Definition: ratgring.cc:465
const char feNotImplemented[]
Definition: reporter.cc:54
void PrintS(const char *s)
Definition: reporter.cc:284
void PrintLn()
Definition: reporter.cc:310
void Werror(const char *fmt,...)
Definition: reporter.cc:189
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition: ring.cc:3395
void p_DebugPrint(poly p, const ring r)
Definition: ring.cc:4272
int rChar(ring r)
Definition: ring.cc:711
void rDebugPrint(const ring r)
Definition: ring.cc:4067
void rSetSyzComp(int k, const ring r)
Definition: ring.cc:5027
static BOOLEAN rField_is_R(const ring r)
Definition: ring.h:519
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
@ ringorder_s
s?
Definition: ring.h:76
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:507
static BOOLEAN rField_is_long_R(const ring r)
Definition: ring.h:543
poly ringNF(poly f, ideal G, ring r)
Definition: ringgb.cc:199
poly plain_spoly(poly f, poly g)
Definition: ringgb.cc:168
poly ringRedNF(poly f, ideal G, ring r)
Definition: ringgb.cc:117
int testGB(ideal I, ideal GI)
Definition: ringgb.cc:226
static short scaLastAltVar(ring r)
Definition: sca.h:25
static short scaFirstAltVar(ring r)
Definition: sca.h:18
VAR int sdb_flags
Definition: sdb.cc:31
void sdb_edit(procinfo *pi)
Definition: sdb.cc:109
int status int fd
Definition: si_signals.h:59
ideal id_Vec2Ideal(poly vec, const ring R)
#define IDELEMS(i)
Definition: simpleideals.h:23
#define R
Definition: sirandom.c:27
#define M
Definition: sirandom.c:25
@ testHomog
Definition: structs.h:38
procinfo * procinfov
Definition: structs.h:60
BOOLEAN assumeStdFlag(leftv h)
Definition: subexpr.cc:1536
@ BIGINT_CMD
Definition: tok.h:38
@ CRING_CMD
Definition: tok.h:56
@ LIST_CMD
Definition: tok.h:118
@ INTVEC_CMD
Definition: tok.h:101
@ CMATRIX_CMD
Definition: tok.h:46
@ DEF_CMD
Definition: tok.h:58
@ STRING_CMD
Definition: tok.h:185
@ INT_CMD
Definition: tok.h:96
int dim(ideal I, ring r)
int * iv2array(intvec *iv, const ring R)
Definition: weight.cc:200
#define omPrintUsedTrackAddrs(F, max)
Definition: xalloc.h:320
#define omUpdateInfo()
Definition: xalloc.h:281

◆ jjSYSTEM()

BOOLEAN jjSYSTEM ( leftv  res,
leftv  args 
)

Definition at line 229 of file extra.cc.

230{
231 if(args->Typ() == STRING_CMD)
232 {
233 const char *sys_cmd=(char *)(args->Data());
234 leftv h=args->next;
235// ONLY documented system calls go here
236// Undocumented system calls go down into jjEXTENDED_SYSTEM (#ifdef HAVE_EXTENDED_SYSTEM)
237/*==================== nblocks ==================================*/
238 if (strcmp(sys_cmd, "nblocks") == 0)
239 {
240 ring r;
241 if (h == NULL)
242 {
243 if (currRingHdl != NULL)
244 {
245 r = IDRING(currRingHdl);
246 }
247 else
248 {
249 WerrorS("no ring active");
250 return TRUE;
251 }
252 }
253 else
254 {
255 if (h->Typ() != RING_CMD)
256 {
257 WerrorS("ring expected");
258 return TRUE;
259 }
260 r = (ring) h->Data();
261 }
262 res->rtyp = INT_CMD;
263 res->data = (void*) (long)(rBlocks(r) - 1);
264 return FALSE;
265 }
266/*==================== version ==================================*/
267 if(strcmp(sys_cmd,"version")==0)
268 {
269 res->rtyp=INT_CMD;
270 res->data=(void *)SINGULAR_VERSION;
271 return FALSE;
272 }
273 else
274/*==================== alarm ==================================*/
275 if(strcmp(sys_cmd,"alarm")==0)
276 {
277 if ((h!=NULL) &&(h->Typ()==INT_CMD))
278 {
279 // standard variant -> SIGALARM (standard: abort)
280 //alarm((unsigned)h->next->Data());
281 // process time (user +system): SIGVTALARM
282 struct itimerval t,o;
283 memset(&t,0,sizeof(t));
284 t.it_value.tv_sec =(unsigned)((unsigned long)h->Data());
285 setitimer(ITIMER_VIRTUAL,&t,&o);
286 return FALSE;
287 }
288 else
289 WerrorS("int expected");
290 }
291 else
292/*==================== content ==================================*/
293 if(strcmp(sys_cmd,"content")==0)
294 {
295 if ((h!=NULL) && ((h->Typ()==POLY_CMD)||(h->Typ()==VECTOR_CMD)))
296 {
297 int t=h->Typ();
298 poly p=(poly)h->CopyD();
299 if (p!=NULL)
300 {
303 }
304 res->data=(void *)p;
305 res->rtyp=t;
306 return FALSE;
307 }
308 return TRUE;
309 }
310 else
311/*==================== cpu ==================================*/
312 if(strcmp(sys_cmd,"cpu")==0)
313 {
314 long cpu=1; //feOptValue(FE_OPT_CPUS);
315 #ifdef _SC_NPROCESSORS_ONLN
316 cpu=sysconf(_SC_NPROCESSORS_ONLN);
317 #elif defined(_SC_NPROCESSORS_CONF)
318 cpu=sysconf(_SC_NPROCESSORS_CONF);
319 #endif
320 res->data=(void *)cpu;
321 res->rtyp=INT_CMD;
322 return FALSE;
323 }
324 else
325/*==================== executable ==================================*/
326 if(strcmp(sys_cmd,"executable")==0)
327 {
328 if ((h!=NULL) && (h->Typ()==STRING_CMD))
329 {
330 char tbuf[MAXPATHLEN];
331 char *s=omFindExec((char*)h->Data(),tbuf);
332 if(s==NULL) s=(char*)"";
333 res->data=(void *)omStrDup(s);
334 res->rtyp=STRING_CMD;
335 return FALSE;
336 }
337 return TRUE;
338 }
339 else
340 /*==================== flatten =============================*/
341 if(strcmp(sys_cmd,"flatten")==0)
342 {
343 if ((h!=NULL) &&(h->Typ()==SMATRIX_CMD))
344 {
345 res->data=(char*)sm_Flatten((ideal)h->Data(),currRing);
346 res->rtyp=SMATRIX_CMD;
347 return FALSE;
348 }
349 else
350 WerrorS("smatrix expected");
351 }
352 else
353 /*==================== unflatten =============================*/
354 if(strcmp(sys_cmd,"unflatten")==0)
355 {
356 const short t1[]={2,SMATRIX_CMD,INT_CMD};
357 if (iiCheckTypes(h,t1,1))
358 {
359 res->data=(char*)sm_UnFlatten((ideal)h->Data(),(int)(long)h->next->Data(),currRing);
360 res->rtyp=SMATRIX_CMD;
361 return res->data==NULL;
362 }
363 else return TRUE;
364 }
365 else
366 /*==================== neworder =============================*/
367 if(strcmp(sys_cmd,"neworder")==0)
368 {
369 if ((h!=NULL) &&(h->Typ()==IDEAL_CMD))
370 {
371 res->rtyp=STRING_CMD;
372 res->data=(void *)singclap_neworder((ideal)h->Data(), currRing);
373 return FALSE;
374 }
375 else
376 WerrorS("ideal expected");
377 }
378 else
379/*===== nc_hilb ===============================================*/
380 // Hilbert series of non-commutative monomial algebras
381 if(strcmp(sys_cmd,"nc_hilb") == 0)
382 {
383 ideal i; int lV;
384 bool ig = FALSE;
385 bool mgrad = FALSE;
386 bool autop = FALSE;
387 int trunDegHs=0;
388 if((h != NULL)&&(h->Typ() == IDEAL_CMD))
389 i = (ideal)h->Data();
390 else
391 {
392 WerrorS("nc_Hilb:ideal expected");
393 return TRUE;
394 }
395 h = h->next;
396 if((h != NULL)&&(h->Typ() == INT_CMD))
397 lV = (int)(long)h->Data();
398 else
399 {
400 WerrorS("nc_Hilb:int expected");
401 return TRUE;
402 }
403 h = h->next;
404 while(h != NULL)
405 {
406 if((int)(long)h->Data() == 1)
407 ig = TRUE;
408 else if((int)(long)h->Data() == 2)
409 mgrad = TRUE;
410 else if(h->Typ()==STRING_CMD)
411 autop = TRUE;
412 else if(h->Typ() == INT_CMD)
413 trunDegHs = (int)(long)h->Data();
414 h = h->next;
415 }
416 if(h != NULL)
417 {
418 WerrorS("nc_Hilb:int 1,2, total degree for the truncation, and a string for printing the details are expected");
419 return TRUE;
420 }
421
422 HilbertSeries_OrbitData(i, lV, ig, mgrad, autop, trunDegHs);
423 return(FALSE);
424 }
425 else
426/* ====== verify ============================*/
427 if(strcmp(sys_cmd,"verifyGB")==0)
428 {
429 if (rIsNCRing(currRing))
430 {
431 WerrorS("system(\"verifyGB\",<ideal>,..) expects a commutative ring");
432 return TRUE;
433 }
434 if (h->Typ()!=IDEAL_CMD)
435 {
436 WerrorS("expected system(\"verifyGB\",<ideal>,..)");
437 return TRUE;
438 }
439 ideal F=(ideal)h->Data();
440 if (h->next==NULL)
441 {
442 #ifdef HAVE_VSPACE
443 int cpus = (long) feOptValue(FE_OPT_CPUS);
444 if (cpus>1)
445 res->data=(char*)(long) kVerify2(F,currRing->qideal);
446 else
447 #endif
448 res->data=(char*)(long) kVerify1(F,currRing->qideal);
449 }
450 else return TRUE;
451 res->rtyp=INT_CMD;
452 return FALSE;
453 }
454 else
455/*===== rcolon ===============================================*/
456 if(strcmp(sys_cmd,"rcolon") == 0)
457 {
458 const short t1[]={3,IDEAL_CMD,POLY_CMD,INT_CMD};
459 if (iiCheckTypes(h,t1,1))
460 {
461 ideal i = (ideal)h->Data();
462 h = h->next;
463 poly w=(poly)h->Data();
464 h = h->next;
465 int lV = (int)(long)h->Data();
466 res->rtyp = IDEAL_CMD;
467 res->data = RightColonOperation(i, w, lV);
468 return(FALSE);
469 }
470 else
471 return TRUE;
472 }
473 else
474
475/*==================== sh ==================================*/
476 if(strcmp(sys_cmd,"sh")==0)
477 {
478 if (feOptValue(FE_OPT_NO_SHELL))
479 {
480 WerrorS("shell execution is disallowed in restricted mode");
481 return TRUE;
482 }
483 res->rtyp=INT_CMD;
484 if (h==NULL) res->data = (void *)(long) system("sh");
485 else if (h->Typ()==STRING_CMD)
486 res->data = (void*)(long) system((char*)(h->Data()));
487 else
488 WerrorS("string expected");
489 return FALSE;
490 }
491 else
492/*========reduce procedure like the global one but with jet bounds=======*/
493 if(strcmp(sys_cmd,"reduce_bound")==0)
494 {
495 poly p;
496 ideal pid=NULL;
497 const short t1[]={3,POLY_CMD,IDEAL_CMD,INT_CMD};
498 const short t2[]={3,IDEAL_CMD,IDEAL_CMD,INT_CMD};
499 const short t3[]={3,VECTOR_CMD,MODUL_CMD,INT_CMD};
500 const short t4[]={3,MODUL_CMD,MODUL_CMD,INT_CMD};
501 if ((iiCheckTypes(h,t1,0))||((iiCheckTypes(h,t3,0))))
502 {
503 p = (poly)h->CopyD();
504 }
505 else if ((iiCheckTypes(h,t2,0))||(iiCheckTypes(h,t4,1)))
506 {
507 pid = (ideal)h->CopyD();
508 }
509 else return TRUE;
510 //int htype;
511 res->rtyp= h->Typ(); /*htype*/
512 ideal q = (ideal)h->next->CopyD();
513 int bound = (int)(long)h->next->next->Data();
514 if (pid==NULL) /*(htype == POLY_CMD || htype == VECTOR_CMD)*/
515 res->data = (char *)kNFBound(q,currRing->qideal,p,bound);
516 else /*(htype == IDEAL_CMD || htype == MODUL_CMD)*/
517 res->data = (char *)kNFBound(q,currRing->qideal,pid,bound);
518 return FALSE;
519 }
520 else
521/*==================== uname ==================================*/
522 if(strcmp(sys_cmd,"uname")==0)
523 {
524 res->rtyp=STRING_CMD;
525 res->data = omStrDup(S_UNAME);
526 return FALSE;
527 }
528 else
529/*==================== with ==================================*/
530 if(strcmp(sys_cmd,"with")==0)
531 {
532 if (h==NULL)
533 {
534 res->rtyp=STRING_CMD;
535 res->data=(void *)versionString();
536 return FALSE;
537 }
538 else if (h->Typ()==STRING_CMD)
539 {
540 #define TEST_FOR(A) if(strcmp(s,A)==0) res->data=(void *)1; else
541 char *s=(char *)h->Data();
542 res->rtyp=INT_CMD;
543 #ifdef HAVE_DBM
544 TEST_FOR("DBM")
545 #endif
546 #ifdef HAVE_DLD
547 TEST_FOR("DLD")
548 #endif
549 //TEST_FOR("factory")
550 //TEST_FOR("libfac")
551 #ifdef HAVE_READLINE
552 TEST_FOR("readline")
553 #endif
554 #ifdef TEST_MAC_ORDER
555 TEST_FOR("MAC_ORDER")
556 #endif
557 // unconditional since 3-1-0-6
558 TEST_FOR("Namespaces")
559 #ifdef HAVE_DYNAMIC_LOADING
560 TEST_FOR("DynamicLoading")
561 #endif
562 #ifdef HAVE_EIGENVAL
563 TEST_FOR("eigenval")
564 #endif
565 #ifdef HAVE_GMS
566 TEST_FOR("gms")
567 #endif
568 #ifdef OM_NDEBUG
569 TEST_FOR("om_ndebug")
570 #endif
571 #ifdef SING_NDEBUG
572 TEST_FOR("ndebug")
573 #endif
574 {};
575 return FALSE;
576 #undef TEST_FOR
577 }
578 return TRUE;
579 }
580 else
581 /*==================== browsers ==================================*/
582 if (strcmp(sys_cmd,"browsers")==0)
583 {
584 res->rtyp = STRING_CMD;
585 StringSetS("");
587 res->data = StringEndS();
588 return FALSE;
589 }
590 else
591 /*==================== pid ==================================*/
592 if (strcmp(sys_cmd,"pid")==0)
593 {
594 res->rtyp=INT_CMD;
595 res->data=(void *)(long) getpid();
596 return FALSE;
597 }
598 else
599 /*==================== getenv ==================================*/
600 if (strcmp(sys_cmd,"getenv")==0)
601 {
602 if ((h!=NULL) && (h->Typ()==STRING_CMD))
603 {
604 res->rtyp=STRING_CMD;
605 const char *r=getenv((char *)h->Data());
606 if (r==NULL) r="";
607 res->data=(void *)omStrDup(r);
608 return FALSE;
609 }
610 else
611 {
612 WerrorS("string expected");
613 return TRUE;
614 }
615 }
616 else
617 /*==================== setenv ==================================*/
618 if (strcmp(sys_cmd,"setenv")==0)
619 {
620 #ifdef HAVE_SETENV
621 const short t[]={2,STRING_CMD,STRING_CMD};
622 if (iiCheckTypes(h,t,1))
623 {
624 res->rtyp=STRING_CMD;
625 setenv((char *)h->Data(), (char *)h->next->Data(), 1);
626 res->data=(void *)omStrDup((char *)h->next->Data());
628 return FALSE;
629 }
630 else
631 {
632 return TRUE;
633 }
634 #else
635 WerrorS("setenv not supported on this platform");
636 return TRUE;
637 #endif
638 }
639 else
640 /*==================== Singular ==================================*/
641 if (strcmp(sys_cmd, "Singular") == 0)
642 {
643 res->rtyp=STRING_CMD;
644 const char *r=feResource("Singular");
645 if (r == NULL) r="";
646 res->data = (void*) omStrDup( r );
647 return FALSE;
648 }
649 else
650 if (strcmp(sys_cmd, "SingularLib") == 0)
651 {
652 res->rtyp=STRING_CMD;
653 const char *r=feResource("SearchPath");
654 if (r == NULL) r="";
655 res->data = (void*) omStrDup( r );
656 return FALSE;
657 }
658 else
659 if (strcmp(sys_cmd, "SingularBin") == 0)
660 {
661 res->rtyp=STRING_CMD;
662 const char *r=feResource('r');
663 if (r == NULL) r="/usr/local";
664 int l=strlen(r);
665 /* where to find Singular's programs: */
666 #define SINGULAR_PROCS_DIR "/libexec/singular/MOD"
667 int ll=si_max((int)strlen(SINGULAR_PROCS_DIR),(int)strlen(LIBEXEC_DIR));
668 char *s=(char*)omAlloc(l+ll+2);
669 if ((strstr(r,".libs/..")==NULL) /*not installed Singular (libtool)*/
670 &&(strstr(r,"Singular/..")==NULL)) /*not installed Singular (static)*/
671 {
672 strcpy(s,r);
673 strcat(s,SINGULAR_PROCS_DIR);
674 if (access(s,X_OK)==0)
675 {
676 strcat(s,"/");
677 }
678 else
679 {
680 /*second try: LIBEXEC_DIR*/
681 strcpy(s,LIBEXEC_DIR);
682 if (access(s,X_OK)==0)
683 {
684 strcat(s,"/");
685 }
686 else
687 {
688 s[0]='\0';
689 }
690 }
691 }
692 else
693 {
694 const char *r=feResource('b');
695 if (r == NULL)
696 {
697 s[0]='\0';
698 }
699 else
700 {
701 strcpy(s,r);
702 strcat(s,"/");
703 }
704 }
705 res->data = (void*)s;
706 return FALSE;
707 }
708 else
709 /*==================== options ==================================*/
710 if (strstr(sys_cmd, "--") == sys_cmd)
711 {
712 if (strcmp(sys_cmd, "--") == 0)
713 {
715 return FALSE;
716 }
717 feOptIndex opt = feGetOptIndex(&sys_cmd[2]);
718 if (opt == FE_OPT_UNDEF)
719 {
720 Werror("Unknown option %s", sys_cmd);
721 WerrorS("Use 'system(\"--\");' for listing of available options");
722 return TRUE;
723 }
724 // for Untyped Options (help version),
725 // setting it just triggers action
726 if (feOptSpec[opt].type == feOptUntyped)
727 {
728 feSetOptValue(opt,0);
729 return FALSE;
730 }
731 if (h == NULL)
732 {
733 if (feOptSpec[opt].type == feOptString)
734 {
735 res->rtyp = STRING_CMD;
736 const char *r=(const char*)feOptSpec[opt].value;
737 if (r == NULL) r="";
738 res->data = omStrDup(r);
739 }
740 else
741 {
742 res->rtyp = INT_CMD;
743 res->data = feOptSpec[opt].value;
744 }
745 return FALSE;
746 }
747 if (h->Typ() != STRING_CMD &&
748 h->Typ() != INT_CMD)
749 {
750 WerrorS("Need string or int argument to set option value");
751 return TRUE;
752 }
753 const char* errormsg;
754 if (h->Typ() == INT_CMD)
755 {
756 if (feOptSpec[opt].type == feOptString)
757 {
758 Werror("Need string argument to set value of option %s", sys_cmd);
759 return TRUE;
760 }
761 errormsg = feSetOptValue(opt, (int)((long) h->Data()));
762 if (errormsg != NULL)
763 Werror("Option '--%s=%d' %s", sys_cmd, (int) ((long)h->Data()), errormsg);
764 }
765 else
766 {
767 errormsg = feSetOptValue(opt, (char*) h->Data());
768 if (errormsg != NULL)
769 Werror("Option '--%s=%s' %s", sys_cmd, (char*) h->Data(), errormsg);
770 }
771 if (errormsg != NULL) return TRUE;
772 return FALSE;
773 }
774 else
775 /*==================== HC ==================================*/
776 if (strcmp(sys_cmd,"HC")==0)
777 {
778 res->rtyp=INT_CMD;
779 res->data=(void *)(long) HCord;
780 return FALSE;
781 }
782 else
783 /*==================== random ==================================*/
784 if(strcmp(sys_cmd,"random")==0)
785 {
786 const short t[]={1,INT_CMD};
787 if (h!=NULL)
788 {
789 if (iiCheckTypes(h,t,1))
790 {
791 siRandomStart=(int)((long)h->Data());
794 return FALSE;
795 }
796 else
797 {
798 return TRUE;
799 }
800 }
801 res->rtyp=INT_CMD;
802 res->data=(void*)(long) siSeed;
803 return FALSE;
804 }
805 else
806 /*======================= demon_list =====================*/
807 if (strcmp(sys_cmd,"denom_list")==0)
808 {
809 res->rtyp=LIST_CMD;
810 extern lists get_denom_list();
811 res->data=(lists)get_denom_list();
812 return FALSE;
813 }
814 else
815 /*==================== complexNearZero ======================*/
816 if(strcmp(sys_cmd,"complexNearZero")==0)
817 {
818 const short t[]={2,NUMBER_CMD,INT_CMD};
819 if (iiCheckTypes(h,t,1))
820 {
822 {
823 WerrorS( "unsupported ground field!");
824 return TRUE;
825 }
826 else
827 {
828 res->rtyp=INT_CMD;
829 res->data=(void*)complexNearZero((gmp_complex*)h->Data(),
830 (int)((long)(h->next->Data())));
831 return FALSE;
832 }
833 }
834 else
835 {
836 return TRUE;
837 }
838 }
839 else
840 /*==================== getPrecDigits ======================*/
841 if(strcmp(sys_cmd,"getPrecDigits")==0)
842 {
843 if ( (currRing==NULL)
845 {
846 WerrorS( "unsupported ground field!");
847 return TRUE;
848 }
849 res->rtyp=INT_CMD;
850 res->data=(void*)(long)gmp_output_digits;
851 //if (gmp_output_digits!=getGMPFloatDigits())
852 //{ Print("%d, %d\n",getGMPFloatDigits(),gmp_output_digits);}
853 return FALSE;
854 }
855 else
856 /*==================== lduDecomp ======================*/
857 if(strcmp(sys_cmd, "lduDecomp")==0)
858 {
859 const short t[]={1,MATRIX_CMD};
860 if (iiCheckTypes(h,t,1))
861 {
862 matrix aMat = (matrix)h->Data();
863 matrix pMat; matrix lMat; matrix dMat; matrix uMat;
864 poly l; poly u; poly prodLU;
865 lduDecomp(aMat, pMat, lMat, dMat, uMat, l, u, prodLU);
867 L->Init(7);
868 L->m[0].rtyp = MATRIX_CMD; L->m[0].data=(void*)pMat;
869 L->m[1].rtyp = MATRIX_CMD; L->m[1].data=(void*)lMat;
870 L->m[2].rtyp = MATRIX_CMD; L->m[2].data=(void*)dMat;
871 L->m[3].rtyp = MATRIX_CMD; L->m[3].data=(void*)uMat;
872 L->m[4].rtyp = POLY_CMD; L->m[4].data=(void*)l;
873 L->m[5].rtyp = POLY_CMD; L->m[5].data=(void*)u;
874 L->m[6].rtyp = POLY_CMD; L->m[6].data=(void*)prodLU;
875 res->rtyp = LIST_CMD;
876 res->data = (char *)L;
877 return FALSE;
878 }
879 else
880 {
881 return TRUE;
882 }
883 }
884 else
885 /*==================== lduSolve ======================*/
886 if(strcmp(sys_cmd, "lduSolve")==0)
887 {
888 /* for solving a linear equation system A * x = b, via the
889 given LDU-decomposition of the matrix A;
890 There is one valid parametrisation:
891 1) exactly eight arguments P, L, D, U, l, u, lTimesU, b;
892 P, L, D, and U realise the LDU-decomposition of A, that is,
893 P * A = L * D^(-1) * U, and P, L, D, and U satisfy the
894 properties decribed in method 'luSolveViaLDUDecomp' in
895 linearAlgebra.h; see there;
896 l, u, and lTimesU are as described in the same location;
897 b is the right-hand side vector of the linear equation system;
898 The method will return a list of either 1 entry or three entries:
899 1) [0] if there is no solution to the system;
900 2) [1, x, H] if there is at least one solution;
901 x is any solution of the given linear system,
902 H is the matrix with column vectors spanning the homogeneous
903 solution space.
904 The method produces an error if matrix and vector sizes do not
905 fit. */
907 if (!iiCheckTypes(h,t,1))
908 {
909 return TRUE;
910 }
912 {
913 WerrorS("field required");
914 return TRUE;
915 }
916 matrix pMat = (matrix)h->Data();
917 matrix lMat = (matrix)h->next->Data();
918 matrix dMat = (matrix)h->next->next->Data();
919 matrix uMat = (matrix)h->next->next->next->Data();
920 poly l = (poly) h->next->next->next->next->Data();
921 poly u = (poly) h->next->next->next->next->next->Data();
922 poly lTimesU = (poly) h->next->next->next->next->next->next->Data();
923 matrix bVec = (matrix)h->next->next->next->next->next->next->next->Data();
924 matrix xVec; int solvable; matrix homogSolSpace;
925 if (pMat->rows() != pMat->cols())
926 {
927 Werror("first matrix (%d x %d) is not quadratic",
928 pMat->rows(), pMat->cols());
929 return TRUE;
930 }
931 if (lMat->rows() != lMat->cols())
932 {
933 Werror("second matrix (%d x %d) is not quadratic",
934 lMat->rows(), lMat->cols());
935 return TRUE;
936 }
937 if (dMat->rows() != dMat->cols())
938 {
939 Werror("third matrix (%d x %d) is not quadratic",
940 dMat->rows(), dMat->cols());
941 return TRUE;
942 }
943 if (dMat->cols() != uMat->rows())
944 {
945 Werror("third matrix (%d x %d) and fourth matrix (%d x %d) %s",
946 dMat->rows(), dMat->cols(), uMat->rows(), uMat->cols(),
947 "do not t");
948 return TRUE;
949 }
950 if (uMat->rows() != bVec->rows())
951 {
952 Werror("fourth matrix (%d x %d) and vector (%d x 1) do not fit",
953 uMat->rows(), uMat->cols(), bVec->rows());
954 return TRUE;
955 }
956 solvable = luSolveViaLDUDecomp(pMat, lMat, dMat, uMat, l, u, lTimesU,
957 bVec, xVec, homogSolSpace);
958
959 /* build the return structure; a list with either one or
960 three entries */
962 if (solvable)
963 {
964 ll->Init(3);
965 ll->m[0].rtyp=INT_CMD; ll->m[0].data=(void *)(long)solvable;
966 ll->m[1].rtyp=MATRIX_CMD; ll->m[1].data=(void *)xVec;
967 ll->m[2].rtyp=MATRIX_CMD; ll->m[2].data=(void *)homogSolSpace;
968 }
969 else
970 {
971 ll->Init(1);
972 ll->m[0].rtyp=INT_CMD; ll->m[0].data=(void *)(long)solvable;
973 }
974 res->rtyp = LIST_CMD;
975 res->data=(char*)ll;
976 return FALSE;
977 }
978 else
979 /*==== countedref: reference and shared ====*/
980 if (strcmp(sys_cmd, "shared") == 0)
981 {
982 #ifndef SI_COUNTEDREF_AUTOLOAD
985 #endif
986 res->rtyp = NONE;
987 return FALSE;
988 }
989 else if (strcmp(sys_cmd, "reference") == 0)
990 {
991 #ifndef SI_COUNTEDREF_AUTOLOAD
994 #endif
995 res->rtyp = NONE;
996 return FALSE;
997 }
998 else
999/*==================== semaphore =================*/
1000#ifdef HAVE_SIMPLEIPC
1001 if (strcmp(sys_cmd,"semaphore")==0)
1002 {
1003 if((h!=NULL) && (h->Typ()==STRING_CMD) && (h->next!=NULL) && (h->next->Typ()==INT_CMD))
1004 {
1005 int v=1;
1006 if ((h->next->next!=NULL)&& (h->next->next->Typ()==INT_CMD))
1007 v=(int)(long)h->next->next->Data();
1008 res->data=(char *)(long)simpleipc_cmd((char *)h->Data(),(int)(long)h->next->Data(),v);
1009 res->rtyp=INT_CMD;
1010 return FALSE;
1011 }
1012 else
1013 {
1014 WerrorS("Usage: system(\"semaphore\",<cmd>,int)");
1015 return TRUE;
1016 }
1017 }
1018 else
1019#endif
1020/*==================== reserved port =================*/
1021 if (strcmp(sys_cmd,"reserve")==0)
1022 {
1023 int ssiReservePort(int clients);
1024 const short t[]={1,INT_CMD};
1025 if (iiCheckTypes(h,t,1))
1026 {
1027 res->rtyp=INT_CMD;
1028 int p=ssiReservePort((int)(long)h->Data());
1029 res->data=(void*)(long)p;
1030 return (p==0);
1031 }
1032 return TRUE;
1033 }
1034 else
1035/*==================== reserved link =================*/
1036 if (strcmp(sys_cmd,"reservedLink")==0)
1037 {
1038 res->rtyp=LINK_CMD;
1040 res->data=(void*)p;
1041 return (p==NULL);
1042 }
1043 else
1044/*==================== install newstruct =================*/
1045 if (strcmp(sys_cmd,"install")==0)
1046 {
1047 const short t[]={4,STRING_CMD,STRING_CMD,PROC_CMD,INT_CMD};
1048 if (iiCheckTypes(h,t,1))
1049 {
1050 return newstruct_set_proc((char*)h->Data(),(char*)h->next->Data(),
1051 (int)(long)h->next->next->next->Data(),
1052 (procinfov)h->next->next->Data());
1053 }
1054 return TRUE;
1055 }
1056 else
1057/*==================== newstruct =================*/
1058 if (strcmp(sys_cmd,"newstruct")==0)
1059 {
1060 const short t[]={1,STRING_CMD};
1061 if (iiCheckTypes(h,t,1))
1062 {
1063 int id=0;
1064 char *n=(char*)h->Data();
1065 blackboxIsCmd(n,id);
1066 if (id>0)
1067 {
1068 blackbox *bb=getBlackboxStuff(id);
1069 if (BB_LIKE_LIST(bb))
1070 {
1071 newstruct_desc desc=(newstruct_desc)bb->data;
1072 newstructShow(desc);
1073 return FALSE;
1074 }
1075 else Werror("'%s' is not a newstruct",n);
1076 }
1077 else Werror("'%s' is not a blackbox object",n);
1078 }
1079 return TRUE;
1080 }
1081 else
1082/*==================== blackbox =================*/
1083 if (strcmp(sys_cmd,"blackbox")==0)
1084 {
1086 return FALSE;
1087 }
1088 else
1089 /*================= absBiFact ======================*/
1090 #if defined(HAVE_FLINT) || defined(HAVE_NTL)
1091 if (strcmp(sys_cmd, "absFact") == 0)
1092 {
1093 const short t[]={1,POLY_CMD};
1094 if (iiCheckTypes(h,t,1)
1095 && (currRing!=NULL)
1096 && (getCoeffType(currRing->cf)==n_transExt))
1097 {
1098 res->rtyp=LIST_CMD;
1099 intvec *v=NULL;
1100 ideal mipos= NULL;
1101 int n= 0;
1102 ideal f=singclap_absFactorize((poly)(h->Data()), mipos, &v, n, currRing);
1103 if (f==NULL) return TRUE;
1104 ivTest(v);
1106 l->Init(4);
1107 l->m[0].rtyp=IDEAL_CMD;
1108 l->m[0].data=(void *)f;
1109 l->m[1].rtyp=INTVEC_CMD;
1110 l->m[1].data=(void *)v;
1111 l->m[2].rtyp=IDEAL_CMD;
1112 l->m[2].data=(void*) mipos;
1113 l->m[3].rtyp=INT_CMD;
1114 l->m[3].data=(void*) (long) n;
1115 res->data=(void *)l;
1116 return FALSE;
1117 }
1118 else return TRUE;
1119 }
1120 else
1121 #endif
1122 /* =================== LLL via NTL ==============================*/
1123 #ifdef HAVE_NTL
1124 if (strcmp(sys_cmd, "LLL") == 0)
1125 {
1126 if (h!=NULL)
1127 {
1128 res->rtyp=h->Typ();
1129 if (h->Typ()==MATRIX_CMD)
1130 {
1131 res->data=(char *)singntl_LLL((matrix)h->Data(), currRing);
1132 return FALSE;
1133 }
1134 else if (h->Typ()==INTMAT_CMD)
1135 {
1136 res->data=(char *)singntl_LLL((intvec*)h->Data());
1137 return FALSE;
1138 }
1139 else return TRUE;
1140 }
1141 else return TRUE;
1142 }
1143 else
1144 #endif
1145 /* =================== LLL via Flint ==============================*/
1146 #ifdef HAVE_FLINT
1147 #if __FLINT_RELEASE >= 20500
1148 if (strcmp(sys_cmd, "LLL_Flint") == 0)
1149 {
1150 if (h!=NULL)
1151 {
1152 if(h->next == NULL)
1153 {
1154 res->rtyp=h->Typ();
1155 if (h->Typ()==BIGINTMAT_CMD)
1156 {
1157 res->data=(char *)singflint_LLL((bigintmat*)h->Data(), NULL);
1158 return FALSE;
1159 }
1160 else if (h->Typ()==INTMAT_CMD)
1161 {
1162 res->data=(char *)singflint_LLL((intvec*)h->Data(), NULL);
1163 return FALSE;
1164 }
1165 else return TRUE;
1166 }
1167 if(h->next->Typ()!= INT_CMD)
1168 {
1169 WerrorS("matrix,int or bigint,int expected");
1170 return TRUE;
1171 }
1172 if(h->next->Typ()== INT_CMD)
1173 {
1174 if(((int)((long)(h->next->Data())) != 0) && (int)((long)(h->next->Data()) != 1))
1175 {
1176 WerrorS("int is different from 0, 1");
1177 return TRUE;
1178 }
1179 res->rtyp=h->Typ();
1180 if((long)(h->next->Data()) == 0)
1181 {
1182 if (h->Typ()==BIGINTMAT_CMD)
1183 {
1184 res->data=(char *)singflint_LLL((bigintmat*)h->Data(), NULL);
1185 return FALSE;
1186 }
1187 else if (h->Typ()==INTMAT_CMD)
1188 {
1189 res->data=(char *)singflint_LLL((intvec*)h->Data(), NULL);
1190 return FALSE;
1191 }
1192 else return TRUE;
1193 }
1194 // This will give also the transformation matrix U s.t. res = U * m
1195 if((long)(h->next->Data()) == 1)
1196 {
1197 if (h->Typ()==BIGINTMAT_CMD)
1198 {
1199 bigintmat* m = (bigintmat*)h->Data();
1200 bigintmat* T = new bigintmat(m->rows(),m->rows(),m->basecoeffs());
1201 for(int i = 1; i<=m->rows(); i++)
1202 {
1203 n_Delete(&(BIMATELEM(*T,i,i)),T->basecoeffs());
1204 BIMATELEM(*T,i,i)=n_Init(1, T->basecoeffs());
1205 }
1206 m = singflint_LLL(m,T);
1208 L->Init(2);
1209 L->m[0].rtyp = BIGINTMAT_CMD; L->m[0].data = (void*)m;
1210 L->m[1].rtyp = BIGINTMAT_CMD; L->m[1].data = (void*)T;
1211 res->data=L;
1212 res->rtyp=LIST_CMD;
1213 return FALSE;
1214 }
1215 else if (h->Typ()==INTMAT_CMD)
1216 {
1217 intvec* m = (intvec*)h->Data();
1218 intvec* T = new intvec(m->rows(),m->rows(),(int)0);
1219 for(int i = 1; i<=m->rows(); i++)
1220 IMATELEM(*T,i,i)=1;
1221 m = singflint_LLL(m,T);
1223 L->Init(2);
1224 L->m[0].rtyp = INTMAT_CMD; L->m[0].data = (void*)m;
1225 L->m[1].rtyp = INTMAT_CMD; L->m[1].data = (void*)T;
1226 res->data=L;
1227 res->rtyp=LIST_CMD;
1228 return FALSE;
1229 }
1230 else return TRUE;
1231 }
1232 }
1233
1234 }
1235 else return TRUE;
1236 }
1237 else
1238 #endif
1239 #endif
1240/* ====== rref ============================*/
1241 #ifdef HAVE_FLINT
1242 if(strcmp(sys_cmd,"rref")==0)
1243 {
1244 const short t1[]={1,MATRIX_CMD};
1245 if (iiCheckTypes(h,t1,1))
1246 {
1247 matrix M=(matrix)h->Data();
1248 res->data=(void*)singflint_rref(M,currRing);
1249 res->rtyp=MATRIX_CMD;
1250 return FALSE;
1251 }
1252 else
1253 {
1254 WerrorS("expected system(\"rref\",<matrix>)");
1255 return TRUE;
1256 }
1257 }
1258 else
1259 #endif
1260 /*==================== pcv ==================================*/
1261 #ifdef HAVE_PCV
1262 if(strcmp(sys_cmd,"pcvLAddL")==0)
1263 {
1264 return pcvLAddL(res,h);
1265 }
1266 else
1267 if(strcmp(sys_cmd,"pcvPMulL")==0)
1268 {
1269 return pcvPMulL(res,h);
1270 }
1271 else
1272 if(strcmp(sys_cmd,"pcvMinDeg")==0)
1273 {
1274 return pcvMinDeg(res,h);
1275 }
1276 else
1277 if(strcmp(sys_cmd,"pcvP2CV")==0)
1278 {
1279 return pcvP2CV(res,h);
1280 }
1281 else
1282 if(strcmp(sys_cmd,"pcvCV2P")==0)
1283 {
1284 return pcvCV2P(res,h);
1285 }
1286 else
1287 if(strcmp(sys_cmd,"pcvDim")==0)
1288 {
1289 return pcvDim(res,h);
1290 }
1291 else
1292 if(strcmp(sys_cmd,"pcvBasis")==0)
1293 {
1294 return pcvBasis(res,h);
1295 }
1296 else
1297 #endif
1298 /*==================== hessenberg/eigenvalues ==================================*/
1299 #ifdef HAVE_EIGENVAL
1300 if(strcmp(sys_cmd,"hessenberg")==0)
1301 {
1302 return evHessenberg(res,h);
1303 }
1304 else
1305 #endif
1306 /*==================== eigenvalues ==================================*/
1307 #ifdef HAVE_EIGENVAL
1308 if(strcmp(sys_cmd,"eigenvals")==0)
1309 {
1310 return evEigenvals(res,h);
1311 }
1312 else
1313 #endif
1314 /*==================== rowelim ==================================*/
1315 #ifdef HAVE_EIGENVAL
1316 if(strcmp(sys_cmd,"rowelim")==0)
1317 {
1318 return evRowElim(res,h);
1319 }
1320 else
1321 #endif
1322 /*==================== rowcolswap ==================================*/
1323 #ifdef HAVE_EIGENVAL
1324 if(strcmp(sys_cmd,"rowcolswap")==0)
1325 {
1326 return evSwap(res,h);
1327 }
1328 else
1329 #endif
1330 /*==================== Gauss-Manin system ==================================*/
1331 #ifdef HAVE_GMS
1332 if(strcmp(sys_cmd,"gmsnf")==0)
1333 {
1334 return gmsNF(res,h);
1335 }
1336 else
1337 #endif
1338 /*==================== contributors =============================*/
1339 if(strcmp(sys_cmd,"contributors") == 0)
1340 {
1341 res->rtyp=STRING_CMD;
1342 res->data=(void *)omStrDup(
1343 "Olaf Bachmann, Michael Brickenstein, Hubert Grassmann, Kai Krueger, Victor Levandovskyy, Wolfgang Neumann, Thomas Nuessler, Wilfred Pohl, Jens Schmidt, Mathias Schulze, Thomas Siebert, Ruediger Stobbe, Moritz Wenk, Tim Wichmann");
1344 return FALSE;
1345 }
1346 else
1347 /*==================== spectrum =============================*/
1348 #ifdef HAVE_SPECTRUM
1349 if(strcmp(sys_cmd,"spectrum") == 0)
1350 {
1351 if ((h==NULL) || (h->Typ()!=POLY_CMD))
1352 {
1353 WerrorS("poly expected");
1354 return TRUE;
1355 }
1356 if (h->next==NULL)
1357 return spectrumProc(res,h);
1358 if (h->next->Typ()!=INT_CMD)
1359 {
1360 WerrorS("poly,int expected");
1361 return TRUE;
1362 }
1363 if(((long)h->next->Data())==1L)
1364 return spectrumfProc(res,h);
1365 return spectrumProc(res,h);
1366 }
1367 else
1368 /*==================== semic =============================*/
1369 if(strcmp(sys_cmd,"semic") == 0)
1370 {
1371 if ((h->next!=NULL)
1372 && (h->Typ()==LIST_CMD)
1373 && (h->next->Typ()==LIST_CMD))
1374 {
1375 if (h->next->next==NULL)
1376 return semicProc(res,h,h->next);
1377 else if (h->next->next->Typ()==INT_CMD)
1378 return semicProc3(res,h,h->next,h->next->next);
1379 }
1380 return TRUE;
1381 }
1382 else
1383 /*==================== spadd =============================*/
1384 if(strcmp(sys_cmd,"spadd") == 0)
1385 {
1386 const short t[]={2,LIST_CMD,LIST_CMD};
1387 if (iiCheckTypes(h,t,1))
1388 {
1389 return spaddProc(res,h,h->next);
1390 }
1391 return TRUE;
1392 }
1393 else
1394 /*==================== spmul =============================*/
1395 if(strcmp(sys_cmd,"spmul") == 0)
1396 {
1397 const short t[]={2,LIST_CMD,INT_CMD};
1398 if (iiCheckTypes(h,t,1))
1399 {
1400 return spmulProc(res,h,h->next);
1401 }
1402 return TRUE;
1403 }
1404 else
1405 #endif
1406/*==================== tensorModuleMult ========================= */
1407 #define HAVE_SHEAFCOH_TRICKS 1
1408
1409 #ifdef HAVE_SHEAFCOH_TRICKS
1410 if(strcmp(sys_cmd,"tensorModuleMult")==0)
1411 {
1412 const short t[]={2,INT_CMD,MODUL_CMD};
1413 // WarnS("tensorModuleMult!");
1414 if (iiCheckTypes(h,t,1))
1415 {
1416 int m = (int)( (long)h->Data() );
1417 ideal M = (ideal)h->next->Data();
1418 res->rtyp=MODUL_CMD;
1419 res->data=(void *)id_TensorModuleMult(m, M, currRing);
1420 return FALSE;
1421 }
1422 return TRUE;
1423 }
1424 else
1425 #endif
1426 /*==================== twostd =================*/
1427 #ifdef HAVE_PLURAL
1428 if (strcmp(sys_cmd, "twostd") == 0)
1429 {
1430 ideal I;
1431 if ((h!=NULL) && (h->Typ()==IDEAL_CMD))
1432 {
1433 I=(ideal)h->CopyD();
1434 res->rtyp=IDEAL_CMD;
1435 if (rIsPluralRing(currRing)) res->data=twostd(I);
1436 else res->data=I;
1439 }
1440 else return TRUE;
1441 return FALSE;
1442 }
1443 else
1444 #endif
1445 /*==================== lie bracket =================*/
1446 #ifdef HAVE_PLURAL
1447 if (strcmp(sys_cmd, "bracket") == 0)
1448 {
1449 const short t[]={2,POLY_CMD,POLY_CMD};
1450 if (iiCheckTypes(h,t,1))
1451 {
1452 poly p=(poly)h->CopyD();
1453 h=h->next;
1454 poly q=(poly)h->Data();
1455 res->rtyp=POLY_CMD;
1457 return FALSE;
1458 }
1459 return TRUE;
1460 }
1461 else
1462 #endif
1463 /*==================== env ==================================*/
1464 #ifdef HAVE_PLURAL
1465 if (strcmp(sys_cmd, "env")==0)
1466 {
1467 if ((h!=NULL) && (h->Typ()==RING_CMD))
1468 {
1469 ring r = (ring)h->Data();
1470 res->data = rEnvelope(r);
1471 res->rtyp = RING_CMD;
1472 return FALSE;
1473 }
1474 else
1475 {
1476 WerrorS("`system(\"env\",<ring>)` expected");
1477 return TRUE;
1478 }
1479 }
1480 else
1481 #endif
1482/* ============ opp ======================== */
1483 #ifdef HAVE_PLURAL
1484 if (strcmp(sys_cmd, "opp")==0)
1485 {
1486 if ((h!=NULL) && (h->Typ()==RING_CMD))
1487 {
1488 ring r=(ring)h->Data();
1489 res->data=rOpposite(r);
1490 res->rtyp=RING_CMD;
1491 return FALSE;
1492 }
1493 else
1494 {
1495 WerrorS("`system(\"opp\",<ring>)` expected");
1496 return TRUE;
1497 }
1498 }
1499 else
1500 #endif
1501 /*==================== oppose ==================================*/
1502 #ifdef HAVE_PLURAL
1503 if (strcmp(sys_cmd, "oppose")==0)
1504 {
1505 if ((h!=NULL) && (h->Typ()==RING_CMD)
1506 && (h->next!= NULL))
1507 {
1508 ring Rop = (ring)h->Data();
1509 h = h->next;
1510 idhdl w;
1511 if ((w=Rop->idroot->get(h->Name(),myynest))!=NULL)
1512 {
1513 poly p = (poly)IDDATA(w);
1514 res->data = pOppose(Rop, p, currRing); // into CurrRing?
1515 res->rtyp = POLY_CMD;
1516 return FALSE;
1517 }
1518 }
1519 else
1520 {
1521 WerrorS("`system(\"oppose\",<ring>,<poly>)` expected");
1522 return TRUE;
1523 }
1524 }
1525 else
1526 #endif
1527 /*==================== walk stuff =================*/
1528 /*==================== walkNextWeight =================*/
1529 #ifdef HAVE_WALK
1530 #ifdef OWNW
1531 if (strcmp(sys_cmd, "walkNextWeight") == 0)
1532 {
1533 const short t[]={3,INTVEC_CMD,INTVEC_CMD,IDEAL_CMD};
1534 if (!iiCheckTypes(h,t,1)) return TRUE;
1535 if (((intvec*) h->Data())->length() != currRing->N ||
1536 ((intvec*) h->next->Data())->length() != currRing->N)
1537 {
1538 Werror("system(\"walkNextWeight\" ...) intvecs not of length %d\n",
1539 currRing->N);
1540 return TRUE;
1541 }
1542 res->data = (void*) walkNextWeight(((intvec*) h->Data()),
1543 ((intvec*) h->next->Data()),
1544 (ideal) h->next->next->Data());
1545 if (res->data == NULL || res->data == (void*) 1L)
1546 {
1547 res->rtyp = INT_CMD;
1548 }
1549 else
1550 {
1551 res->rtyp = INTVEC_CMD;
1552 }
1553 return FALSE;
1554 }
1555 else
1556 #endif
1557 #endif
1558 /*==================== walkNextWeight =================*/
1559 #ifdef HAVE_WALK
1560 #ifdef OWNW
1561 if (strcmp(sys_cmd, "walkInitials") == 0)
1562 {
1563 if (h == NULL || h->Typ() != IDEAL_CMD)
1564 {
1565 WerrorS("system(\"walkInitials\", ideal) expected");
1566 return TRUE;
1567 }
1568 res->data = (void*) walkInitials((ideal) h->Data());
1569 res->rtyp = IDEAL_CMD;
1570 return FALSE;
1571 }
1572 else
1573 #endif
1574 #endif
1575 /*==================== walkAddIntVec =================*/
1576 #ifdef HAVE_WALK
1577 #ifdef WAIV
1578 if (strcmp(sys_cmd, "walkAddIntVec") == 0)
1579 {
1580 const short t[]={2,INTVEC_CMD,INTVEC_CMD};
1581 if (!iiCheckTypes(h,t,1)) return TRUE;
1582 intvec* arg1 = (intvec*) h->Data();
1583 intvec* arg2 = (intvec*) h->next->Data();
1584 res->data = (intvec*) walkAddIntVec(arg1, arg2);
1585 res->rtyp = INTVEC_CMD;
1586 return FALSE;
1587 }
1588 else
1589 #endif
1590 #endif
1591 /*==================== MwalkNextWeight =================*/
1592 #ifdef HAVE_WALK
1593 #ifdef MwaklNextWeight
1594 if (strcmp(sys_cmd, "MwalkNextWeight") == 0)
1595 {
1596 const short t[]={3,INTVEC_CMD,INTVEC_CMD,IDEAL_CMD};
1597 if (!iiCheckTypes(h,t,1)) return TRUE;
1598 if (((intvec*) h->Data())->length() != currRing->N ||
1599 ((intvec*) h->next->Data())->length() != currRing->N)
1600 {
1601 Werror("system(\"MwalkNextWeight\" ...) intvecs not of length %d\n",
1602 currRing->N);
1603 return TRUE;
1604 }
1605 intvec* arg1 = (intvec*) h->Data();
1606 intvec* arg2 = (intvec*) h->next->Data();
1607 ideal arg3 = (ideal) h->next->next->Data();
1608 intvec* result = (intvec*) MwalkNextWeight(arg1, arg2, arg3);
1609 res->rtyp = INTVEC_CMD;
1610 res->data = result;
1611 return FALSE;
1612 }
1613 else
1614 #endif //MWalkNextWeight
1615 #endif
1616 /*==================== Mivdp =================*/
1617 #ifdef HAVE_WALK
1618 if(strcmp(sys_cmd, "Mivdp") == 0)
1619 {
1620 if (h == NULL || h->Typ() != INT_CMD)
1621 {
1622 WerrorS("system(\"Mivdp\", int) expected");
1623 return TRUE;
1624 }
1625 if ((int) ((long)(h->Data())) != currRing->N)
1626 {
1627 Werror("system(\"Mivdp\" ...) intvecs not of length %d\n",
1628 currRing->N);
1629 return TRUE;
1630 }
1631 int arg1 = (int) ((long)(h->Data()));
1632 intvec* result = (intvec*) Mivdp(arg1);
1633 res->rtyp = INTVEC_CMD;
1634 res->data = result;
1635 return FALSE;
1636 }
1637 else
1638 #endif
1639 /*==================== Mivlp =================*/
1640 #ifdef HAVE_WALK
1641 if(strcmp(sys_cmd, "Mivlp") == 0)
1642 {
1643 if (h == NULL || h->Typ() != INT_CMD)
1644 {
1645 WerrorS("system(\"Mivlp\", int) expected");
1646 return TRUE;
1647 }
1648 if ((int) ((long)(h->Data())) != currRing->N)
1649 {
1650 Werror("system(\"Mivlp\" ...) intvecs not of length %d\n",
1651 currRing->N);
1652 return TRUE;
1653 }
1654 int arg1 = (int) ((long)(h->Data()));
1655 intvec* result = (intvec*) Mivlp(arg1);
1656 res->rtyp = INTVEC_CMD;
1657 res->data = result;
1658 return FALSE;
1659 }
1660 else
1661 #endif
1662 /*==================== MpDiv =================*/
1663 #ifdef HAVE_WALK
1664 #ifdef MpDiv
1665 if(strcmp(sys_cmd, "MpDiv") == 0)
1666 {
1667 const short t[]={2,POLY_CMD,POLY_CMD};
1668 if (!iiCheckTypes(h,t,1)) return TRUE;
1669 poly arg1 = (poly) h->Data();
1670 poly arg2 = (poly) h->next->Data();
1671 poly result = MpDiv(arg1, arg2);
1672 res->rtyp = POLY_CMD;
1673 res->data = result;
1674 return FALSE;
1675 }
1676 else
1677 #endif
1678 #endif
1679 /*==================== MpMult =================*/
1680 #ifdef HAVE_WALK
1681 #ifdef MpMult
1682 if(strcmp(sys_cmd, "MpMult") == 0)
1683 {
1684 const short t[]={2,POLY_CMD,POLY_CMD};
1685 if (!iiCheckTypes(h,t,1)) return TRUE;
1686 poly arg1 = (poly) h->Data();
1687 poly arg2 = (poly) h->next->Data();
1688 poly result = MpMult(arg1, arg2);
1689 res->rtyp = POLY_CMD;
1690 res->data = result;
1691 return FALSE;
1692 }
1693 else
1694 #endif
1695 #endif
1696 /*==================== MivSame =================*/
1697 #ifdef HAVE_WALK
1698 if (strcmp(sys_cmd, "MivSame") == 0)
1699 {
1700 const short t[]={2,INTVEC_CMD,INTVEC_CMD};
1701 if (!iiCheckTypes(h,t,1)) return TRUE;
1702 /*
1703 if (((intvec*) h->Data())->length() != currRing->N ||
1704 ((intvec*) h->next->Data())->length() != currRing->N)
1705 {
1706 Werror("system(\"MivSame\" ...) intvecs not of length %d\n",
1707 currRing->N);
1708 return TRUE;
1709 }
1710 */
1711 intvec* arg1 = (intvec*) h->Data();
1712 intvec* arg2 = (intvec*) h->next->Data();
1713 /*
1714 poly result = (poly) MivSame(arg1, arg2);
1715 res->rtyp = POLY_CMD;
1716 res->data = (poly) result;
1717 */
1718 res->rtyp = INT_CMD;
1719 res->data = (void*)(long) MivSame(arg1, arg2);
1720 return FALSE;
1721 }
1722 else
1723 #endif
1724 /*==================== M3ivSame =================*/
1725 #ifdef HAVE_WALK
1726 if (strcmp(sys_cmd, "M3ivSame") == 0)
1727 {
1728 const short t[]={3,INTVEC_CMD,INTVEC_CMD,INTVEC_CMD};
1729 if (!iiCheckTypes(h,t,1)) return TRUE;
1730 /*
1731 if (((intvec*) h->Data())->length() != currRing->N ||
1732 ((intvec*) h->next->Data())->length() != currRing->N ||
1733 ((intvec*) h->next->next->Data())->length() != currRing->N )
1734 {
1735 Werror("system(\"M3ivSame\" ...) intvecs not of length %d\n",
1736 currRing->N);
1737 return TRUE;
1738 }
1739 */
1740 intvec* arg1 = (intvec*) h->Data();
1741 intvec* arg2 = (intvec*) h->next->Data();
1742 intvec* arg3 = (intvec*) h->next->next->Data();
1743 /*
1744 poly result = (poly) M3ivSame(arg1, arg2, arg3);
1745 res->rtyp = POLY_CMD;
1746 res->data = (poly) result;
1747 */
1748 res->rtyp = INT_CMD;
1749 res->data = (void*)(long) M3ivSame(arg1, arg2, arg3);
1750 return FALSE;
1751 }
1752 else
1753 #endif
1754 /*==================== MwalkInitialForm =================*/
1755 #ifdef HAVE_WALK
1756 if(strcmp(sys_cmd, "MwalkInitialForm") == 0)
1757 {
1758 const short t[]={2,IDEAL_CMD,INTVEC_CMD};
1759 if (!iiCheckTypes(h,t,1)) return TRUE;
1760 if(((intvec*) h->next->Data())->length() != currRing->N)
1761 {
1762 Werror("system \"MwalkInitialForm\"...) intvec not of length %d\n",
1763 currRing->N);
1764 return TRUE;
1765 }
1766 ideal id = (ideal) h->Data();
1767 intvec* int_w = (intvec*) h->next->Data();
1768 ideal result = (ideal) MwalkInitialForm(id, int_w);
1769 res->rtyp = IDEAL_CMD;
1770 res->data = result;
1771 return FALSE;
1772 }
1773 else
1774 #endif
1775 /*==================== MivMatrixOrder =================*/
1776 #ifdef HAVE_WALK
1777 /************** Perturbation walk **********/
1778 if(strcmp(sys_cmd, "MivMatrixOrder") == 0)
1779 {
1780 if(h==NULL || h->Typ() != INTVEC_CMD)
1781 {
1782 WerrorS("system(\"MivMatrixOrder\",intvec) expected");
1783 return TRUE;
1784 }
1785 intvec* arg1 = (intvec*) h->Data();
1786 intvec* result = MivMatrixOrder(arg1);
1787 res->rtyp = INTVEC_CMD;
1788 res->data = result;
1789 return FALSE;
1790 }
1791 else
1792 #endif
1793 /*==================== MivMatrixOrderdp =================*/
1794 #ifdef HAVE_WALK
1795 if(strcmp(sys_cmd, "MivMatrixOrderdp") == 0)
1796 {
1797 if(h==NULL || h->Typ() != INT_CMD)
1798 {
1799 WerrorS("system(\"MivMatrixOrderdp\",intvec) expected");
1800 return TRUE;
1801 }
1802 int arg1 = (int) ((long)(h->Data()));
1804 res->rtyp = INTVEC_CMD;
1805 res->data = result;
1806 return FALSE;
1807 }
1808 else
1809 #endif
1810 /*==================== MPertVectors =================*/
1811 #ifdef HAVE_WALK
1812 if(strcmp(sys_cmd, "MPertVectors") == 0)
1813 {
1814 const short t[]={3,IDEAL_CMD,INTVEC_CMD,INT_CMD};
1815 if (!iiCheckTypes(h,t,1)) return TRUE;
1816 ideal arg1 = (ideal) h->Data();
1817 intvec* arg2 = (intvec*) h->next->Data();
1818 int arg3 = (int) ((long)(h->next->next->Data()));
1819 intvec* result = (intvec*) MPertVectors(arg1, arg2, arg3);
1820 res->rtyp = INTVEC_CMD;
1821 res->data = result;
1822 return FALSE;
1823 }
1824 else
1825 #endif
1826 /*==================== MPertVectorslp =================*/
1827 #ifdef HAVE_WALK
1828 if(strcmp(sys_cmd, "MPertVectorslp") == 0)
1829 {
1830 const short t[]={3,IDEAL_CMD,INTVEC_CMD,INT_CMD};
1831 if (!iiCheckTypes(h,t,1)) return TRUE;
1832 ideal arg1 = (ideal) h->Data();
1833 intvec* arg2 = (intvec*) h->next->Data();
1834 int arg3 = (int) ((long)(h->next->next->Data()));
1835 intvec* result = (intvec*) MPertVectorslp(arg1, arg2, arg3);
1836 res->rtyp = INTVEC_CMD;
1837 res->data = result;
1838 return FALSE;
1839 }
1840 else
1841 #endif
1842 /************** fractal walk **********/
1843 #ifdef HAVE_WALK
1844 if(strcmp(sys_cmd, "Mfpertvector") == 0)
1845 {
1846 const short t[]={2,IDEAL_CMD,INTVEC_CMD};
1847 if (!iiCheckTypes(h,t,1)) return TRUE;
1848 ideal arg1 = (ideal) h->Data();
1849 intvec* arg2 = (intvec*) h->next->Data();
1850 intvec* result = Mfpertvector(arg1, arg2);
1851 res->rtyp = INTVEC_CMD;
1852 res->data = result;
1853 return FALSE;
1854 }
1855 else
1856 #endif
1857 /*==================== MivUnit =================*/
1858 #ifdef HAVE_WALK
1859 if(strcmp(sys_cmd, "MivUnit") == 0)
1860 {
1861 const short t[]={1,INT_CMD};
1862 if (!iiCheckTypes(h,t,1)) return TRUE;
1863 int arg1 = (int) ((long)(h->Data()));
1864 intvec* result = (intvec*) MivUnit(arg1);
1865 res->rtyp = INTVEC_CMD;
1866 res->data = result;
1867 return FALSE;
1868 }
1869 else
1870 #endif
1871 /*==================== MivWeightOrderlp =================*/
1872 #ifdef HAVE_WALK
1873 if(strcmp(sys_cmd, "MivWeightOrderlp") == 0)
1874 {
1875 const short t[]={1,INTVEC_CMD};
1876 if (!iiCheckTypes(h,t,1)) return TRUE;
1877 intvec* arg1 = (intvec*) h->Data();
1879 res->rtyp = INTVEC_CMD;
1880 res->data = result;
1881 return FALSE;
1882 }
1883 else
1884 #endif
1885 /*==================== MivWeightOrderdp =================*/
1886 #ifdef HAVE_WALK
1887 if(strcmp(sys_cmd, "MivWeightOrderdp") == 0)
1888 {
1889 if(h==NULL || h->Typ() != INTVEC_CMD)
1890 {
1891 WerrorS("system(\"MivWeightOrderdp\",intvec) expected");
1892 return TRUE;
1893 }
1894 intvec* arg1 = (intvec*) h->Data();
1895 //int arg2 = (int) h->next->Data();
1897 res->rtyp = INTVEC_CMD;
1898 res->data = result;
1899 return FALSE;
1900 }
1901 else
1902 #endif
1903 /*==================== MivMatrixOrderlp =================*/
1904 #ifdef HAVE_WALK
1905 if(strcmp(sys_cmd, "MivMatrixOrderlp") == 0)
1906 {
1907 if(h==NULL || h->Typ() != INT_CMD)
1908 {
1909 WerrorS("system(\"MivMatrixOrderlp\",int) expected");
1910 return TRUE;
1911 }
1912 int arg1 = (int) ((long)(h->Data()));
1914 res->rtyp = INTVEC_CMD;
1915 res->data = result;
1916 return FALSE;
1917 }
1918 else
1919 #endif
1920 /*==================== MkInterRedNextWeight =================*/
1921 #ifdef HAVE_WALK
1922 if (strcmp(sys_cmd, "MkInterRedNextWeight") == 0)
1923 {
1924 const short t[]={3,INTVEC_CMD,INTVEC_CMD,IDEAL_CMD};
1925 if (!iiCheckTypes(h,t,1)) return TRUE;
1926 if (((intvec*) h->Data())->length() != currRing->N ||
1927 ((intvec*) h->next->Data())->length() != currRing->N)
1928 {
1929 Werror("system(\"MkInterRedNextWeight\" ...) intvecs not of length %d\n",
1930 currRing->N);
1931 return TRUE;
1932 }
1933 intvec* arg1 = (intvec*) h->Data();
1934 intvec* arg2 = (intvec*) h->next->Data();
1935 ideal arg3 = (ideal) h->next->next->Data();
1936 intvec* result = (intvec*) MkInterRedNextWeight(arg1, arg2, arg3);
1937 res->rtyp = INTVEC_CMD;
1938 res->data = result;
1939 return FALSE;
1940 }
1941 else
1942 #endif
1943 /*==================== MPertNextWeight =================*/
1944 #ifdef HAVE_WALK
1945 #ifdef MPertNextWeight
1946 if (strcmp(sys_cmd, "MPertNextWeight") == 0)
1947 {
1948 const short t[]={3,INTVEC_CMD,IDEAL_CMD,INT_CMD};
1949 if (!iiCheckTypes(h,t,1)) return TRUE;
1950 if (((intvec*) h->Data())->length() != currRing->N)
1951 {
1952 Werror("system(\"MPertNextWeight\" ...) intvecs not of length %d\n",
1953 currRing->N);
1954 return TRUE;
1955 }
1956 intvec* arg1 = (intvec*) h->Data();
1957 ideal arg2 = (ideal) h->next->Data();
1958 int arg3 = (int) h->next->next->Data();
1959 intvec* result = (intvec*) MPertNextWeight(arg1, arg2, arg3);
1960 res->rtyp = INTVEC_CMD;
1961 res->data = result;
1962 return FALSE;
1963 }
1964 else
1965 #endif //MPertNextWeight
1966 #endif
1967 /*==================== Mivperttarget =================*/
1968 #ifdef HAVE_WALK
1969 #ifdef Mivperttarget
1970 if (strcmp(sys_cmd, "Mivperttarget") == 0)
1971 {
1972 const short t[]={2,IDEAL_CMD,INT_CMD};
1973 if (!iiCheckTypes(h,t,1)) return TRUE;
1974 ideal arg1 = (ideal) h->Data();
1975 int arg2 = (int) h->next->Data();
1976 intvec* result = (intvec*) Mivperttarget(arg1, arg2);
1977 res->rtyp = INTVEC_CMD;
1978 res->data = result;
1979 return FALSE;
1980 }
1981 else
1982 #endif //Mivperttarget
1983 #endif
1984 /*==================== Mwalk =================*/
1985 #ifdef HAVE_WALK
1986 if (strcmp(sys_cmd, "Mwalk") == 0)
1987 {
1989 if (!iiCheckTypes(h,t,1)) return TRUE;
1990 if (((intvec*) h->next->Data())->length() != currRing->N &&
1991 ((intvec*) h->next->next->Data())->length() != currRing->N )
1992 {
1993 Werror("system(\"Mwalk\" ...) intvecs not of length %d\n",
1994 currRing->N);
1995 return TRUE;
1996 }
1997 ideal arg1 = (ideal) h->CopyD();
1998 intvec* arg2 = (intvec*) h->next->Data();
1999 intvec* arg3 = (intvec*) h->next->next->Data();
2000 ring arg4 = (ring) h->next->next->next->Data();
2001 int arg5 = (int) (long) h->next->next->next->next->Data();
2002 int arg6 = (int) (long) h->next->next->next->next->next->Data();
2003 ideal result = (ideal) Mwalk(arg1, arg2, arg3, arg4, arg5, arg6);
2004 res->rtyp = IDEAL_CMD;
2005 res->data = result;
2006 return FALSE;
2007 }
2008 else
2009 #endif
2010 /*==================== Mpwalk =================*/
2011 #ifdef HAVE_WALK
2012 #ifdef MPWALK_ORIG
2013 if (strcmp(sys_cmd, "Mwalk") == 0)
2014 {
2015 const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,RING_CMD};
2016 if (!iiCheckTypes(h,t,1)) return TRUE;
2017 if ((((intvec*) h->next->Data())->length() != currRing->N &&
2018 ((intvec*) h->next->next->Data())->length() != currRing->N ) &&
2019 (((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
2020 ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N)))
2021 {
2022 Werror("system(\"Mwalk\" ...) intvecs not of length %d or %d\n",
2023 currRing->N,(currRing->N)*(currRing->N));
2024 return TRUE;
2025 }
2026 ideal arg1 = (ideal) h->Data();
2027 intvec* arg2 = (intvec*) h->next->Data();
2028 intvec* arg3 = (intvec*) h->next->next->Data();
2029 ring arg4 = (ring) h->next->next->next->Data();
2030 ideal result = (ideal) Mwalk(arg1, arg2, arg3,arg4);
2031 res->rtyp = IDEAL_CMD;
2032 res->data = result;
2033 return FALSE;
2034 }
2035 else
2036 #else
2037 if (strcmp(sys_cmd, "Mpwalk") == 0)
2038 {
2040 if (!iiCheckTypes(h,t,1)) return TRUE;
2041 if(((intvec*) h->next->next->next->Data())->length() != currRing->N &&
2042 ((intvec*) h->next->next->next->next->Data())->length()!=currRing->N)
2043 {
2044 Werror("system(\"Mpwalk\" ...) intvecs not of length %d\n",currRing->N);
2045 return TRUE;
2046 }
2047 ideal arg1 = (ideal) h->Data();
2048 int arg2 = (int) (long) h->next->Data();
2049 int arg3 = (int) (long) h->next->next->Data();
2050 intvec* arg4 = (intvec*) h->next->next->next->Data();
2051 intvec* arg5 = (intvec*) h->next->next->next->next->Data();
2052 int arg6 = (int) (long) h->next->next->next->next->next->Data();
2053 int arg7 = (int) (long) h->next->next->next->next->next->next->Data();
2054 int arg8 = (int) (long) h->next->next->next->next->next->next->next->Data();
2055 ideal result = (ideal) Mpwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
2056 res->rtyp = IDEAL_CMD;
2057 res->data = result;
2058 return FALSE;
2059 }
2060 else
2061 #endif
2062 #endif
2063 /*==================== Mrwalk =================*/
2064 #ifdef HAVE_WALK
2065 if (strcmp(sys_cmd, "Mrwalk") == 0)
2066 {
2068 if (!iiCheckTypes(h,t,1)) return TRUE;
2069 if(((intvec*) h->next->Data())->length() != currRing->N &&
2070 ((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
2071 ((intvec*) h->next->next->Data())->length() != currRing->N &&
2072 ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) )
2073 {
2074 Werror("system(\"Mrwalk\" ...) intvecs not of length %d or %d\n",
2075 currRing->N,(currRing->N)*(currRing->N));
2076 return TRUE;
2077 }
2078 ideal arg1 = (ideal) h->Data();
2079 intvec* arg2 = (intvec*) h->next->Data();
2080 intvec* arg3 = (intvec*) h->next->next->Data();
2081 int arg4 = (int)(long) h->next->next->next->Data();
2082 int arg5 = (int)(long) h->next->next->next->next->Data();
2083 int arg6 = (int)(long) h->next->next->next->next->next->Data();
2084 int arg7 = (int)(long) h->next->next->next->next->next->next->Data();
2085 ideal result = (ideal) Mrwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
2086 res->rtyp = IDEAL_CMD;
2087 res->data = result;
2088 return FALSE;
2089 }
2090 else
2091 #endif
2092 /*==================== MAltwalk1 =================*/
2093 #ifdef HAVE_WALK
2094 if (strcmp(sys_cmd, "MAltwalk1") == 0)
2095 {
2096 const short t[]={5,IDEAL_CMD,INT_CMD,INT_CMD,INTVEC_CMD,INTVEC_CMD};
2097 if (!iiCheckTypes(h,t,1)) return TRUE;
2098 if (((intvec*) h->next->next->next->Data())->length() != currRing->N &&
2099 ((intvec*) h->next->next->next->next->Data())->length()!=currRing->N)
2100 {
2101 Werror("system(\"MAltwalk1\" ...) intvecs not of length %d\n",
2102 currRing->N);
2103 return TRUE;
2104 }
2105 ideal arg1 = (ideal) h->Data();
2106 int arg2 = (int) ((long)(h->next->Data()));
2107 int arg3 = (int) ((long)(h->next->next->Data()));
2108 intvec* arg4 = (intvec*) h->next->next->next->Data();
2109 intvec* arg5 = (intvec*) h->next->next->next->next->Data();
2110 ideal result = (ideal) MAltwalk1(arg1, arg2, arg3, arg4, arg5);
2111 res->rtyp = IDEAL_CMD;
2112 res->data = result;
2113 return FALSE;
2114 }
2115 else
2116 #endif
2117 /*==================== MAltwalk1 =================*/
2118 #ifdef HAVE_WALK
2119 #ifdef MFWALK_ALT
2120 if (strcmp(sys_cmd, "Mfwalk_alt") == 0)
2121 {
2122 const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD};
2123 if (!iiCheckTypes(h,t,1)) return TRUE;
2124 if (((intvec*) h->next->Data())->length() != currRing->N &&
2125 ((intvec*) h->next->next->Data())->length() != currRing->N )
2126 {
2127 Werror("system(\"Mfwalk\" ...) intvecs not of length %d\n",
2128 currRing->N);
2129 return TRUE;
2130 }
2131 ideal arg1 = (ideal) h->Data();
2132 intvec* arg2 = (intvec*) h->next->Data();
2133 intvec* arg3 = (intvec*) h->next->next->Data();
2134 int arg4 = (int) h->next->next->next->Data();
2135 ideal result = (ideal) Mfwalk_alt(arg1, arg2, arg3, arg4);
2136 res->rtyp = IDEAL_CMD;
2137 res->data = result;
2138 return FALSE;
2139 }
2140 else
2141 #endif
2142 #endif
2143 /*==================== Mfwalk =================*/
2144 #ifdef HAVE_WALK
2145 if (strcmp(sys_cmd, "Mfwalk") == 0)
2146 {
2147 const short t[]={5,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD,INT_CMD};
2148 if (!iiCheckTypes(h,t,1)) return TRUE;
2149 if (((intvec*) h->next->Data())->length() != currRing->N &&
2150 ((intvec*) h->next->next->Data())->length() != currRing->N )
2151 {
2152 Werror("system(\"Mfwalk\" ...) intvecs not of length %d\n",
2153 currRing->N);
2154 return TRUE;
2155 }
2156 ideal arg1 = (ideal) h->Data();
2157 intvec* arg2 = (intvec*) h->next->Data();
2158 intvec* arg3 = (intvec*) h->next->next->Data();
2159 int arg4 = (int)(long) h->next->next->next->Data();
2160 int arg5 = (int)(long) h->next->next->next->next->Data();
2161 ideal result = (ideal) Mfwalk(arg1, arg2, arg3, arg4, arg5);
2162 res->rtyp = IDEAL_CMD;
2163 res->data = result;
2164 return FALSE;
2165 }
2166 else
2167 #endif
2168 /*==================== Mfrwalk =================*/
2169 #ifdef HAVE_WALK
2170 if (strcmp(sys_cmd, "Mfrwalk") == 0)
2171 {
2173 if (!iiCheckTypes(h,t,1)) return TRUE;
2174/*
2175 if (((intvec*) h->next->Data())->length() != currRing->N &&
2176 ((intvec*) h->next->next->Data())->length() != currRing->N)
2177 {
2178 Werror("system(\"Mfrwalk\" ...) intvecs not of length %d\n",currRing->N);
2179 return TRUE;
2180 }
2181*/
2182 if((((intvec*) h->next->Data())->length() != currRing->N &&
2183 ((intvec*) h->next->next->Data())->length() != currRing->N ) &&
2184 (((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
2185 ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) ))
2186 {
2187 Werror("system(\"Mfrwalk\" ...) intvecs not of length %d or %d\n",
2188 currRing->N,(currRing->N)*(currRing->N));
2189 return TRUE;
2190 }
2191
2192 ideal arg1 = (ideal) h->Data();
2193 intvec* arg2 = (intvec*) h->next->Data();
2194 intvec* arg3 = (intvec*) h->next->next->Data();
2195 int arg4 = (int)(long) h->next->next->next->Data();
2196 int arg5 = (int)(long) h->next->next->next->next->Data();
2197 int arg6 = (int)(long) h->next->next->next->next->next->Data();
2198 ideal result = (ideal) Mfrwalk(arg1, arg2, arg3, arg4, arg5, arg6);
2199 res->rtyp = IDEAL_CMD;
2200 res->data = result;
2201 return FALSE;
2202 }
2203 else
2204 /*==================== Mprwalk =================*/
2205 if (strcmp(sys_cmd, "Mprwalk") == 0)
2206 {
2208 if (!iiCheckTypes(h,t,1)) return TRUE;
2209 if((((intvec*) h->next->Data())->length() != currRing->N &&
2210 ((intvec*) h->next->next->Data())->length() != currRing->N ) &&
2211 (((intvec*) h->next->Data())->length() != (currRing->N)*(currRing->N) &&
2212 ((intvec*) h->next->next->Data())->length() != (currRing->N)*(currRing->N) ))
2213 {
2214 Werror("system(\"Mrwalk\" ...) intvecs not of length %d or %d\n",
2215 currRing->N,(currRing->N)*(currRing->N));
2216 return TRUE;
2217 }
2218 ideal arg1 = (ideal) h->Data();
2219 intvec* arg2 = (intvec*) h->next->Data();
2220 intvec* arg3 = (intvec*) h->next->next->Data();
2221 int arg4 = (int)(long) h->next->next->next->Data();
2222 int arg5 = (int)(long) h->next->next->next->next->Data();
2223 int arg6 = (int)(long) h->next->next->next->next->next->Data();
2224 int arg7 = (int)(long) h->next->next->next->next->next->next->Data();
2225 int arg8 = (int)(long) h->next->next->next->next->next->next->next->Data();
2226 int arg9 = (int)(long) h->next->next->next->next->next->next->next->next->Data();
2227 ideal result = (ideal) Mprwalk(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
2228 res->rtyp = IDEAL_CMD;
2229 res->data = result;
2230 return FALSE;
2231 }
2232 else
2233 #endif
2234 /*==================== TranMImprovwalk =================*/
2235 #ifdef HAVE_WALK
2236 #ifdef TRAN_Orig
2237 if (strcmp(sys_cmd, "TranMImprovwalk") == 0)
2238 {
2239 const short t[]={3,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD};
2240 if (!iiCheckTypes(h,t,1)) return TRUE;
2241 if (((intvec*) h->next->Data())->length() != currRing->N &&
2242 ((intvec*) h->next->next->Data())->length() != currRing->N )
2243 {
2244 Werror("system(\"TranMImprovwalk\" ...) intvecs not of length %d\n",
2245 currRing->N);
2246 return TRUE;
2247 }
2248 ideal arg1 = (ideal) h->Data();
2249 intvec* arg2 = (intvec*) h->next->Data();
2250 intvec* arg3 = (intvec*) h->next->next->Data();
2251 ideal result = (ideal) TranMImprovwalk(arg1, arg2, arg3);
2252 res->rtyp = IDEAL_CMD;
2253 res->data = result;
2254 return FALSE;
2255 }
2256 else
2257 #endif
2258 #endif
2259 /*==================== MAltwalk2 =================*/
2260 #ifdef HAVE_WALK
2261 if (strcmp(sys_cmd, "MAltwalk2") == 0)
2262 {
2263 const short t[]={3,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD};
2264 if (!iiCheckTypes(h,t,1)) return TRUE;
2265 if (((intvec*) h->next->Data())->length() != currRing->N &&
2266 ((intvec*) h->next->next->Data())->length() != currRing->N )
2267 {
2268 Werror("system(\"MAltwalk2\" ...) intvecs not of length %d\n",
2269 currRing->N);
2270 return TRUE;
2271 }
2272 ideal arg1 = (ideal) h->Data();
2273 intvec* arg2 = (intvec*) h->next->Data();
2274 intvec* arg3 = (intvec*) h->next->next->Data();
2275 ideal result = (ideal) MAltwalk2(arg1, arg2, arg3);
2276 res->rtyp = IDEAL_CMD;
2277 res->data = result;
2278 return FALSE;
2279 }
2280 else
2281 #endif
2282 /*==================== MAltwalk2 =================*/
2283 #ifdef HAVE_WALK
2284 if (strcmp(sys_cmd, "TranMImprovwalk") == 0)
2285 {
2286 const short t[]={4,IDEAL_CMD,INTVEC_CMD,INTVEC_CMD,INT_CMD};
2287 if (!iiCheckTypes(h,t,1)) return TRUE;
2288 if (((intvec*) h->next->Data())->length() != currRing->N &&
2289 ((intvec*) h->next->next->Data())->length() != currRing->N )
2290 {
2291 Werror("system(\"TranMImprovwalk\" ...) intvecs not of length %d\n",
2292 currRing->N);
2293 return TRUE;
2294 }
2295 ideal arg1 = (ideal) h->Data();
2296 intvec* arg2 = (intvec*) h->next->Data();
2297 intvec* arg3 = (intvec*) h->next->next->Data();
2298 int arg4 = (int) ((long)(h->next->next->next->Data()));
2299 ideal result = (ideal) TranMImprovwalk(arg1, arg2, arg3, arg4);
2300 res->rtyp = IDEAL_CMD;
2301 res->data = result;
2302 return FALSE;
2303 }
2304 else
2305 #endif
2306 /*==================== TranMrImprovwalk =================*/
2307 #if 0
2308 #ifdef HAVE_WALK
2309 if (strcmp(sys_cmd, "TranMrImprovwalk") == 0)
2310 {
2311 if (h == NULL || h->Typ() != IDEAL_CMD ||
2312 h->next == NULL || h->next->Typ() != INTVEC_CMD ||
2313 h->next->next == NULL || h->next->next->Typ() != INTVEC_CMD ||
2314 h->next->next->next == NULL || h->next->next->next->Typ() != INT_CMD ||
2315 h->next->next->next == NULL || h->next->next->next->next->Typ() != INT_CMD ||
2316 h->next->next->next == NULL || h->next->next->next->next->next->Typ() != INT_CMD)
2317 {
2318 WerrorS("system(\"TranMrImprovwalk\", ideal, intvec, intvec) expected");
2319 return TRUE;
2320 }
2321 if (((intvec*) h->next->Data())->length() != currRing->N &&
2322 ((intvec*) h->next->next->Data())->length() != currRing->N )
2323 {
2324 Werror("system(\"TranMrImprovwalk\" ...) intvecs not of length %d\n", currRing->N);
2325 return TRUE;
2326 }
2327 ideal arg1 = (ideal) h->Data();
2328 intvec* arg2 = (intvec*) h->next->Data();
2329 intvec* arg3 = (intvec*) h->next->next->Data();
2330 int arg4 = (int)(long) h->next->next->next->Data();
2331 int arg5 = (int)(long) h->next->next->next->next->Data();
2332 int arg6 = (int)(long) h->next->next->next->next->next->Data();
2333 ideal result = (ideal) TranMrImprovwalk(arg1, arg2, arg3, arg4, arg5, arg6);
2334 res->rtyp = IDEAL_CMD;
2335 res->data = result;
2336 return FALSE;
2337 }
2338 else
2339 #endif
2340 #endif
2341 /*================= Extended system call ========================*/
2342 {
2343 #ifndef MAKE_DISTRIBUTION
2344 return(jjEXTENDED_SYSTEM(res, args));
2345 #else
2346 Werror( "system(\"%s\",...) %s", sys_cmd, feNotImplemented );
2347 #endif
2348 }
2349 } /* typ==string */
2350 return TRUE;
2351}
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
#define BIMATELEM(M, I, J)
Definition: bigintmat.h:133
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition: blackbox.cc:17
int blackboxIsCmd(const char *n, int &tok)
used by scanner: returns ROOT_DECL for known types (and the type number in tok)
Definition: blackbox.cc:218
void printBlackboxTypes()
list all defined type (for debugging)
Definition: blackbox.cc:235
#define BB_LIKE_LIST(B)
Definition: blackbox.h:53
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
void factoryseed(int s)
random seed initializer
Definition: cf_random.cc:189
matrix singntl_LLL(matrix m, const ring s)
Definition: clapsing.cc:1892
ideal singclap_absFactorize(poly f, ideal &mipos, intvec **exps, int &numFactors, const ring r)
Definition: clapsing.cc:1974
char * singclap_neworder(ideal I, const ring r)
Definition: clapsing.cc:1641
gmp_complex numbers based on
Definition: mpr_complex.h:179
Definition: idrec.h:35
int & cols()
Definition: matpol.h:24
int & rows()
Definition: matpol.h:23
int Typ()
Definition: subexpr.cc:1011
void * Data()
Definition: subexpr.cc:1154
leftv next
Definition: subexpr.h:86
VAR int siRandomStart
Definition: cntrlc.cc:93
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:38
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:730
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:421
void countedref_reference_load()
Initialize blackbox types 'reference' and 'shared', or both.
Definition: countedref.cc:721
void countedref_shared_load()
Definition: countedref.cc:745
lists get_denom_list()
Definition: denom_list.cc:8
matrix evRowElim(matrix M, int i, int j, int k)
Definition: eigenval.cc:47
matrix evHessenberg(matrix M)
Definition: eigenval.cc:100
matrix evSwap(matrix M, int i, int j)
Definition: eigenval.cc:25
lists evEigenvals(matrix M)
Definition: eigenval_ip.cc:118
#define SINGULAR_PROCS_DIR
#define TEST_FOR(A)
static BOOLEAN jjEXTENDED_SYSTEM(leftv res, leftv h)
Definition: extra.cc:2361
return result
Definition: facAbsBiFact.cc:75
feOptIndex
Definition: feOptGen.h:15
@ FE_OPT_UNDEF
Definition: feOptGen.h:15
void fePrintOptValues()
Definition: feOpt.cc:337
feOptIndex feGetOptIndex(const char *name)
Definition: feOpt.cc:104
const char * feSetOptValue(feOptIndex opt, char *optarg)
Definition: feOpt.cc:154
EXTERN_VAR struct fe_option feOptSpec[]
Definition: feOpt.h:17
void feReInitResources()
Definition: feResource.cc:185
static char * feResource(feResourceConfig config, int warn)
Definition: feResource.cc:236
VAR int myynest
Definition: febase.cc:41
char * getenv()
@ feOptUntyped
Definition: fegetopt.h:77
@ feOptString
Definition: fegetopt.h:77
void * value
Definition: fegetopt.h:93
void system(sys)
void feStringAppendBrowsers(int warn)
Definition: fehelp.cc:340
matrix singflint_rref(matrix m, const ring R)
bigintmat * singflint_LLL(bigintmat *A, bigintmat *T)
lists gmsNF(ideal p, ideal g, matrix B, int D, int K)
Definition: gms.cc:22
@ BIGINTMAT_CMD
Definition: grammar.cc:278
@ SMATRIX_CMD
Definition: grammar.cc:291
void HilbertSeries_OrbitData(ideal S, int lV, bool IG_CASE, bool mgrad, bool odp, int trunDegHs)
Definition: hilb.cc:2012
ideal RightColonOperation(ideal S, poly w, int lV)
Definition: hilb.cc:2359
ideal id_TensorModuleMult(const int m, const ideal M, const ring rRing)
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257
#define ivTest(v)
Definition: intvec.h:158
#define IMATELEM(M, I, J)
Definition: intvec.h:85
VAR idhdl currRingHdl
Definition: ipid.cc:59
#define IDDATA(a)
Definition: ipid.h:126
#define FLAG_TWOSTD
Definition: ipid.h:107
#define IDRING(a)
Definition: ipid.h:127
BOOLEAN spaddProc(leftv result, leftv first, leftv second)
Definition: ipshell.cc:4431
BOOLEAN semicProc3(leftv res, leftv u, leftv v, leftv w)
Definition: ipshell.cc:4514
BOOLEAN spectrumfProc(leftv result, leftv first)
Definition: ipshell.cc:4187
BOOLEAN spmulProc(leftv result, leftv first, leftv second)
Definition: ipshell.cc:4473
BOOLEAN spectrumProc(leftv result, leftv first)
Definition: ipshell.cc:4136
BOOLEAN semicProc(leftv res, leftv u, leftv v)
Definition: ipshell.cc:4554
char * versionString()
Definition: misc_ip.cc:770
poly kNFBound(ideal F, ideal Q, poly p, int bound, int syzComp, int lazyReduce)
Definition: kstd1.cc:3222
VAR int HCord
Definition: kutil.cc:246
BOOLEAN kVerify2(ideal F, ideal Q)
Definition: kverify.cc:137
BOOLEAN kVerify1(ideal F, ideal Q)
Definition: kverify.cc:21
poly pOppose(ring Rop_src, poly p, const ring Rop_dst)
opposes a vector p from Rop to currRing (dst!)
Definition: old.gring.cc:3342
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
Definition: old.gring.cc:2243
bool luSolveViaLDUDecomp(const matrix pMat, const matrix lMat, const matrix dMat, const matrix uMat, const poly l, const poly u, const poly lTimesU, const matrix bVec, matrix &xVec, matrix &H)
Solves the linear system A * x = b, where A is an (m x n)-matrix which is given by its LDU-decomposit...
void lduDecomp(const matrix aMat, matrix &pMat, matrix &lMat, matrix &dMat, matrix &uMat, poly &l, poly &u, poly &lTimesU)
LU-decomposition of a given (m x n)-matrix with performing only those divisions that yield zero remai...
ideal sm_UnFlatten(ideal a, int col, const ring R)
Definition: matpol.cc:1946
ideal sm_Flatten(ideal a, const ring R)
Definition: matpol.cc:1926
#define SINGULAR_VERSION
Definition: mod2.h:85
EXTERN_VAR size_t gmp_output_digits
Definition: mpr_base.h:115
bool complexNearZero(gmp_complex *c, int digits)
Definition: mpr_complex.cc:765
ideal twostd(ideal I)
Compute two-sided GB:
Definition: nc.cc:18
void newstructShow(newstruct_desc d)
Definition: newstruct.cc:826
BOOLEAN newstruct_set_proc(const char *bbname, const char *func, int args, procinfov pr)
Definition: newstruct.cc:846
char * omFindExec(const char *name, char *exec)
Definition: omFindExec.c:314
#define MAXPATHLEN
Definition: omRet2Info.c:22
void p_Content(poly ph, const ring r)
Definition: p_polys.cc:2287
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2906
poly pcvP2CV(poly p, int d0, int d1)
Definition: pcv.cc:280
int pcvBasis(lists b, int i, poly m, int d, int n)
Definition: pcv.cc:430
int pcvMinDeg(poly p)
Definition: pcv.cc:135
int pcvDim(int d0, int d1)
Definition: pcv.cc:400
lists pcvPMulL(poly p, lists l1)
Definition: pcv.cc:76
poly pcvCV2P(poly cv, int d0, int d1)
Definition: pcv.cc:297
lists pcvLAddL(lists l1, lists l2)
Definition: pcv.cc:31
void StringSetS(const char *st)
Definition: reporter.cc:128
char * StringEndS()
Definition: reporter.cc:151
ring rOpposite(ring src)
Definition: ring.cc:5243
ring rEnvelope(ring R)
Definition: ring.cc:5633
static int rBlocks(ring r)
Definition: ring.h:569
static BOOLEAN rField_is_long_C(const ring r)
Definition: ring.h:546
static BOOLEAN rIsNCRing(const ring r)
Definition: ring.h:421
#define rField_is_Ring(R)
Definition: ring.h:486
int simpleipc_cmd(char *cmd, int id, int v)
Definition: semaphore.c:167
VAR int siSeed
Definition: sirandom.c:30
@ LINK_CMD
Definition: tok.h:117
#define NONE
Definition: tok.h:221
int M3ivSame(intvec *temp, intvec *u, intvec *v)
Definition: walk.cc:914
intvec * MivWeightOrderdp(intvec *ivstart)
Definition: walk.cc:1456
intvec * MivUnit(int nV)
Definition: walk.cc:1496
ideal TranMImprovwalk(ideal G, intvec *curr_weight, intvec *target_tmp, int nP)
Definition: walk.cc:8396
intvec * MivMatrixOrderdp(int nV)
Definition: walk.cc:1417
ideal Mfwalk(ideal G, intvec *ivstart, intvec *ivtarget, int reduction, int printout)
Definition: walk.cc:8031
intvec * MPertVectors(ideal G, intvec *ivtarget, int pdeg)
Definition: walk.cc:1088
intvec * MivWeightOrderlp(intvec *ivstart)
Definition: walk.cc:1436
ideal Mprwalk(ideal Go, intvec *orig_M, intvec *target_M, int weight_rad, int op_deg, int tp_deg, int nP, int reduction, int printout)
Definition: walk.cc:6388
intvec * MivMatrixOrder(intvec *iv)
Definition: walk.cc:963
ideal MAltwalk2(ideal Go, intvec *curr_weight, intvec *target_weight)
Definition: walk.cc:4280
ideal MAltwalk1(ideal Go, int op_deg, int tp_deg, intvec *curr_weight, intvec *target_weight)
Definition: walk.cc:9671
ideal Mrwalk(ideal Go, intvec *orig_M, intvec *target_M, int weight_rad, int pert_deg, int reduction, int printout)
Definition: walk.cc:5603
ideal Mfrwalk(ideal G, intvec *ivstart, intvec *ivtarget, int weight_rad, int reduction, int printout)
Definition: walk.cc:8212
ideal Mwalk(ideal Go, intvec *orig_M, intvec *target_M, ring baseRing, int reduction, int printout)
Definition: walk.cc:5302
ideal Mpwalk(ideal Go, int op_deg, int tp_deg, intvec *curr_weight, intvec *target_weight, int nP, int reduction, int printout)
Definition: walk.cc:5947
int MivSame(intvec *u, intvec *v)
Definition: walk.cc:893
intvec * Mivlp(int nR)
Definition: walk.cc:1022
ideal MwalkInitialForm(ideal G, intvec *ivw)
Definition: walk.cc:761
intvec * MivMatrixOrderlp(int nV)
Definition: walk.cc:1401
intvec * Mfpertvector(ideal G, intvec *ivtarget)
Definition: walk.cc:1512
intvec * MPertVectorslp(ideal G, intvec *ivtarget, int pdeg)
Definition: walk.cc:1299
intvec * Mivdp(int nR)
Definition: walk.cc:1007
intvec * MkInterRedNextWeight(intvec *iva, intvec *ivb, ideal G)
Definition: walk.cc:2570
intvec * MwalkNextWeight(intvec *curr_weight, intvec *target_weight, ideal G)
intvec * Mivperttarget(ideal G, int ndeg)
intvec * MPertNextWeight(intvec *iva, ideal G, int deg)

◆ longCoeffsToSingularPoly()

poly longCoeffsToSingularPoly ( unsigned long *  polyCoeffs,
const int  degree 
)

Definition at line 207 of file extra.cc.

208{
209 poly result = NULL;
210 for (int i = 0; i <= degree; i++)
211 {
212 if ((int)polyCoeffs[i] != 0)
213 {
214 poly term = p_ISet((int)polyCoeffs[i], currRing);
215 if (i > 0)
216 {
217 p_SetExp(term, 1, i, currRing);
219 }
221 }
222 }
223 return result;
224}
int degree(const CanonicalForm &f)
Definition: int_poly.h:33
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1293
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:908
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:488
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:233

◆ singularMatrixToLongMatrix()

unsigned long ** singularMatrixToLongMatrix ( matrix  singularMatrix)

Definition at line 175 of file extra.cc.

176{
177 int n = singularMatrix->rows();
178 assume(n == singularMatrix->cols());
179 unsigned long **longMatrix = 0;
180 longMatrix = new unsigned long *[n] ;
181 for (int i = 0 ; i < n; i++)
182 longMatrix[i] = new unsigned long [n];
183 number entry;
184 for (int r = 0; r < n; r++)
185 for (int c = 0; c < n; c++)
186 {
187 poly p=MATELEM(singularMatrix, r + 1, c + 1);
188 int entryAsInt;
189 if (p!=NULL)
190 {
191 entry = p_GetCoeff(p, currRing);
192 entryAsInt = n_Int(entry, currRing->cf);
193 if (entryAsInt < 0) entryAsInt += n_GetChar(currRing->cf);
194 }
195 else
196 entryAsInt=0;
197 longMatrix[r][c] = (unsigned long)entryAsInt;
198 }
199 return longMatrix;
200}
static FORCE_INLINE long n_Int(number &n, const coeffs r)
conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 ....
Definition: coeffs.h:547
#define assume(x)
Definition: mod2.h:387
#define p_GetCoeff(p, r)
Definition: monomials.h:50