Macros | Functions
extra.cc File Reference
#include <kernel/mod2.h>
#include <misc/sirandom.h>
#include <resources/omFindExec.h>
#include <factory/factory.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <signal.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 "coeffs/AE.h"
#include "coeffs/AEp.h"
#include "coeffs/AEQ.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/prCopy.h>
#include <polys/weight.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/shiftgb.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 "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>
#include <polys/mod_raw.h>

Go to the source code of this file.

Macros

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

Functions

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

Macro Definition Documentation

§ HAVE_SHEAFCOH_TRICKS

#define HAVE_SHEAFCOH_TRICKS   1

§ HAVE_WALK

#define HAVE_WALK   1

Definition at line 11 of file extra.cc.

§ 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 2322 of file extra.cc.

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

§ jjSYSTEM()

BOOLEAN jjSYSTEM ( leftv  res,
leftv  args 
)

Definition at line 245 of file extra.cc.

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

§ longCoeffsToSingularPoly()

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

Definition at line 222 of file extra.cc.

223 {
224  poly result = NULL;
225  for (int i = 0; i <= degree; i++)
226  {
227  if ((int)polyCoeffs[i] != 0)
228  {
229  poly term = p_ISet((int)polyCoeffs[i], currRing);
230  if (i > 0)
231  {
232  p_SetExp(term, 1, i, currRing);
233  p_Setm(term, currRing);
234  }
235  result = p_Add_q(result, term, currRing);
236  }
237  }
238  return result;
239 }
Definition: int_poly.h:33
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
int i
Definition: cfEzgcd.cc:123
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:483
#define NULL
Definition: omList.c:10
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
int degree(const CanonicalForm &f)
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:877
poly p_ISet(long i, const ring r)
returns the poly representing the integer i
Definition: p_polys.cc:1296
return result
Definition: facAbsBiFact.cc:76

§ singularMatrixToLongMatrix()

unsigned long** singularMatrixToLongMatrix ( matrix  singularMatrix)

Definition at line 190 of file extra.cc.

191 {
192  int n = singularMatrix->rows();
193  assume(n == singularMatrix->cols());
194  unsigned long **longMatrix = 0;
195  longMatrix = new unsigned long *[n] ;
196  for (int i = 0 ; i < n; i++)
197  longMatrix[i] = new unsigned long [n];
198  number entry;
199  for (int r = 0; r < n; r++)
200  for (int c = 0; c < n; c++)
201  {
202  poly p=MATELEM(singularMatrix, r + 1, c + 1);
203  int entryAsInt;
204  if (p!=NULL)
205  {
206  entry = p_GetCoeff(p, currRing);
207  entryAsInt = n_Int(entry, currRing->cf);
208  if (entryAsInt < 0) entryAsInt += n_GetChar(currRing->cf);
209  }
210  else
211  entryAsInt=0;
212  longMatrix[r][c] = (unsigned long)entryAsInt;
213  }
214  return longMatrix;
215 }
int & rows()
Definition: matpol.h:24
return P p
Definition: myNF.cc:203
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:448
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
const ring r
Definition: syzextra.cc:208
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:551
#define assume(x)
Definition: mod2.h:394
int i
Definition: cfEzgcd.cc:123
int & cols()
Definition: matpol.h:25
#define NULL
Definition: omList.c:10
#define p_GetCoeff(p, r)
Definition: monomials.h:57
polyrec * poly
Definition: hilb.h:10
#define MATELEM(mat, i, j)
Definition: matpol.h:29