My Project
Loading...
Searching...
No Matches
Macros | Functions | Variables
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)
 

Variables

EXTERN_VAR BOOLEAN FE_OPT_NO_SHELL_FLAG
 

Macro Definition Documentation

◆ HAVE_EXTENDED_SYSTEM

#define HAVE_EXTENDED_SYSTEM   1

Definition at line 142 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 2379 of file extra.cc.

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

◆ jjSYSTEM()

BOOLEAN jjSYSTEM ( leftv  res,
leftv  args 
)

Definition at line 231 of file extra.cc.

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

210{
211 poly result = NULL;
212 for (int i = 0; i <= degree; i++)
213 {
214 if ((int)polyCoeffs[i] != 0)
215 {
216 poly term = p_ISet((int)polyCoeffs[i], currRing);
217 if (i > 0)
218 {
219 p_SetExp(term, 1, i, currRing);
221 }
223 }
224 }
225 return result;
226}
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:1297
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:938
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:490
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:235

◆ singularMatrixToLongMatrix()

unsigned long ** singularMatrixToLongMatrix ( matrix  singularMatrix)

Definition at line 177 of file extra.cc.

178{
179 int n = singularMatrix->rows();
180 assume(n == singularMatrix->cols());
181 unsigned long **longMatrix = 0;
182 longMatrix = new unsigned long *[n] ;
183 for (int i = 0 ; i < n; i++)
184 longMatrix[i] = new unsigned long [n];
185 number entry;
186 for (int r = 0; r < n; r++)
187 for (int c = 0; c < n; c++)
188 {
189 poly p=MATELEM(singularMatrix, r + 1, c + 1);
190 int entryAsInt;
191 if (p!=NULL)
192 {
193 entry = p_GetCoeff(p, currRing);
194 entryAsInt = n_Int(entry, currRing->cf);
195 if (entryAsInt < 0) entryAsInt += n_GetChar(currRing->cf);
196 }
197 else
198 entryAsInt=0;
199 longMatrix[r][c] = (unsigned long)entryAsInt;
200 }
201 return longMatrix;
202}
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:389
#define p_GetCoeff(p, r)
Definition: monomials.h:50

Variable Documentation

◆ FE_OPT_NO_SHELL_FLAG

EXTERN_VAR BOOLEAN FE_OPT_NO_SHELL_FLAG

Definition at line 170 of file extra.cc.