My Project
Data Structures | Macros | Typedefs | Functions | Variables
iparith.cc File Reference
#include "kernel/mod2.h"
#include "factory/factory.h"
#include "coeffs/bigintmat.h"
#include "coeffs/coeffs.h"
#include "coeffs/numbers.h"
#include "misc/options.h"
#include "misc/intvec.h"
#include "misc/sirandom.h"
#include "misc/prime.h"
#include "polys/matpol.h"
#include "polys/monomials/maps.h"
#include "polys/sparsmat.h"
#include "polys/weight.h"
#include "polys/ext_fields/transext.h"
#include "polys/clapsing.h"
#include "polys/flintconv.h"
#include "kernel/combinatorics/stairc.h"
#include "kernel/combinatorics/hilb.h"
#include "kernel/linear_algebra/interpolation.h"
#include "kernel/linear_algebra/linearAlgebra.h"
#include "kernel/linear_algebra/MinorInterface.h"
#include "kernel/GBEngine/kChinese.h"
#include "kernel/spectrum/GMPrat.h"
#include "kernel/groebner_walk/walkProc.h"
#include "kernel/oswrapper/timer.h"
#include "kernel/fglm/fglm.h"
#include "kernel/GBEngine/kstdfac.h"
#include "kernel/GBEngine/syz.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/GBEngine/units.h"
#include "kernel/GBEngine/tgb.h"
#include "kernel/preimage.h"
#include "kernel/polys.h"
#include "kernel/ideals.h"
#include "Singular/mod_lib.h"
#include "Singular/fevoices.h"
#include "Singular/tok.h"
#include "Singular/ipid.h"
#include "Singular/sdb.h"
#include "Singular/subexpr.h"
#include "Singular/lists.h"
#include "Singular/maps_ip.h"
#include "Singular/feOpt.h"
#include "Singular/ipconv.h"
#include "Singular/ipprint.h"
#include "Singular/attrib.h"
#include "Singular/links/silink.h"
#include "Singular/misc_ip.h"
#include "Singular/linearAlgebra_ip.h"
#include "Singular/number2.h"
#include "Singular/fglm.h"
#include "Singular/blackbox.h"
#include "Singular/newstruct.h"
#include "Singular/ipshell.h"
#include "reporter/si_signals.h"
#include <ctype.h>
#include "kernel/GBEngine/ratgring.h"
#include "kernel/GBEngine/nc.h"
#include "polys/nc/nc.h"
#include "polys/nc/sca.h"
#include "table.h"
#include "iparith.inc"

Go to the source code of this file.

Data Structures

struct  sValCmdTab
 
struct  cmdnames
 
struct  sValCmd1
 
struct  sValCmd2
 
struct  sValCmd3
 
struct  sValCmdM
 
struct  SArithBase
 

Macros

#define NC_MASK   (3+64)
 
#define RING_MASK   4
 
#define ZERODIVISOR_MASK   8
 
#define ALLOW_PLURAL   1
 
#define NO_NC   0
 
#define COMM_PLURAL   2
 
#define ALLOW_RING   4
 
#define NO_RING   0
 
#define NO_ZERODIVISOR   8
 
#define ALLOW_ZERODIVISOR   0
 
#define ALLOW_LP   64
 
#define ALLOW_NC   ALLOW_LP|ALLOW_PLURAL
 
#define ALLOW_ZZ   (ALLOW_RING|NO_ZERODIVISOR)
 
#define WARN_RING   16
 
#define NO_CONVERSION   32
 
#define bit31   SIZEOF_LONG*8-1
 
#define ii_div_by_0   "div. by 0"
 
#define SIMPL_NORMALIZE   64
 
#define SIMPL_LMDIV   32
 
#define SIMPL_LMEQ   16
 
#define SIMPL_MULT   8
 
#define SIMPL_EQU   4
 
#define SIMPL_NULL   2
 
#define SIMPL_NORM   1
 
#define jjWRONG2   (proc2)jjWRONG
 
#define jjWRONG3   (proc3)jjWRONG
 
#define D(A)   (A)
 
#define NULL_VAL   NULL
 
#define IPARITH
 

Typedefs

typedef sValCmdTab jjValCmdTab[]
 
typedef BOOLEAN(* proc2) (leftv, leftv, leftv)
 
typedef BOOLEAN(* proc3) (leftv, leftv, leftv, leftv)
 
typedef char si_char_2[2]
 

Functions

static BOOLEAN check_valid (const int p, const int op)
 
static int _gentable_sort_cmds (const void *a, const void *b)
 compares to entry of cmdsname-list More...
 
int iiArithRemoveCmd (char *szName)
 
int iiArithAddCmd (const char *szName, short nAlias, short nTokval, short nToktype, short nPos=-1)
 
static int iiTabIndex (const jjValCmdTab dArithTab, const int len, const int op)
 
static Subexpr jjMakeSub (leftv e)
 
static int iin_Int (number &n, coeffs cf)
 
poly pHeadProc (poly p)
 
int iiTokType (int op)
 
static BOOLEAN jjOP_BIM_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjOP_I_BIM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjOP_BIM_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjOP_BI_BIM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjOP_IV_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjOP_I_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjOP_IM_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjOP_I_IM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOLON (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDOTDOT (leftv res, leftv u, leftv v)
 
static void jjEQUAL_REST (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOMPARE_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOMPARE_BIM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOMPARE_IV_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOMPARE_MA (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOMPARE_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOMPARE_S (leftv res, leftv u, leftv v)
 
static BOOLEAN jjOP_REST (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPOWER_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPOWER_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPOWER_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPOWER_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPOWER_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUSMINUS_Gen (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOLCOL (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_V (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_B (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_B_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_BIM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_MA (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_SM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_MA_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_P_MA (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_S (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPLUS_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMINUS_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMINUS_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMINUS_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMINUS_V (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMINUS_B_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMINUS_B (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMINUS_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMINUS_BIM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMINUS_MA (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMINUS_SM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_BIM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_MA_BI1 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_MA_BI2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_MA_P1 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_MA_P2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_MA_N1 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_MA_N2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_MA_I1 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_MA_I2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_MA (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTIMES_SM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjGE_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjGE_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjGE_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjGT_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjGT_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjGT_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjLE_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjLE_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjLE_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjLT_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjLT_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjLT_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDIVMOD_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDIV_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDIV_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDIV_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDIV_Ma (leftv res, leftv u, leftv v)
 
static BOOLEAN jjEQUAL_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjEQUAL_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjEQUAL_Ma (leftv res, leftv u, leftv v)
 
static BOOLEAN jjEQUAL_SM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjEQUAL_R (leftv res, leftv u, leftv v)
 
static BOOLEAN jjEQUAL_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjEQUAL_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjAND_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjOR_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjINDEX_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjINDEX_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjINDEX_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjINDEX_PBu (leftv res, leftv u, leftv v)
 
static BOOLEAN jjINDEX_P_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjINDEX_V (leftv res, leftv u, leftv v)
 
static BOOLEAN jjINDEX_V_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjKLAMMER_rest (leftv res, leftv u, leftv v)
 
static BOOLEAN jjKLAMMER (leftv res, leftv u, leftv v)
 
static BOOLEAN jjKLAMMER_IV (leftv res, leftv u, leftv v)
 
BOOLEAN jjPROC (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMAP (leftv res, leftv u, leftv v)
 
static BOOLEAN jjRING_1 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCHINREM_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjALIGN_V (leftv res, leftv u, leftv v)
 
static BOOLEAN jjALIGN_M (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCHINREM_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOEF (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOEF_Id (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOEFFS_Id (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCOEFFS2_KB (leftv res, leftv u, leftv v)
 
static BOOLEAN jjCONTRACT (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDEG_M_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDEG_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDelete_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDelete_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDET2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDET2_S (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDIFF_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDIFF_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDIFF_ID_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjDIM2 (leftv res, leftv v, leftv w)
 
static BOOLEAN jjDIVISION (leftv res, leftv u, leftv v)
 
static BOOLEAN jjELIMIN (leftv res, leftv u, leftv v)
 
static BOOLEAN jjELIMIN_IV (leftv res, leftv u, leftv v)
 
static BOOLEAN jjEXPORTTO (leftv, leftv u, leftv v)
 
static BOOLEAN jjERROR (leftv, leftv u)
 
static BOOLEAN jjEXTGCD_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjEXTGCD_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjEXTGCD_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjFAC_P2 (leftv res, leftv u, leftv dummy)
 
static BOOLEAN jjFACSTD2 (leftv res, leftv v, leftv w)
 
static BOOLEAN jjFAREY_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjFAREY_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjFAREY_LI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjFETCH (leftv res, leftv u, leftv v)
 
static BOOLEAN jjFIND2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjFRES3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjFRES (leftv res, leftv u, leftv v)
 
static BOOLEAN jjFWALK (leftv res, leftv u, leftv v)
 
static BOOLEAN jjGCD_I (leftv res, leftv u, leftv v)
 
static BOOLEAN jjGCD_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjGCD_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjGCD_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjHILBERT2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjHOMOG_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjHOMOG_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjHOMOG1_W (leftv res, leftv v, leftv u)
 
static BOOLEAN jjHOMOG1_WI (leftv res, leftv v, leftv u)
 
static BOOLEAN jjINDEPSET2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjINTERSECT (leftv res, leftv u, leftv v)
 
static BOOLEAN jjINTERPOLATION (leftv res, leftv l, leftv v)
 
static BOOLEAN jjJanetBasis2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjJanetBasis (leftv res, leftv v)
 
static BOOLEAN jjJET_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjJET_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjKBASE2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPREIMAGE (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjKERNEL (leftv res, leftv u, leftv v)
 
static BOOLEAN jjKoszul (leftv res, leftv u, leftv v)
 
static BOOLEAN jjKoszul_Id (leftv res, leftv u, leftv v)
 
static BOOLEAN jjLIFT (leftv res, leftv u, leftv v)
 
static BOOLEAN jjLIFTSTD (leftv res, leftv u, leftv v)
 
static BOOLEAN jjLOAD2 (leftv, leftv, leftv v)
 
static BOOLEAN jjLOAD_E (leftv, leftv v, leftv u)
 
static BOOLEAN jjMODULO (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMOD_BI (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMOD_N (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMOD_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMONITOR2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjMONITOR1 (leftv res, leftv v)
 
static BOOLEAN jjMONOM (leftv res, leftv v)
 
static BOOLEAN jjNEWSTRUCT2 (leftv, leftv u, leftv v)
 
static BOOLEAN jjPARSTR2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPlural_num_poly (leftv res, leftv a, leftv b)
 
static BOOLEAN jjPlural_num_mat (leftv res, leftv a, leftv b)
 
static BOOLEAN jjPlural_mat_poly (leftv res, leftv a, leftv b)
 
static BOOLEAN jjPlural_mat_mat (leftv res, leftv a, leftv b)
 
static BOOLEAN jjBRACKET (leftv res, leftv a, leftv b)
 
static BOOLEAN jjBRACKET_REC (leftv res, leftv a, leftv b, leftv c)
 
static BOOLEAN jjOPPOSE (leftv res, leftv a, leftv b)
 
static BOOLEAN jjQUOT (leftv res, leftv u, leftv v)
 
static BOOLEAN jjRANDOM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjRANK2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjREAD2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjREDUCE_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjREDUCE_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjRES (leftv res, leftv u, leftv v)
 
static BOOLEAN jjPFAC2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjRMINUS (leftv res, leftv u, leftv v)
 
static BOOLEAN jjRPLUS (leftv res, leftv u, leftv v)
 
static BOOLEAN jjRSUM (leftv res, leftv u, leftv v)
 
static BOOLEAN jjSIMPL_ID (leftv res, leftv u, leftv v)
 
static BOOLEAN jjSQR_FREE2 (leftv res, leftv u, leftv dummy)
 
static BOOLEAN jjSTATUS2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjSTATUS2L (leftv res, leftv u, leftv v)
 
static BOOLEAN jjSIMPL_P (leftv res, leftv u, leftv v)
 
static BOOLEAN jjSTD_HILB (leftv res, leftv u, leftv v)
 
static BOOLEAN jjSTD_1 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjSYZ_2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTENSOR (leftv res, leftv u, leftv v)
 
static BOOLEAN jjTENSOR_Ma (leftv res, leftv u, leftv v)
 
static BOOLEAN jjVARSTR2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjWAIT1ST2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjWAITALL2 (leftv res, leftv u, leftv v)
 
static BOOLEAN jjWEDGE (leftv res, leftv u, leftv v)
 
static BOOLEAN jjWRONG (leftv, leftv)
 
static BOOLEAN jjDUMMY (leftv res, leftv u)
 
static BOOLEAN jjNULL (leftv, leftv)
 
static BOOLEAN jjPLUSPLUS (leftv, leftv u)
 
static BOOLEAN jjUMINUS_BI (leftv res, leftv u)
 
static BOOLEAN jjUMINUS_I (leftv res, leftv u)
 
static BOOLEAN jjUMINUS_N (leftv res, leftv u)
 
static BOOLEAN jjUMINUS_P (leftv res, leftv u)
 
static BOOLEAN jjUMINUS_MA (leftv res, leftv u)
 
static BOOLEAN jjUMINUS_IV (leftv res, leftv u)
 
static BOOLEAN jjUMINUS_BIM (leftv res, leftv u)
 
static BOOLEAN jjSetRing (leftv, leftv u)
 
static BOOLEAN jjPROC1 (leftv res, leftv u)
 
static BOOLEAN jjBAREISS (leftv res, leftv v)
 
static BOOLEAN jjBAREISS_BIM (leftv res, leftv v)
 
static BOOLEAN jjBI2N (leftv res, leftv u)
 
static BOOLEAN jjBI2IM (leftv res, leftv u)
 
static BOOLEAN jjBI2P (leftv res, leftv u)
 
static BOOLEAN jjCALL1MANY (leftv res, leftv u)
 
static BOOLEAN jjCHAR (leftv res, leftv v)
 
static BOOLEAN jjCOLS (leftv res, leftv v)
 
static BOOLEAN jjCOLS_BIM (leftv res, leftv v)
 
static BOOLEAN jjCOLS_IV (leftv res, leftv v)
 
static BOOLEAN jjCONTENT (leftv res, leftv v)
 
static BOOLEAN jjCOUNT_BI (leftv res, leftv v)
 
static BOOLEAN jjCOUNT_BIM (leftv res, leftv v)
 
static BOOLEAN jjCOUNT_N (leftv res, leftv v)
 
static BOOLEAN jjCOUNT_L (leftv res, leftv v)
 
static BOOLEAN jjCOUNT_M (leftv res, leftv v)
 
static BOOLEAN jjCOUNT_IV (leftv res, leftv v)
 
static BOOLEAN jjCOUNT_RG (leftv res, leftv v)
 
static BOOLEAN jjDEG (leftv res, leftv v)
 
static BOOLEAN jjDEG_M (leftv res, leftv u)
 
static BOOLEAN jjDEGREE (leftv res, leftv v)
 
static BOOLEAN jjDEFINED (leftv res, leftv v)
 
static BOOLEAN jjDENOMINATOR (leftv res, leftv v)
 Return the denominator of the input number. More...
 
static BOOLEAN jjNUMERATOR (leftv res, leftv v)
 Return the numerator of the input number. More...
 
static BOOLEAN jjDET (leftv res, leftv v)
 
static BOOLEAN jjDET_BI (leftv res, leftv v)
 
static BOOLEAN jjDET_I (leftv res, leftv v)
 
static BOOLEAN jjDET_S (leftv res, leftv v)
 
static BOOLEAN jjDIM (leftv res, leftv v)
 
static BOOLEAN jjDUMP (leftv, leftv v)
 
static BOOLEAN jjE (leftv res, leftv v)
 
static BOOLEAN jjEXECUTE (leftv, leftv v)
 
static BOOLEAN jjFACSTD (leftv res, leftv v)
 
static BOOLEAN jjFAC_P (leftv res, leftv u)
 
static BOOLEAN jjGETDUMP (leftv, leftv v)
 
static BOOLEAN jjHIGHCORNER (leftv res, leftv v)
 
static BOOLEAN jjHIGHCORNER_M (leftv res, leftv v)
 
static BOOLEAN jjHILBERT (leftv, leftv v)
 
static BOOLEAN jjHILBERT_IV (leftv res, leftv v)
 
static BOOLEAN jjHOMOG1 (leftv res, leftv v)
 
static BOOLEAN jjidMaxIdeal (leftv res, leftv v)
 
static BOOLEAN jjIDEAL_Ma (leftv res, leftv v)
 
static BOOLEAN jjIDEAL_Map (leftv res, leftv v)
 
static BOOLEAN jjIDEAL_R (leftv res, leftv v)
 
static BOOLEAN jjIm2Iv (leftv res, leftv v)
 
static BOOLEAN jjIMPART (leftv res, leftv v)
 
static BOOLEAN jjINDEPSET (leftv res, leftv v)
 
static BOOLEAN jjINTERRED (leftv res, leftv v)
 
static BOOLEAN jjIS_RINGVAR_P (leftv res, leftv v)
 
static BOOLEAN jjIS_RINGVAR_S (leftv res, leftv v)
 
static BOOLEAN jjIS_RINGVAR0 (leftv res, leftv)
 
static BOOLEAN jjJACOB_P (leftv res, leftv v)
 
static BOOLEAN jjDIFF_COEF (leftv res, leftv u, leftv v)
 
static BOOLEAN jjJACOB_M (leftv res, leftv a)
 
static BOOLEAN jjKERNEL_M (leftv res, leftv v)
 
static BOOLEAN jjKERNEL_SM (leftv res, leftv v)
 
static BOOLEAN jjKBASE (leftv res, leftv v)
 
static BOOLEAN jjL2R (leftv res, leftv v)
 
static BOOLEAN jjLEADCOEF (leftv res, leftv v)
 
static BOOLEAN jjLEADEXP (leftv res, leftv v)
 
static BOOLEAN jjLEADMONOM (leftv res, leftv v)
 
static BOOLEAN jjLOAD1 (leftv, leftv v)
 
static BOOLEAN jjLISTRING (leftv res, leftv v)
 
static BOOLEAN jjPFAC1 (leftv res, leftv v)
 
static BOOLEAN jjLagSolve (leftv res, leftv v)
 
static BOOLEAN jjLU_DECOMP (leftv res, leftv v)
 
static BOOLEAN jjMEMORY (leftv res, leftv v)
 
static BOOLEAN jjMSTD (leftv res, leftv v)
 
static BOOLEAN jjMULT (leftv res, leftv v)
 
static BOOLEAN jjMINRES_R (leftv res, leftv v)
 
static BOOLEAN jjN2BI (leftv res, leftv v)
 
static BOOLEAN jjNAMEOF (leftv res, leftv v)
 
static BOOLEAN jjNAMES (leftv res, leftv v)
 
static BOOLEAN jjNAMES_I (leftv res, leftv v)
 
static BOOLEAN jjNOT (leftv res, leftv v)
 
static BOOLEAN jjNVARS (leftv res, leftv v)
 
static BOOLEAN jjOpenClose (leftv, leftv v)
 
static BOOLEAN jjORD (leftv res, leftv v)
 
static BOOLEAN jjPAR1 (leftv res, leftv v)
 
static BOOLEAN jjPARDEG (leftv res, leftv v)
 
static BOOLEAN jjPARSTR1 (leftv res, leftv v)
 
static BOOLEAN jjP2BI (leftv res, leftv v)
 
static BOOLEAN jjP2I (leftv res, leftv v)
 
static BOOLEAN jjPREIMAGE_R (leftv res, leftv v)
 
static BOOLEAN jjPRIME (leftv res, leftv v)
 
static BOOLEAN jjPRUNE (leftv res, leftv v)
 
static BOOLEAN jjP2N (leftv res, leftv v)
 
static BOOLEAN jjRESERVEDNAME (leftv res, leftv v)
 
static BOOLEAN jjRANK1 (leftv res, leftv v)
 
static BOOLEAN jjREAD (leftv res, leftv v)
 
static BOOLEAN jjREGULARITY (leftv res, leftv v)
 
static BOOLEAN jjREPART (leftv res, leftv v)
 
static BOOLEAN jjRINGLIST (leftv res, leftv v)
 
static BOOLEAN jjRINGLIST_C (leftv res, leftv v)
 
static BOOLEAN jjRING_LIST (leftv res, leftv v)
 
static BOOLEAN jjROWS (leftv res, leftv v)
 
static BOOLEAN jjROWS_BIM (leftv res, leftv v)
 
static BOOLEAN jjROWS_IV (leftv res, leftv v)
 
static BOOLEAN jjRPAR (leftv res, leftv v)
 
static BOOLEAN jjS2I (leftv res, leftv v)
 
static BOOLEAN jjSLIM_GB (leftv res, leftv u)
 
static BOOLEAN jjSBA (leftv res, leftv v)
 
static BOOLEAN jjSBA_1 (leftv res, leftv v, leftv u)
 
static BOOLEAN jjSBA_2 (leftv res, leftv v, leftv u, leftv t)
 
static BOOLEAN jjSTD (leftv res, leftv v)
 
static BOOLEAN jjSort_Id (leftv res, leftv v)
 
static BOOLEAN jjSQR_FREE (leftv res, leftv u)
 
static BOOLEAN jjSYZYGY (leftv res, leftv v)
 
static BOOLEAN jjTRACE_IV (leftv res, leftv v)
 
static BOOLEAN jjTRANSP_BIM (leftv res, leftv v)
 
static BOOLEAN jjTRANSP_IV (leftv res, leftv v)
 
static BOOLEAN jjOPPOSITE (leftv res, leftv a)
 
static BOOLEAN jjENVELOPE (leftv res, leftv a)
 
static BOOLEAN jjTWOSTD (leftv res, leftv a)
 
static BOOLEAN jjRIGHTSTD (leftv res, leftv v)
 
static BOOLEAN jjTYPEOF (leftv res, leftv v)
 
static BOOLEAN jjUNIVARIATE (leftv res, leftv v)
 
static BOOLEAN jjVAR1 (leftv res, leftv v)
 
static BOOLEAN jjVARSTR1 (leftv res, leftv v)
 
static BOOLEAN jjVDIM (leftv res, leftv v)
 
BOOLEAN jjWAIT1ST1 (leftv res, leftv u)
 
BOOLEAN jjWAITALL1 (leftv res, leftv u)
 
BOOLEAN jjLOAD (const char *s, BOOLEAN autoexport)
 load lib/module given in v More...
 
static void WerrorS_dummy (const char *)
 
BOOLEAN jjLOAD_TRY (const char *s)
 
static BOOLEAN jjstrlen (leftv res, leftv v)
 
static BOOLEAN jjpLength (leftv res, leftv v)
 
static BOOLEAN jjidElem (leftv res, leftv v)
 
static BOOLEAN jjidFreeModule (leftv res, leftv v)
 
static BOOLEAN jjidVec2Ideal (leftv res, leftv v)
 
static BOOLEAN jjrCharStr (leftv res, leftv v)
 
static BOOLEAN jjpHead (leftv res, leftv v)
 
static BOOLEAN jjidHead (leftv res, leftv v)
 
static BOOLEAN jjidMinBase (leftv res, leftv v)
 
static BOOLEAN jjpMaxComp (leftv res, leftv v)
 
static BOOLEAN jjmpTrace (leftv res, leftv v)
 
static BOOLEAN jjmpTransp (leftv res, leftv v)
 
static BOOLEAN jjrOrdStr (leftv res, leftv v)
 
static BOOLEAN jjrVarStr (leftv res, leftv v)
 
static BOOLEAN jjrParStr (leftv res, leftv v)
 
static BOOLEAN jjCOUNT_RES (leftv res, leftv v)
 
static BOOLEAN jjDIM_R (leftv res, leftv v)
 
static BOOLEAN jjidTransp (leftv res, leftv v)
 
static BOOLEAN jjnInt (leftv res, leftv u)
 
static BOOLEAN jjnlInt (leftv res, leftv u)
 
static BOOLEAN jjBRACK_S (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjBRACK_Im (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjBRACK_Bim (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjBRACK_Ma (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjBRACK_SM (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjBRACK_Ma_I_IV (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjBRACK_Ma_IV_I (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjBRACK_Ma_IV_IV (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjPROC3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjRING_2 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjBAREISS3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjCOEFFS3_Id (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjCOEFFS3_KB (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjCOEFFS3_P (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjELIMIN_ALG (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjELIMIN_HILB (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjFIND3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjFWALK3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjHILBERT3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjHOMOG_ID_W (leftv res, leftv u, leftv v, leftv)
 
static BOOLEAN jjHOMOG_P_W (leftv res, leftv u, leftv v, leftv)
 
static BOOLEAN jjHOMOG_W_M (leftv res, leftv v1, leftv v2, leftv v3)
 
static BOOLEAN jjINTMAT3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjINTERSECT3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjINTERSEC3S (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjJET_P_IV (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjJET_P_P (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjJET_ID_IV (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjJET_ID_M (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjMINOR_M (leftv res, leftv v)
 
static BOOLEAN jjNEWSTRUCT3 (leftv, leftv u, leftv v, leftv w)
 
static BOOLEAN jjRANDOM_Im (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjSUBST_Test (leftv v, leftv w, int &ringvar, poly &monomexpr)
 
static BOOLEAN jjSUBST_Bu (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjSUBST_P (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjSUBST_Id (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjSUBST_Id_X (leftv res, leftv u, leftv v, leftv w, int input_type)
 
static BOOLEAN jjSUBST_Id_I (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjSUBST_Id_N (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjMATRIX_Id (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjMATRIX_Mo (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjMATRIX_Ma (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjMODULO3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjMODULO3S (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjSMATRIX_Mo (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjLIFT3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjLIFTSTD_SYZ (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjLIFTSTD_ALG (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjREDUCE3_CP (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjREDUCE3_CID (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjREDUCE3_P (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjREDUCE3_ID (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjRES3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjRING3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjSTATUS3 (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjSTD_HILB_W (leftv res, leftv u, leftv v, leftv w)
 
static BOOLEAN jjBREAK0 (leftv, leftv)
 
static BOOLEAN jjBREAK1 (leftv, leftv v)
 
static BOOLEAN jjCALL1ARG (leftv res, leftv v)
 
static BOOLEAN jjCALL2ARG (leftv res, leftv u)
 
static BOOLEAN jjCALL3ARG (leftv res, leftv u)
 
static BOOLEAN jjCOEF_M (leftv, leftv v)
 
static BOOLEAN jjDIVISION4 (leftv res, leftv v)
 
static BOOLEAN jjIDEAL_PL (leftv res, leftv v)
 
static BOOLEAN jjFETCH_M (leftv res, leftv u)
 
static BOOLEAN jjINTERSECT_PL (leftv res, leftv v)
 
static BOOLEAN jjLU_INVERSE (leftv res, leftv v)
 
static BOOLEAN jjLU_SOLVE (leftv res, leftv v)
 
static BOOLEAN jjINTVEC_PL (leftv res, leftv v)
 
static BOOLEAN jjJET4 (leftv res, leftv u)
 
static BOOLEAN jjKLAMMER_PL (leftv res, leftv u)
 
static BOOLEAN jjLIFT_4 (leftv res, leftv U)
 
static BOOLEAN jjLIFTSTD_M (leftv res, leftv U)
 
BOOLEAN jjLIST_PL (leftv res, leftv v)
 
static BOOLEAN jjMODULO4 (leftv res, leftv u)
 
static BOOLEAN jjNAMES0 (leftv res, leftv)
 
static BOOLEAN jjOPTION_PL (leftv res, leftv v)
 
static BOOLEAN jjREDUCE4 (leftv res, leftv u)
 
static BOOLEAN jjREDUCE5 (leftv res, leftv u)
 
static BOOLEAN jjRESERVED0 (leftv, leftv)
 
static BOOLEAN jjRESERVEDLIST0 (leftv res, leftv)
 
static BOOLEAN jjSTRING_PL (leftv res, leftv v)
 
static BOOLEAN jjTEST (leftv, leftv v)
 
static BOOLEAN jjFactModD_M (leftv res, leftv v)
 
static BOOLEAN jjSTATUS_M (leftv res, leftv v)
 
static BOOLEAN jjSUBST_M (leftv res, leftv u)
 
static BOOLEAN jjQRDS (leftv res, leftv INPUT)
 
static BOOLEAN jjSTD_HILB_WP (leftv res, leftv INPUT)
 
static BOOLEAN jjRING_PL (leftv res, leftv a)
 
static BOOLEAN jjRESTART (leftv, leftv u)
 
static BOOLEAN iiExprArith2TabIntern (leftv res, leftv a, int op, leftv b, BOOLEAN proccall, const struct sValCmd2 *dA2, int at, int bt, const struct sConvertTypes *dConvertTypes)
 
BOOLEAN iiExprArith2Tab (leftv res, leftv a, int op, const struct sValCmd2 *dA2, int at, const struct sConvertTypes *dConvertTypes)
 apply an operation 'op' to arguments a and a->next return TRUE on failure More...
 
BOOLEAN iiExprArith2 (leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
 
BOOLEAN iiExprArith1Tab (leftv res, leftv a, int op, const struct sValCmd1 *dA1, int at, const struct sConvertTypes *dConvertTypes)
 apply an operation 'op' to an argument a return TRUE on failure More...
 
BOOLEAN iiExprArith1 (leftv res, leftv a, int op)
 
static BOOLEAN iiExprArith3TabIntern (leftv res, int op, leftv a, leftv b, leftv c, const struct sValCmd3 *dA3, int at, int bt, int ct, const struct sConvertTypes *dConvertTypes)
 
BOOLEAN iiExprArith3 (leftv res, int op, leftv a, leftv b, leftv c)
 
BOOLEAN iiExprArith3Tab (leftv res, leftv a, int op, const struct sValCmd3 *dA3, int at, const struct sConvertTypes *dConvertTypes)
 apply an operation 'op' to arguments a, a->next and a->next->next return TRUE on failure More...
 
BOOLEAN iiExprArithM (leftv res, leftv a, int op)
 
int IsCmd (const char *n, int &tok)
 
const char * Tok2Cmdname (int tok)
 
int iiInitArithmetic ()
 initialisation of arithmetic structured data More...
 
int iiArithFindCmd (const char *szName)
 
char * iiArithGetCmd (int nPos)
 
int iiArithRemoveCmd (const char *szName)
 
static int jjCOMPARE_ALL (const void *aa, const void *bb)
 
BOOLEAN jjSORTLIST (leftv, leftv arg)
 
BOOLEAN jjUNIQLIST (leftv, leftv arg)
 

Variables

long all_farey =0L
 
long farey_cnt =0L
 
STATIC_VAR SArithBase sArithBase
 Base entry for arithmetic. More...
 
EXTERN_VAR int cmdtok
 
EXTERN_VAR BOOLEAN expected_parms
 
VAR int iiOp
 
EXTERN_VAR int singclap_factorize_retry
 
STATIC_VAR int WerrorS_dummy_cnt =0
 
STATIC_VAR si_char_2 Tok2Cmdname_buf =" "
 

Data Structure Documentation

◆ sValCmdTab

struct sValCmdTab

Definition at line 127 of file iparith.cc.

Data Fields
short cmd
short start

◆ _scmdnames

struct _scmdnames

Definition at line 59 of file gentable.cc.

Data Fields
short alias
const char * name
char * name
short toktype
short tokval

◆ sValCmd1

struct sValCmd1

Definition at line 78 of file gentable.cc.

Data Fields
short arg
short cmd
int p
proc1 p
short res
short valid_for

◆ sValCmd2

struct sValCmd2

Definition at line 69 of file gentable.cc.

Data Fields
short arg1
short arg2
short cmd
int p
proc2 p
short res
short valid_for

◆ sValCmd3

struct sValCmd3

Definition at line 86 of file gentable.cc.

Data Fields
short arg1
short arg2
short arg3
short cmd
int p
proc3 p
short res
short valid_for

◆ sValCmdM

struct sValCmdM

Definition at line 96 of file gentable.cc.

Data Fields
short cmd
short number_of_args
int p
proc1 p
short res
short valid_for

◆ SArithBase

struct SArithBase

Definition at line 184 of file iparith.cc.

Data Fields
unsigned nCmdAllocated number of commands-slots allocated
unsigned nCmdUsed number of commands used
unsigned nLastIdentifier valid indentifieres are slot 1..nLastIdentifier
struct sValCmd1 * psValCmd1
struct sValCmd2 * psValCmd2
struct sValCmd3 * psValCmd3
struct sValCmdM * psValCmdM
cmdnames * sCmds array of existing commands

Macro Definition Documentation

◆ ALLOW_LP

#define ALLOW_LP   64

Definition at line 111 of file iparith.cc.

◆ ALLOW_NC

#define ALLOW_NC   ALLOW_LP|ALLOW_PLURAL

Definition at line 112 of file iparith.cc.

◆ ALLOW_PLURAL

#define ALLOW_PLURAL   1

Definition at line 104 of file iparith.cc.

◆ ALLOW_RING

#define ALLOW_RING   4

Definition at line 107 of file iparith.cc.

◆ ALLOW_ZERODIVISOR

#define ALLOW_ZERODIVISOR   0

Definition at line 110 of file iparith.cc.

◆ ALLOW_ZZ

#define ALLOW_ZZ   (ALLOW_RING|NO_ZERODIVISOR)

Definition at line 114 of file iparith.cc.

◆ bit31

#define bit31   SIZEOF_LONG*8-1

Definition at line 124 of file iparith.cc.

◆ COMM_PLURAL

#define COMM_PLURAL   2

Definition at line 106 of file iparith.cc.

◆ D

#define D (   A)    (A)

Definition at line 8720 of file iparith.cc.

◆ ii_div_by_0

#define ii_div_by_0   "div. by 0"

Definition at line 220 of file iparith.cc.

◆ IPARITH

#define IPARITH

Definition at line 8722 of file iparith.cc.

◆ jjWRONG2

#define jjWRONG2   (proc2)jjWRONG

Definition at line 3678 of file iparith.cc.

◆ jjWRONG3

#define jjWRONG3   (proc3)jjWRONG

Definition at line 3679 of file iparith.cc.

◆ NC_MASK

#define NC_MASK   (3+64)

Definition at line 92 of file iparith.cc.

◆ NO_CONVERSION

#define NO_CONVERSION   32

Definition at line 120 of file iparith.cc.

◆ NO_NC

#define NO_NC   0

Definition at line 105 of file iparith.cc.

◆ NO_RING

#define NO_RING   0

Definition at line 108 of file iparith.cc.

◆ NO_ZERODIVISOR

#define NO_ZERODIVISOR   8

Definition at line 109 of file iparith.cc.

◆ NULL_VAL

#define NULL_VAL   NULL

Definition at line 8721 of file iparith.cc.

◆ RING_MASK

#define RING_MASK   4

Definition at line 98 of file iparith.cc.

◆ SIMPL_EQU

#define SIMPL_EQU   4

Definition at line 3275 of file iparith.cc.

◆ SIMPL_LMDIV

#define SIMPL_LMDIV   32

Definition at line 3272 of file iparith.cc.

◆ SIMPL_LMEQ

#define SIMPL_LMEQ   16

Definition at line 3273 of file iparith.cc.

◆ SIMPL_MULT

#define SIMPL_MULT   8

Definition at line 3274 of file iparith.cc.

◆ SIMPL_NORM

#define SIMPL_NORM   1

Definition at line 3277 of file iparith.cc.

◆ SIMPL_NORMALIZE

#define SIMPL_NORMALIZE   64

Definition at line 3271 of file iparith.cc.

◆ SIMPL_NULL

#define SIMPL_NULL   2

Definition at line 3276 of file iparith.cc.

◆ WARN_RING

#define WARN_RING   16

Definition at line 118 of file iparith.cc.

◆ ZERODIVISOR_MASK

#define ZERODIVISOR_MASK   8

Definition at line 99 of file iparith.cc.

Typedef Documentation

◆ jjValCmdTab

typedef sValCmdTab jjValCmdTab[]

Definition at line 133 of file iparith.cc.

◆ proc2

typedef BOOLEAN(* proc2) (leftv, leftv, leftv)

Definition at line 153 of file iparith.cc.

◆ proc3

typedef BOOLEAN(* proc3) (leftv, leftv, leftv, leftv)

Definition at line 164 of file iparith.cc.

◆ si_char_2

typedef char si_char_2[2]

Definition at line 9625 of file iparith.cc.

Function Documentation

◆ _gentable_sort_cmds()

static int _gentable_sort_cmds ( const void *  a,
const void *  b 
)
static

compares to entry of cmdsname-list

Parameters
[in]a
[in]b
Returns
<ReturnValue>

Definition at line 9681 of file iparith.cc.

9682{
9683 cmdnames *pCmdL = (cmdnames*)a;
9684 cmdnames *pCmdR = (cmdnames*)b;
9685
9686 if(a==NULL || b==NULL) return 0;
9687
9688 /* empty entries goes to the end of the list for later reuse */
9689 if(pCmdL->name==NULL) return 1;
9690 if(pCmdR->name==NULL) return -1;
9691
9692 /* $INVALID$ must come first */
9693 if(strcmp(pCmdL->name, "$INVALID$")==0) return -1;
9694 if(strcmp(pCmdR->name, "$INVALID$")==0) return 1;
9695
9696 /* tokval=-1 are reserved names at the end */
9697 if (pCmdL->tokval==-1)
9698 {
9699 if (pCmdR->tokval==-1)
9700 return strcmp(pCmdL->name, pCmdR->name);
9701 /* pCmdL->tokval==-1, pCmdL goes at the end */
9702 return 1;
9703 }
9704 /* pCmdR->tokval==-1, pCmdR goes at the end */
9705 if(pCmdR->tokval==-1) return -1;
9706
9707 return strcmp(pCmdL->name, pCmdR->name);
9708}
CanonicalForm b
Definition: cfModGcd.cc:4103
#define NULL
Definition: omList.c:12

◆ check_valid()

static BOOLEAN check_valid ( const int  p,
const int  op 
)
static

Definition at line 9907 of file iparith.cc.

9908{
9910 {
9911 if ((p & NC_MASK)==NO_NC)
9912 {
9913 WerrorS("not implemented for non-commutative rings");
9914 return TRUE;
9915 }
9916 else if ((p & NC_MASK)==COMM_PLURAL)
9917 {
9918 Warn("assume commutative subalgebra for cmd `%s` in >>%s<<",Tok2Cmdname(op),my_yylinebuf);
9919 return FALSE;
9920 }
9921 /* else, ALLOW_PLURAL */
9922 }
9923 else if (rIsLPRing(currRing))
9924 {
9925 if ((p & ALLOW_LP)==0)
9926 {
9927 Werror("`%s` not implemented for letterplace rings in >>%s<<",Tok2Cmdname(op),my_yylinebuf);
9928 return TRUE;
9929 }
9930 }
9932 {
9933 if ((p & RING_MASK)==0 /*NO_RING*/)
9934 {
9935 WerrorS("not implemented for rings with rings as coeffients");
9936 return TRUE;
9937 }
9938 /* else ALLOW_RING */
9939 else if (((p & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
9941 {
9942 WerrorS("domain required as coeffients");
9943 return TRUE;
9944 }
9945 /* else ALLOW_ZERODIVISOR */
9946 else if(((p & WARN_RING)==WARN_RING)&&(myynest==0))
9947 {
9948 WarnS("considering the image in Q[...]");
9949 }
9950 }
9951 return FALSE;
9952}
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
int p
Definition: cfModGcd.cc:4078
#define Warn
Definition: emacs.cc:77
#define WarnS
Definition: emacs.cc:78
void WerrorS(const char *s)
Definition: feFopen.cc:24
VAR char my_yylinebuf[80]
Definition: febase.cc:44
VAR int myynest
Definition: febase.cc:41
#define COMM_PLURAL
Definition: iparith.cc:106
#define NO_ZERODIVISOR
Definition: iparith.cc:109
#define ALLOW_LP
Definition: iparith.cc:111
#define RING_MASK
Definition: iparith.cc:98
#define WARN_RING
Definition: iparith.cc:118
#define NC_MASK
Definition: iparith.cc:92
const char * Tok2Cmdname(int tok)
Definition: iparith.cc:9627
#define NO_NC
Definition: iparith.cc:105
#define ZERODIVISOR_MASK
Definition: iparith.cc:99
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
void Werror(const char *fmt,...)
Definition: reporter.cc:189
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
static BOOLEAN rField_is_Domain(const ring r)
Definition: ring.h:488
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:411
#define rField_is_Ring(R)
Definition: ring.h:486

◆ iiArithAddCmd()

int iiArithAddCmd ( const char *  szName,
short  nAlias,
short  nTokval,
short  nToktype,
short  nPos = -1 
)

Definition at line 9848 of file iparith.cc.

9855{
9856 //printf("AddCmd(%s, %d, %d, %d, %d)\n", szName, nAlias,
9857 // nTokval, nToktype, nPos);
9858 if(nPos>=0)
9859 {
9860 // no checks: we rely on a correct generated code in iparith.inc
9861 assume((unsigned)nPos < sArithBase.nCmdAllocated);
9862 assume(szName!=NULL);
9863 sArithBase.sCmds[nPos].name = omStrDup(szName);
9864 sArithBase.sCmds[nPos].alias = nAlias;
9865 sArithBase.sCmds[nPos].tokval = nTokval;
9866 sArithBase.sCmds[nPos].toktype = nToktype;
9868 //if(nTokval>0) sArithBase.nLastIdentifier++;
9869 }
9870 else
9871 {
9872 if(szName==NULL) return -1;
9873 int nIndex = iiArithFindCmd(szName);
9874 if(nIndex>=0)
9875 {
9876 Print("'%s' already exists at %d\n", szName, nIndex);
9877 return -1;
9878 }
9879
9881 {
9882 /* needs to create new slots */
9883 unsigned long nSize = (sArithBase.nCmdAllocated+1)*sizeof(cmdnames);
9885 if(sArithBase.sCmds==NULL) return -1;
9887 }
9888 /* still free slots available */
9890 sArithBase.sCmds[sArithBase.nCmdUsed].alias = nAlias;
9891 sArithBase.sCmds[sArithBase.nCmdUsed].tokval = nTokval;
9892 sArithBase.sCmds[sArithBase.nCmdUsed].toktype = nToktype;
9894
9895 qsort(sArithBase.sCmds, sArithBase.nCmdUsed, sizeof(cmdnames),
9899 {
9900 if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
9901 }
9902 //Print("L=%d\n", sArithBase.nLastIdentifier);
9903 }
9904 return 0;
9905}
#define Print
Definition: emacs.cc:80
static int _gentable_sort_cmds(const void *a, const void *b)
compares to entry of cmdsname-list
Definition: iparith.cc:9681
int iiArithFindCmd(const char *szName)
Definition: iparith.cc:9753
cmdnames * sCmds
array of existing commands
Definition: iparith.cc:186
unsigned nLastIdentifier
valid indentifieres are slot 1..nLastIdentifier
Definition: iparith.cc:193
STATIC_VAR SArithBase sArithBase
Base entry for arithmetic.
Definition: iparith.cc:201
unsigned nCmdAllocated
number of commands-slots allocated
Definition: iparith.cc:192
unsigned nCmdUsed
number of commands used
Definition: iparith.cc:191
#define assume(x)
Definition: mod2.h:389
#define nSize(n)
Definition: numbers.h:39
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omRealloc(addr, size)
Definition: omAllocDecl.h:225

◆ iiArithFindCmd()

int iiArithFindCmd ( const char *  szName)

Definition at line 9753 of file iparith.cc.

9754{
9755 int an=0;
9756 int i = 0,v = 0;
9758
9759 loop
9760 //for(an=0; an<sArithBase.nCmdUsed; )
9761 {
9762 if(an>=en-1)
9763 {
9764 if (strcmp(szName, sArithBase.sCmds[an].name) == 0)
9765 {
9766 //Print("RET-an=%d %s\n", an, sArithBase.sCmds[an].name);
9767 return an;
9768 }
9769 else if (strcmp(szName, sArithBase.sCmds[en].name) == 0)
9770 {
9771 //Print("RET-en=%d %s\n", en, sArithBase.sCmds[en].name);
9772 return en;
9773 }
9774 else
9775 {
9776 //Print("RET- 1\n");
9777 return -1;
9778 }
9779 }
9780 i=(an+en)/2;
9781 if (*szName < *(sArithBase.sCmds[i].name))
9782 {
9783 en=i-1;
9784 }
9785 else if (*szName > *(sArithBase.sCmds[i].name))
9786 {
9787 an=i+1;
9788 }
9789 else
9790 {
9791 v=strcmp(szName,sArithBase.sCmds[i].name);
9792 if(v<0)
9793 {
9794 en=i-1;
9795 }
9796 else if(v>0)
9797 {
9798 an=i+1;
9799 }
9800 else /*v==0*/
9801 {
9802 //Print("RET-i=%d %s\n", i, sArithBase.sCmds[i].name);
9803 return i;
9804 }
9805 }
9806 }
9807 //if(i>=0 && i<sArithBase.nCmdUsed)
9808 // return i;
9809 //PrintS("RET-2\n");
9810 return -2;
9811}
int i
Definition: cfEzgcd.cc:132
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
#define loop
Definition: structs.h:75

◆ iiArithGetCmd()

char * iiArithGetCmd ( int  nPos)

Definition at line 9813 of file iparith.cc.

9814{
9815 if(nPos<0) return NULL;
9816 if(nPos<(int)sArithBase.nCmdUsed)
9817 return sArithBase.sCmds[nPos].name;
9818 return NULL;
9819}

◆ iiArithRemoveCmd() [1/2]

int iiArithRemoveCmd ( char *  szName)

◆ iiArithRemoveCmd() [2/2]

int iiArithRemoveCmd ( const char *  szName)

Definition at line 9821 of file iparith.cc.

9822{
9823 int nIndex;
9824 if(szName==NULL) return -1;
9825
9826 nIndex = iiArithFindCmd(szName);
9827 if(nIndex<0 || nIndex>=(int)sArithBase.nCmdUsed)
9828 {
9829 Print("'%s' not found (%d)\n", szName, nIndex);
9830 return -1;
9831 }
9832 omFreeBinAddr(sArithBase.sCmds[nIndex].name);
9833 sArithBase.sCmds[nIndex].name=NULL;
9834 qsort(sArithBase.sCmds, sArithBase.nCmdUsed, sizeof(cmdnames),
9837
9838 /* fix last-identifier */
9841 {
9842 if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
9843 }
9844 //Print("L=%d\n", sArithBase.nLastIdentifier);
9845 return 0;
9846}
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258

◆ iiExprArith1()

BOOLEAN iiExprArith1 ( leftv  res,
leftv  a,
int  op 
)

Definition at line 9093 of file iparith.cc.

9094{
9095 if (!errorreported)
9096 {
9097 res->Init();
9098#ifdef SIQ
9099 if (siq>0)
9100 {
9101 //Print("siq:%d\n",siq);
9103 memcpy(&d->arg1,a,sizeof(sleftv));
9104 a->Init();
9105 d->op=op;
9106 d->argc=1;
9107 res->data=(char *)d;
9108 res->rtyp=COMMAND;
9109 return FALSE;
9110 }
9111#endif
9112 int at=a->Typ();
9113 // handling bb-objects ----------------------------------------------------
9114 if(op>MAX_TOK) // explicit type conversion to bb
9115 {
9116 blackbox *bb=getBlackboxStuff(op);
9117 if (bb!=NULL)
9118 {
9119 res->rtyp=op;
9120 res->data=bb->blackbox_Init(bb);
9121 if(!bb->blackbox_Assign(res,a)) return FALSE;
9122 }
9123 else
9124 return TRUE;
9125 }
9126 else if (at>MAX_TOK) // argument is of bb-type
9127 {
9128 blackbox *bb=getBlackboxStuff(at);
9129 if (bb!=NULL)
9130 {
9131 if(!bb->blackbox_Op1(op,res,a)) return FALSE;
9132 // else: no op defined
9133 }
9134 else
9135 return TRUE;
9136 }
9137 if (errorreported) return TRUE;
9138
9139 int i=iiTabIndex(dArithTab1,JJTAB1LEN,op);
9140 return iiExprArith1Tab(res,a,op, dArith1+i,at,dConvertTypes);
9141 }
9142 a->CleanUp();
9143 return TRUE;
9144}
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition: blackbox.cc:17
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
int Typ()
Definition: subexpr.cc:1011
void Init()
Definition: subexpr.h:107
void CleanUp(ring r=currRing)
Definition: subexpr.cc:348
CanonicalForm res
Definition: facAbsFact.cc:60
VAR short errorreported
Definition: feFopen.cc:23
BOOLEAN iiExprArith1Tab(leftv res, leftv a, int op, const struct sValCmd1 *dA1, int at, const struct sConvertTypes *dConvertTypes)
apply an operation 'op' to an argument a return TRUE on failure
Definition: iparith.cc:8963
static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
Definition: iparith.cc:9602
const struct sConvertTypes dConvertTypes[]
Definition: table.h:1281
VAR omBin sip_command_bin
Definition: ipid.cc:45
ip_command * command
Definition: ipid.h:23
const struct sValCmd1 dArith1[]
Definition: table.h:37
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
VAR BOOLEAN siq
Definition: subexpr.cc:48
@ MAX_TOK
Definition: tok.h:218
#define COMMAND
Definition: tok.h:29

◆ iiExprArith1Tab()

BOOLEAN iiExprArith1Tab ( leftv  res,
leftv  a,
int  op,
const struct sValCmd1 dA1,
int  at,
const struct sConvertTypes dConvertTypes 
)

apply an operation 'op' to an argument a return TRUE on failure

Parameters
[out]respre-allocated result
[in]aargument
[in]opoperation
[in]dA1table of possible proc assumes dArith1[0].cmd==op
[in]ata->Typ()
[in]dConvertTypestable of type conversions

Definition at line 8963 of file iparith.cc.

8964{
8965 res->Init();
8966 BOOLEAN call_failed=FALSE;
8967
8968 if (!errorreported)
8969 {
8970 BOOLEAN failed=FALSE;
8971 iiOp=op;
8972 int i = 0;
8973 while (dA1[i].cmd==op)
8974 {
8975 if (at==dA1[i].arg)
8976 {
8977 if (currRing!=NULL)
8978 {
8979 if (check_valid(dA1[i].valid_for,op)) break;
8980 }
8981 else
8982 {
8983 if (RingDependend(dA1[i].res))
8984 {
8985 WerrorS("no ring active (5)");
8986 break;
8987 }
8988 }
8989 if (traceit&TRACE_CALL)
8990 Print("call %s(%s)\n",iiTwoOps(op),Tok2Cmdname(at));
8991 res->rtyp=dA1[i].res;
8992 if ((call_failed=dA1[i].p(res,a)))
8993 {
8994 break;// leave loop, goto error handling
8995 }
8996 if (a->Next()!=NULL)
8997 {
8999 failed=iiExprArith1(res->next,a->next,op);
9000 }
9001 a->CleanUp();
9002 return failed;
9003 }
9004 i++;
9005 }
9006 // implicite type conversion --------------------------------------------
9007 if (dA1[i].cmd!=op)
9008 {
9010 i=0;
9011 //Print("fuer %c , typ: %s\n",op,Tok2Cmdname(at));
9012 while (dA1[i].cmd==op)
9013 {
9014 int ai;
9015 //Print("test %s\n",Tok2Cmdname(dA1[i].arg));
9016 if ((dA1[i].valid_for & NO_CONVERSION)==0)
9017 {
9018 if ((ai=iiTestConvert(at,dA1[i].arg,dConvertTypes))!=0)
9019 {
9020 if (currRing!=NULL)
9021 {
9022 if (check_valid(dA1[i].valid_for,op)) break;
9023 }
9024 else
9025 {
9026 if (RingDependend(dA1[i].res))
9027 {
9028 WerrorS("no ring active (6)");
9029 break;
9030 }
9031 }
9032 if (traceit&TRACE_CALL)
9033 Print("call %s(%s)\n",iiTwoOps(op),Tok2Cmdname(dA1[i].arg));
9034 res->rtyp=dA1[i].res;
9035 failed= ((iiConvert(at,dA1[i].arg,ai,a,an,dConvertTypes))
9036 || (call_failed=dA1[i].p(res,an)));
9037 // everything done, clean up temp. variables
9038 if (failed)
9039 {
9040 // leave loop, goto error handling
9041 break;
9042 }
9043 else
9044 {
9045 if (an->Next() != NULL)
9046 {
9047 res->next = (leftv)omAllocBin(sleftv_bin);
9048 failed=iiExprArith1(res->next,an->next,op);
9049 }
9050 // everything ok, clean up and return
9051 an->CleanUp();
9053 return failed;
9054 }
9055 }
9056 }
9057 i++;
9058 }
9059 an->CleanUp();
9061 }
9062 // error handling
9063 if (!errorreported)
9064 {
9065 if ((at==0) && (a->Fullname()!=sNoName_fe))
9066 {
9067 Werror("`%s` is not defined",a->Fullname());
9068 }
9069 else
9070 {
9071 i=0;
9072 const char *s = iiTwoOps(op);
9073 Werror("%s(`%s`) failed"
9074 ,s,Tok2Cmdname(at));
9075 if ((!call_failed) && BVERBOSE(V_SHOW_USE))
9076 {
9077 while (dA1[i].cmd==op)
9078 {
9079 if ((dA1[i].res!=0)
9080 && (dA1[i].p!=jjWRONG))
9081 Werror("expected %s(`%s`)"
9082 ,s,Tok2Cmdname(dA1[i].arg));
9083 i++;
9084 }
9085 }
9086 }
9087 }
9088 res->rtyp = UNKNOWN;
9089 }
9090 a->CleanUp();
9091 return TRUE;
9092}
int BOOLEAN
Definition: auxiliary.h:87
void * ADDRESS
Definition: auxiliary.h:119
leftv next
Definition: subexpr.h:86
leftv Next()
Definition: subexpr.h:136
const char * Fullname()
Definition: subexpr.h:125
const CanonicalForm int s
Definition: facAbsFact.cc:51
const char sNoName_fe[]
Definition: fevoices.cc:57
int iiTestConvert(int inputType, int outputType)
Definition: gentable.cc:301
const char * iiTwoOps(int t)
Definition: gentable.cc:261
static BOOLEAN jjWRONG(leftv, leftv)
Definition: iparith.cc:3680
#define NO_CONVERSION
Definition: iparith.cc:120
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
Definition: iparith.cc:9093
static BOOLEAN check_valid(const int p, const int op)
Definition: iparith.cc:9907
VAR int iiOp
Definition: iparith.cc:222
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, const struct sConvertTypes *dConvertTypes)
Definition: ipconv.cc:435
EXTERN_VAR omBin sleftv_bin
Definition: ipid.h:145
short res
Definition: gentable.cc:82
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define BVERBOSE(a)
Definition: options.h:35
#define V_SHOW_USE
Definition: options.h:52
EXTERN_VAR int traceit
Definition: reporter.h:24
#define TRACE_CALL
Definition: reporter.h:44
sleftv * leftv
Definition: structs.h:57
BOOLEAN RingDependend(int t)
Definition: subexpr.h:142
#define UNKNOWN
Definition: tok.h:222

◆ iiExprArith2()

BOOLEAN iiExprArith2 ( leftv  res,
leftv  a,
int  op,
leftv  b,
BOOLEAN  proccall 
)

Definition at line 8904 of file iparith.cc.

8905{
8906 res->Init();
8907
8908 if (!errorreported)
8909 {
8910#ifdef SIQ
8911 if (siq>0)
8912 {
8913 //Print("siq:%d\n",siq);
8915 memcpy(&d->arg1,a,sizeof(sleftv));
8916 a->Init();
8917 memcpy(&d->arg2,b,sizeof(sleftv));
8918 b->Init();
8919 d->argc=2;
8920 d->op=op;
8921 res->data=(char *)d;
8922 res->rtyp=COMMAND;
8923 return FALSE;
8924 }
8925#endif
8926 int at=a->Typ();
8927 int bt=b->Typ();
8928 // handling bb-objects ----------------------------------------------------
8929 if (at>MAX_TOK)
8930 {
8931 blackbox *bb=getBlackboxStuff(at);
8932 if (bb!=NULL)
8933 {
8934 if (!bb->blackbox_Op2(op,res,a,b)) return FALSE;
8935 //else: no op defined, try the default
8936 }
8937 else
8938 return TRUE;
8939 }
8940 else if ((bt>MAX_TOK)&&(op!='('))
8941 {
8942 blackbox *bb=getBlackboxStuff(bt);
8943 if (bb!=NULL)
8944 {
8945 if(!bb->blackbox_Op2(op,res,a,b)) return FALSE;
8946 // else: no op defined
8947 }
8948 else
8949 return TRUE;
8950 }
8951 int i=iiTabIndex(dArithTab2,JJTAB2LEN,op);
8952 return iiExprArith2TabIntern(res,a,op,b,proccall,dArith2+i,at,bt,dConvertTypes);
8953 }
8954 a->CleanUp();
8955 b->CleanUp();
8956 return TRUE;
8957}
static BOOLEAN iiExprArith2TabIntern(leftv res, leftv a, int op, leftv b, BOOLEAN proccall, const struct sValCmd2 *dA2, int at, int bt, const struct sConvertTypes *dConvertTypes)
Definition: iparith.cc:8731
const struct sValCmd2 dArith2[]
Definition: table.h:320

◆ iiExprArith2Tab()

BOOLEAN iiExprArith2Tab ( leftv  res,
leftv  a,
int  op,
const struct sValCmd2 dA2,
int  at,
const struct sConvertTypes dConvertTypes 
)

apply an operation 'op' to arguments a and a->next return TRUE on failure

Parameters
[out]respre-allocated result
[in]a2 arguments
[in]opoperation
[in]dA2table of possible proc assumes dA2[0].cmd==op
[in]ata->Typ()
[in]dConvertTypestable of type conversions

Definition at line 8890 of file iparith.cc.

8894{
8895 res->Init();
8896 leftv b=a->next;
8897 a->next=NULL;
8898 int bt=b->Typ();
8900 a->next=b;
8901 a->CleanUp(); // to clean up the chain, content already done in iiExprArith2TabIntern
8902 return bo;
8903}

◆ iiExprArith2TabIntern()

static BOOLEAN iiExprArith2TabIntern ( leftv  res,
leftv  a,
int  op,
leftv  b,
BOOLEAN  proccall,
const struct sValCmd2 dA2,
int  at,
int  bt,
const struct sConvertTypes dConvertTypes 
)
static

Definition at line 8731 of file iparith.cc.

8736{
8737 BOOLEAN call_failed=FALSE;
8738
8739 if (!errorreported)
8740 {
8741 int i=0;
8742 iiOp=op;
8743 while (dA2[i].cmd==op)
8744 {
8745 if ((at==dA2[i].arg1)
8746 && (bt==dA2[i].arg2))
8747 {
8748 res->rtyp=dA2[i].res;
8749 if (currRing!=NULL)
8750 {
8751 if (check_valid(dA2[i].valid_for,op)) break;
8752 }
8753 else
8754 {
8755 if (RingDependend(dA2[i].res))
8756 {
8757 WerrorS("no ring active (3)");
8758 break;
8759 }
8760 }
8761 if (traceit&TRACE_CALL)
8762 Print("call %s(%s,%s)\n",iiTwoOps(op),Tok2Cmdname(at),Tok2Cmdname(bt));
8763 if ((call_failed=dA2[i].p(res,a,b)))
8764 {
8765 break;// leave loop, goto error handling
8766 }
8767 a->CleanUp();
8768 b->CleanUp();
8769 //Print("op: %d,result typ:%d\n",op,res->rtyp);
8770 return FALSE;
8771 }
8772 i++;
8773 }
8774 // implicite type conversion ----------------------------------------------
8775 if (dA2[i].cmd!=op)
8776 {
8777 int ai,bi;
8780 BOOLEAN failed=FALSE;
8781 i=0; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
8782 //Print("op: %c, type: %s %s\n",op,Tok2Cmdname(at),Tok2Cmdname(bt));
8783 while (dA2[i].cmd==op)
8784 {
8785 //Print("test %s %s\n",Tok2Cmdname(dA2[i].arg1),Tok2Cmdname(dA2[i].arg2));
8786 if ((dA2[i].valid_for & NO_CONVERSION)==0)
8787 {
8788 if ((ai=iiTestConvert(at,dA2[i].arg1,dConvertTypes))!=0)
8789 {
8790 if ((bi=iiTestConvert(bt,dA2[i].arg2,dConvertTypes))!=0)
8791 {
8792 res->rtyp=dA2[i].res;
8793 if (currRing!=NULL)
8794 {
8795 if (check_valid(dA2[i].valid_for,op)) break;
8796 }
8797 else
8798 {
8799 if (RingDependend(dA2[i].res))
8800 {
8801 WerrorS("no ring active (4)");
8802 break;
8803 }
8804 }
8805 if (traceit&TRACE_CALL)
8806 Print("call %s(%s,%s)\n",iiTwoOps(op),
8807 Tok2Cmdname(dA2[i].arg1),Tok2Cmdname(dA2[i].arg2));
8808 failed= ((iiConvert(at,dA2[i].arg1,ai,a,an))
8809 || (iiConvert(bt,dA2[i].arg2,bi,b,bn))
8810 || (call_failed=dA2[i].p(res,an,bn)));
8811 // everything done, clean up temp. variables
8812 if (failed)
8813 {
8814 // leave loop, goto error handling
8815 break;
8816 }
8817 else
8818 {
8819 // everything ok, clean up and return
8820 an->CleanUp();
8821 bn->CleanUp();
8824 return FALSE;
8825 }
8826 }
8827 }
8828 }
8829 i++;
8830 }
8831 an->CleanUp();
8832 bn->CleanUp();
8835 }
8836 // error handling ---------------------------------------------------
8837 const char *s=NULL;
8838 if (!errorreported)
8839 {
8840 if ((at==0) && (a->Fullname()!=sNoName_fe))
8841 {
8842 s=a->Fullname();
8843 }
8844 else if ((bt==0) && (b->Fullname()!=sNoName_fe))
8845 {
8846 s=b->Fullname();
8847 }
8848 if (s!=NULL)
8849 Werror("`%s` is not defined",s);
8850 else
8851 {
8852 i=0; /*iiTabIndex(dArithTab2,JJTAB2LEN,op);*/
8853 s = iiTwoOps(op);
8854 if (proccall)
8855 {
8856 Werror("%s(`%s`,`%s`) failed"
8857 ,s,Tok2Cmdname(at),Tok2Cmdname(bt));
8858 }
8859 else
8860 {
8861 Werror("`%s` %s `%s` failed"
8862 ,Tok2Cmdname(at),s,Tok2Cmdname(bt));
8863 }
8864 if ((!call_failed) && BVERBOSE(V_SHOW_USE))
8865 {
8866 while (dA2[i].cmd==op)
8867 {
8868 if(((at==dA2[i].arg1)||(bt==dA2[i].arg2))
8869 && (dA2[i].res!=0)
8870 && (dA2[i].p!=jjWRONG2))
8871 {
8872 if (proccall)
8873 Werror("expected %s(`%s`,`%s`)"
8874 ,s,Tok2Cmdname(dA2[i].arg1),Tok2Cmdname(dA2[i].arg2));
8875 else
8876 Werror("expected `%s` %s `%s`"
8877 ,Tok2Cmdname(dA2[i].arg1),s,Tok2Cmdname(dA2[i].arg2));
8878 }
8879 i++;
8880 }
8881 }
8882 }
8883 }
8884 a->CleanUp();
8885 b->CleanUp();
8886 res->rtyp = UNKNOWN;
8887 }
8888 return TRUE;
8889}
#define jjWRONG2
Definition: iparith.cc:3678
short res
Definition: gentable.cc:73

◆ iiExprArith3()

BOOLEAN iiExprArith3 ( leftv  res,
int  op,
leftv  a,
leftv  b,
leftv  c 
)

Definition at line 9303 of file iparith.cc.

9304{
9305 res->Init();
9306
9307 if (!errorreported)
9308 {
9309#ifdef SIQ
9310 if (siq>0)
9311 {
9312 //Print("siq:%d\n",siq);
9314 memcpy(&d->arg1,a,sizeof(sleftv));
9315 a->Init();
9316 memcpy(&d->arg2,b,sizeof(sleftv));
9317 b->Init();
9318 memcpy(&d->arg3,c,sizeof(sleftv));
9319 c->Init();
9320 d->op=op;
9321 d->argc=3;
9322 res->data=(char *)d;
9323 res->rtyp=COMMAND;
9324 return FALSE;
9325 }
9326#endif
9327 int at=a->Typ();
9328 // handling bb-objects ----------------------------------------------
9329 if (at>MAX_TOK)
9330 {
9331 blackbox *bb=getBlackboxStuff(at);
9332 if (bb!=NULL)
9333 {
9334 if(!bb->blackbox_Op3(op,res,a,b,c)) return FALSE;
9335 // else: no op defined
9336 }
9337 else
9338 return TRUE;
9339 if (errorreported) return TRUE;
9340 }
9341 int bt=b->Typ();
9342 int ct=c->Typ();
9343
9344 iiOp=op;
9345 int i=0;
9346 while ((dArith3[i].cmd!=op)&&(dArith3[i].cmd!=0)) i++;
9347 return iiExprArith3TabIntern(res,op,a,b,c,dArith3+i,at,bt,ct,dConvertTypes);
9348 }
9349 a->CleanUp();
9350 b->CleanUp();
9351 c->CleanUp();
9352 //Print("op: %d,result typ:%d\n",op,res->rtyp);
9353 return TRUE;
9354}
static BOOLEAN iiExprArith3TabIntern(leftv res, int op, leftv a, leftv b, leftv c, const struct sValCmd3 *dA3, int at, int bt, int ct, const struct sConvertTypes *dConvertTypes)
Definition: iparith.cc:9150
const struct sValCmd3 dArith3[]
Definition: table.h:773

◆ iiExprArith3Tab()

BOOLEAN iiExprArith3Tab ( leftv  res,
leftv  a,
int  op,
const struct sValCmd3 dA3,
int  at,
const struct sConvertTypes dConvertTypes 
)

apply an operation 'op' to arguments a, a->next and a->next->next return TRUE on failure

Parameters
[out]respre-allocated result
[in]a3 arguments
[in]opoperation
[in]dA3table of possible proc assumes dA3[0].cmd==op
[in]ata->Typ()
[in]dConvertTypestable of type conversions

Definition at line 9355 of file iparith.cc.

9359{
9360 res->Init();
9361 leftv b=a->next;
9362 a->next=NULL;
9363 int bt=b->Typ();
9364 leftv c=b->next;
9365 b->next=NULL;
9366 int ct=c->Typ();
9367 BOOLEAN bo=iiExprArith3TabIntern(res,op,a,b,c,dA3,at,bt,ct,dConvertTypes);
9368 b->next=c;
9369 a->next=b;
9370 a->CleanUp(); // to cleanup the chain, content already done
9371 return bo;
9372}

◆ iiExprArith3TabIntern()

static BOOLEAN iiExprArith3TabIntern ( leftv  res,
int  op,
leftv  a,
leftv  b,
leftv  c,
const struct sValCmd3 dA3,
int  at,
int  bt,
int  ct,
const struct sConvertTypes dConvertTypes 
)
static

Definition at line 9150 of file iparith.cc.

9153{
9154 BOOLEAN call_failed=FALSE;
9155
9156 assume(dA3[0].cmd==op);
9157
9158 if (!errorreported)
9159 {
9160 int i=0;
9161 iiOp=op;
9162 while (dA3[i].cmd==op)
9163 {
9164 if ((at==dA3[i].arg1)
9165 && (bt==dA3[i].arg2)
9166 && (ct==dA3[i].arg3))
9167 {
9168 res->rtyp=dA3[i].res;
9169 if (currRing!=NULL)
9170 {
9171 if (check_valid(dA3[i].valid_for,op)) break;
9172 }
9173 if (traceit&TRACE_CALL)
9174 Print("call %s(%s,%s,%s)\n",
9176 if ((call_failed=dA3[i].p(res,a,b,c)))
9177 {
9178 break;// leave loop, goto error handling
9179 }
9180 a->CleanUp();
9181 b->CleanUp();
9182 c->CleanUp();
9183 return FALSE;
9184 }
9185 i++;
9186 }
9187 // implicite type conversion ----------------------------------------------
9188 if (dA3[i].cmd!=op)
9189 {
9190 int ai,bi,ci;
9194 BOOLEAN failed=FALSE;
9195 i=0;
9196 //while ((dA3[i].cmd!=op)&&(dA3[i].cmd!=0)) i++;
9197 while (dA3[i].cmd==op)
9198 {
9199 if ((dA3[i].valid_for & NO_CONVERSION)==0)
9200 {
9201 if ((ai=iiTestConvert(at,dA3[i].arg1,dConvertTypes))!=0)
9202 {
9203 if ((bi=iiTestConvert(bt,dA3[i].arg2,dConvertTypes))!=0)
9204 {
9205 if ((ci=iiTestConvert(ct,dA3[i].arg3,dConvertTypes))!=0)
9206 {
9207 res->rtyp=dA3[i].res;
9208 if (currRing!=NULL)
9209 {
9210 if (check_valid(dA3[i].valid_for,op)) break;
9211 }
9212 if (traceit&TRACE_CALL)
9213 Print("call %s(%s,%s,%s)\n",
9214 iiTwoOps(op),Tok2Cmdname(dA3[i].arg1),
9215 Tok2Cmdname(dA3[i].arg2),Tok2Cmdname(dA3[i].arg3));
9216 failed= ((iiConvert(at,dA3[i].arg1,ai,a,an,dConvertTypes))
9217 || (iiConvert(bt,dA3[i].arg2,bi,b,bn,dConvertTypes))
9218 || (iiConvert(ct,dA3[i].arg3,ci,c,cn,dConvertTypes))
9219 || (call_failed=dA3[i].p(res,an,bn,cn)));
9220 // everything done, clean up temp. variables
9221 if (failed)
9222 {
9223 // leave loop, goto error handling
9224 break;
9225 }
9226 else
9227 {
9228 // everything ok, clean up and return
9229 an->CleanUp();
9230 bn->CleanUp();
9231 cn->CleanUp();
9235 //Print("op: %d,result typ:%d\n",op,res->rtyp);
9236 return FALSE;
9237 }
9238 }
9239 }
9240 }
9241 }
9242 i++;
9243 }
9244 an->CleanUp();
9245 bn->CleanUp();
9246 cn->CleanUp();
9250 }
9251 // error handling ---------------------------------------------------
9252 if (!errorreported)
9253 {
9254 const char *s=NULL;
9255 if ((at==0) && (a->Fullname()!=sNoName_fe))
9256 {
9257 s=a->Fullname();
9258 }
9259 else if ((bt==0) && (b->Fullname()!=sNoName_fe))
9260 {
9261 s=b->Fullname();
9262 }
9263 else if ((ct==0) && (c->Fullname()!=sNoName_fe))
9264 {
9265 s=c->Fullname();
9266 }
9267 if (s!=NULL)
9268 Werror("`%s` is not defined",s);
9269 else
9270 {
9271 i=0;
9272 //while ((dA3[i].cmd!=op)&&(dA3[i].cmd!=0)) i++;
9273 const char *s = iiTwoOps(op);
9274 Werror("%s(`%s`,`%s`,`%s`) failed"
9275 ,s,Tok2Cmdname(at),Tok2Cmdname(bt),Tok2Cmdname(ct));
9276 if ((!call_failed) && BVERBOSE(V_SHOW_USE))
9277 {
9278 while (dA3[i].cmd==op)
9279 {
9280 if(((at==dA3[i].arg1)
9281 ||(bt==dA3[i].arg2)
9282 ||(ct==dA3[i].arg3))
9283 && (dA3[i].res!=0))
9284 {
9285 Werror("expected %s(`%s`,`%s`,`%s`)"
9286 ,s,Tok2Cmdname(dA3[i].arg1)
9287 ,Tok2Cmdname(dA3[i].arg2)
9288 ,Tok2Cmdname(dA3[i].arg3));
9289 }
9290 i++;
9291 }
9292 }
9293 }
9294 }
9295 res->rtyp = UNKNOWN;
9296 }
9297 a->CleanUp();
9298 b->CleanUp();
9299 c->CleanUp();
9300 //Print("op: %d,result typ:%d\n",op,res->rtyp);
9301 return TRUE;
9302}
short res
Definition: gentable.cc:90

◆ iiExprArithM()

BOOLEAN iiExprArithM ( leftv  res,
leftv  a,
int  op 
)

Definition at line 9394 of file iparith.cc.

9395{
9396 res->Init();
9397
9398 if (!errorreported)
9399 {
9400#ifdef SIQ
9401 if (siq>0)
9402 {
9403 //Print("siq:%d\n",siq);
9405 d->op=op;
9406 res->data=(char *)d;
9407 if (a!=NULL)
9408 {
9409 d->argc=a->listLength();
9410 // else : d->argc=0;
9411 memcpy(&d->arg1,a,sizeof(sleftv));
9412 switch(d->argc)
9413 {
9414 case 3:
9415 memcpy(&d->arg3,a->next->next,sizeof(sleftv));
9416 a->next->next->Init();
9417 /* no break */
9418 case 2:
9419 memcpy(&d->arg2,a->next,sizeof(sleftv));
9420 a->next->Init();
9421 a->next->next=d->arg2.next;
9422 d->arg2.next=NULL;
9423 /* no break */
9424 case 1:
9425 a->Init();
9426 a->next=d->arg1.next;
9427 d->arg1.next=NULL;
9428 }
9429 if (d->argc>3) a->next=NULL;
9430 a->name=NULL;
9431 a->rtyp=0;
9432 a->data=NULL;
9433 a->e=NULL;
9434 a->attribute=NULL;
9435 a->CleanUp();
9436 }
9437 res->rtyp=COMMAND;
9438 return FALSE;
9439 }
9440#endif
9441 if ((a!=NULL) && (a->Typ()>MAX_TOK))
9442 {
9443 blackbox *bb=getBlackboxStuff(a->Typ());
9444 if (bb!=NULL)
9445 {
9446 if(!bb->blackbox_OpM(op,res,a)) return FALSE;
9447 // else: no op defined
9448 }
9449 else
9450 return TRUE;
9451 if (errorreported) return TRUE;
9452 }
9453 int args=0;
9454 if (a!=NULL) args=a->listLength();
9455
9456 iiOp=op;
9457 int i=0;
9458 while ((dArithM[i].cmd!=op)&&(dArithM[i].cmd!=0)) i++;
9459 while (dArithM[i].cmd==op)
9460 {
9461 if ((args==dArithM[i].number_of_args)
9462 || (dArithM[i].number_of_args==-1)
9463 || ((dArithM[i].number_of_args==-2)&&(args>0)))
9464 {
9465 res->rtyp=dArithM[i].res;
9466 if (currRing!=NULL)
9467 {
9468 if (check_valid(dArithM[i].valid_for,op)) break;
9469 }
9470 if (traceit&TRACE_CALL)
9471 Print("call %s(... (%d args))\n", iiTwoOps(op),args);
9472 if (dArithM[i].p(res,a))
9473 {
9474 break;// leave loop, goto error handling
9475 }
9476 if (a!=NULL) a->CleanUp();
9477 //Print("op: %d,result typ:%d\n",op,res->rtyp);
9478 return FALSE;
9479 }
9480 i++;
9481 }
9482 // error handling
9483 if (!errorreported)
9484 {
9485 if ((args>0) && (a->rtyp==0) && (a->Name()!=sNoName_fe))
9486 {
9487 Werror("`%s` is not defined",a->Fullname());
9488 }
9489 else
9490 {
9491 const char *s = iiTwoOps(op);
9492 Werror("%s(...) failed",s);
9493 }
9494 }
9495 res->rtyp = UNKNOWN;
9496 }
9497 if (a!=NULL) a->CleanUp();
9498 //Print("op: %d,result typ:%d\n",op,res->rtyp);
9499 return TRUE;
9500}
const char * name
Definition: subexpr.h:87
int rtyp
Definition: subexpr.h:91
const char * Name()
Definition: subexpr.h:120
int listLength()
Definition: subexpr.cc:51
void * data
Definition: subexpr.h:88
Subexpr e
Definition: subexpr.h:105
attr attribute
Definition: subexpr.h:89
short res
Definition: gentable.cc:100
const struct sValCmdM dArithM[]
Definition: table.h:905

◆ iiInitArithmetic()

int iiInitArithmetic ( )

initialisation of arithmetic structured data

Return values
0on success

Definition at line 9718 of file iparith.cc.

9719{
9720 //printf("iiInitArithmetic()\n");
9721 memset(&sArithBase, 0, sizeof(sArithBase));
9722 iiInitCmdName();
9723 /* fix last-identifier */
9724#if 0
9725 /* we expect that gentable allready did every thing */
9728 if(sArithBase.sCmds[sArithBase.nLastIdentifier].tokval>=0) break;
9729 }
9730#endif
9731 //Print("L=%d\n", sArithBase.nLastIdentifier);
9732
9733 //iiArithAddCmd(szName, nAlias, nTokval, nToktype);
9734 //iiArithAddCmd("mygcd", 1, GCD_CMD, CMD_2);
9735
9736 //iiArithAddCmd("Top", 0,-1,0);
9737
9738
9739 //for(i=0; i<sArithBase.nCmdUsed; i++) {
9740 // printf("CMD[%03d] %s, %d, %d, %d\n", i,
9741 // sArithBase.sCmds[i].name,
9742 // sArithBase.sCmds[i].alias,
9743 // sArithBase.sCmds[i].tokval,
9744 // sArithBase.sCmds[i].toktype);
9745 //}
9746 //iiArithRemoveCmd("Top");
9747 //iiArithAddCmd("mygcd", 2, GCD_CMD, CMD_2);
9748 //iiArithRemoveCmd("mygcd");
9749 //iiArithAddCmd("kkk", 1, 1234, CMD_1);
9750 return 0;
9751}

◆ iin_Int()

static int iin_Int ( number &  n,
coeffs  cf 
)
static

Definition at line 225 of file iparith.cc.

226{
227 long l=n_Int(n,cf);
228 int i=(int)l;
229 if ((long)i==l) return l;
230 return 0;
231}
int l
Definition: cfEzgcd.cc:100
CanonicalForm cf
Definition: cfModGcd.cc:4083
static FORCE_INLINE long n_Int(number &n, const coeffs r)
conversion of n to an int; 0 if not possible in Z/pZ: the representing int lying in (-p/2 ....
Definition: coeffs.h:547

◆ iiTabIndex()

static int iiTabIndex ( const jjValCmdTab  dArithTab,
const int  len,
const int  op 
)
static

Definition at line 9602 of file iparith.cc.

9603{
9604 // user defined types are not in the pre-computed table:
9605 if (op>MAX_TOK) return 0;
9606
9607 int a=0;
9608 int e=len;
9609 int p=len/2;
9610 do
9611 {
9612 if (op==dArithTab[p].cmd) return dArithTab[p].start;
9613 if (op<dArithTab[p].cmd) e=p-1;
9614 else a = p+1;
9615 p=a+(e-a)/2;
9616 }
9617 while ( a <= e);
9618
9619 // catch missing a cmd:
9620 // may be missing as a op for blackbox, if the first operand is "undef" instead of bb
9621 // Print("op %d (%c) unknown",op,op);
9622 return 0;
9623}

◆ iiTokType()

int iiTokType ( int  op)

Definition at line 237 of file iparith.cc.

238{
239 for (unsigned i=0;i<sArithBase.nCmdUsed;i++)
240 {
241 if (sArithBase.sCmds[i].tokval==op)
242 return sArithBase.sCmds[i].toktype;
243 }
244 return 0;
245}

◆ IsCmd()

int IsCmd ( const char *  n,
int &  tok 
)

Definition at line 9503 of file iparith.cc.

9504{
9505 int i;
9506 int an=1;
9508
9509 loop
9510 //for(an=0; an<sArithBase.nCmdUsed; )
9511 {
9512 if(an>=en-1)
9513 {
9514 if (strcmp(n, sArithBase.sCmds[an].name) == 0)
9515 {
9516 i=an;
9517 break;
9518 }
9519 else if ((an!=en) && (strcmp(n, sArithBase.sCmds[en].name) == 0))
9520 {
9521 i=en;
9522 break;
9523 }
9524 else
9525 {
9526 // -- blackbox extensions:
9527 // return 0;
9528 return blackboxIsCmd(n,tok);
9529 }
9530 }
9531 i=(an+en)/2;
9532 if (*n < *(sArithBase.sCmds[i].name))
9533 {
9534 en=i-1;
9535 }
9536 else if (*n > *(sArithBase.sCmds[i].name))
9537 {
9538 an=i+1;
9539 }
9540 else
9541 {
9542 int v=strcmp(n,sArithBase.sCmds[i].name);
9543 if(v<0)
9544 {
9545 en=i-1;
9546 }
9547 else if(v>0)
9548 {
9549 an=i+1;
9550 }
9551 else /*v==0*/
9552 {
9553 break;
9554 }
9555 }
9556 }
9558 tok=sArithBase.sCmds[i].tokval;
9559 if(sArithBase.sCmds[i].alias==2)
9560 {
9561 Warn("outdated identifier `%s` used - please change your code",
9562 sArithBase.sCmds[i].name);
9563 sArithBase.sCmds[i].alias=1;
9564 }
9565 #if 0
9566 if (currRingHdl==NULL)
9567 {
9568 #ifdef SIQ
9569 if (siq<=0)
9570 {
9571 #endif
9572 if ((tok>=BEGIN_RING) && (tok<=END_RING))
9573 {
9574 WerrorS("no ring active");
9575 return 0;
9576 }
9577 #ifdef SIQ
9578 }
9579 #endif
9580 }
9581 #endif
9582 if (!expected_parms)
9583 {
9584 switch (tok)
9585 {
9586 case IDEAL_CMD:
9587 case INT_CMD:
9588 case INTVEC_CMD:
9589 case MAP_CMD:
9590 case MATRIX_CMD:
9591 case MODUL_CMD:
9592 case POLY_CMD:
9593 case PROC_CMD:
9594 case RING_CMD:
9595 case STRING_CMD:
9596 cmdtok = tok;
9597 break;
9598 }
9599 }
9600 return sArithBase.sCmds[i].toktype;
9601}
int blackboxIsCmd(const char *n, int &tok)
used by scanner: returns ROOT_DECL for known types (and the type number in tok)
Definition: blackbox.cc:218
@ END_RING
Definition: grammar.cc:310
@ IDEAL_CMD
Definition: grammar.cc:284
@ MATRIX_CMD
Definition: grammar.cc:286
@ MAP_CMD
Definition: grammar.cc:285
@ PROC_CMD
Definition: grammar.cc:280
@ BEGIN_RING
Definition: grammar.cc:282
@ MODUL_CMD
Definition: grammar.cc:287
@ POLY_CMD
Definition: grammar.cc:289
@ RING_CMD
Definition: grammar.cc:281
EXTERN_VAR BOOLEAN expected_parms
Definition: iparith.cc:218
EXTERN_VAR int cmdtok
Definition: iparith.cc:217
VAR idhdl currRingHdl
Definition: ipid.cc:59
const char * lastreserved
Definition: ipshell.cc:82
@ INTVEC_CMD
Definition: tok.h:101
@ STRING_CMD
Definition: tok.h:185
@ INT_CMD
Definition: tok.h:96

◆ jjALIGN_M()

static BOOLEAN jjALIGN_M ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1783 of file iparith.cc.

1784{
1785 ideal M=(ideal)u->CopyD();
1786 int s=(int)(long)v->Data();
1787 for(int i=IDELEMS(M)-1; i>=0;i--)
1788 {
1789 if (s+p_MinComp(M->m[i],currRing)<=0)
1790 { id_Delete(&M,currRing);return TRUE;}
1791 }
1793 res->data=M;
1794 return FALSE;
1795}
void * CopyD(int t)
Definition: subexpr.cc:710
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:315
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
void id_Shift(ideal M, int s, const ring r)
#define IDELEMS(i)
Definition: simpleideals.h:23
#define M
Definition: sirandom.c:25

◆ jjALIGN_V()

static BOOLEAN jjALIGN_V ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1773 of file iparith.cc.

1774{
1775 poly p=(poly)u->CopyD();
1776 int s=(int)(long)v->Data();
1777 if (s+p_MinComp(p,currRing)<=0)
1778 { p_Delete(&p,currRing);return TRUE;}
1779 p_Shift(&p,s,currRing);
1780 res->data=p;
1781 return FALSE;
1782}
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
Definition: p_polys.cc:4822
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:903

◆ jjAND_I()

static BOOLEAN jjAND_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1384 of file iparith.cc.

1385{
1386 res->data = (char *)((long)u->Data() && (long)v->Data());
1387 return FALSE;
1388}
void * Data()
Definition: subexpr.cc:1154

◆ jjBAREISS()

static BOOLEAN jjBAREISS ( leftv  res,
leftv  v 
)
static

Definition at line 3791 of file iparith.cc.

3792{
3793 //matrix m=(matrix)v->Data();
3794 //lists l=mpBareiss(m,FALSE);
3795 intvec *iv;
3796 ideal m;
3797 sm_CallBareiss((ideal)v->Data(),0,0,m,&iv, currRing);
3799 l->Init(2);
3800 l->m[0].rtyp=MODUL_CMD;
3801 l->m[1].rtyp=INTVEC_CMD;
3802 l->m[0].data=(void *)m;
3803 l->m[1].data=(void *)iv;
3804 res->data = (char *)l;
3805 return FALSE;
3806}
int m
Definition: cfEzgcd.cc:128
Definition: intvec.h:23
Definition: lists.h:24
VAR omBin slists_bin
Definition: lists.cc:23
slists * lists
Definition: mpr_numeric.h:146
void sm_CallBareiss(ideal I, int x, int y, ideal &M, intvec **iv, const ring R)
Definition: sparsmat.cc:347

◆ jjBAREISS3()

static BOOLEAN jjBAREISS3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5996 of file iparith.cc.

5997{
5998 intvec *iv;
5999 ideal m;
6001 int k=(int)(long)w->Data();
6002 if (k>=0)
6003 {
6004 sm_CallBareiss((ideal)u->Data(),(int)(long)v->Data(),(int)(long)w->Data(),m,&iv, currRing);
6005 l->Init(2);
6006 l->m[0].rtyp=MODUL_CMD;
6007 l->m[1].rtyp=INTVEC_CMD;
6008 l->m[0].data=(void *)m;
6009 l->m[1].data=(void *)iv;
6010 }
6011 else
6012 {
6013 m=sm_CallSolv((ideal)u->Data(), currRing);
6014 l->Init(1);
6015 l->m[0].rtyp=IDEAL_CMD;
6016 l->m[0].data=(void *)m;
6017 }
6018 res->data = (char *)l;
6019 return FALSE;
6020}
int k
Definition: cfEzgcd.cc:99
const CanonicalForm & w
Definition: facAbsFact.cc:51
ideal sm_CallSolv(ideal I, const ring R)
Definition: sparsmat.cc:2316

◆ jjBAREISS_BIM()

static BOOLEAN jjBAREISS_BIM ( leftv  res,
leftv  v 
)
static

Definition at line 3814 of file iparith.cc.

3815{
3816 bigintmat *b=(bigintmat*)v->CopyD(BIGINTMAT_CMD);
3817 b->hnf();
3818 res->data=(char*)b;
3819 return FALSE;
3820}
Matrices of numbers.
Definition: bigintmat.h:51
@ BIGINTMAT_CMD
Definition: grammar.cc:278

◆ jjBI2IM()

static BOOLEAN jjBI2IM ( leftv  res,
leftv  u 
)
static

Definition at line 3836 of file iparith.cc.

3837{
3838 bigintmat *b=(bigintmat*)u->Data();
3839 res->data=(void *)bim2iv(b);
3840 return FALSE;
3841}
intvec * bim2iv(bigintmat *b)
Definition: bigintmat.cc:341

◆ jjBI2N()

static BOOLEAN jjBI2N ( leftv  res,
leftv  u 
)
static

Definition at line 3821 of file iparith.cc.

3822{
3823 BOOLEAN bo=FALSE;
3824 number n=(number)u->CopyD();
3826 if (nMap!=NULL)
3827 res->data=nMap(n,coeffs_BIGINT,currRing->cf);
3828 else
3829 {
3830 Werror("cannot convert bigint to cring %s", nCoeffName(currRing->cf));
3831 bo=TRUE;
3832 }
3834 return bo;
3835}
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
Definition: coeffs.h:700
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:455
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition: coeffs.h:963
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
Definition: coeffs.h:73
VAR coeffs coeffs_BIGINT
Definition: ipid.cc:50

◆ jjBI2P()

static BOOLEAN jjBI2P ( leftv  res,
leftv  u 
)
static

Definition at line 3842 of file iparith.cc.

3843{
3844 sleftv tmp;
3845 BOOLEAN bo=jjBI2N(&tmp,u);
3846 if (!bo)
3847 {
3848 number n=(number) tmp.data;
3849 if (nIsZero(n)) { res->data=NULL;nDelete(&n); }
3850 else
3851 {
3852 res->data=(void *)pNSet(n);
3853 }
3854 }
3855 return bo;
3856}
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)
static BOOLEAN jjBI2N(leftv res, leftv u)
Definition: iparith.cc:3821
#define nDelete(n)
Definition: numbers.h:16
#define nIsZero(n)
Definition: numbers.h:19
#define pNSet(n)
Definition: polys.h:313

◆ jjBRACK_Bim()

static BOOLEAN jjBRACK_Bim ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5741 of file iparith.cc.

5742{
5743 bigintmat *bim = (bigintmat *)u->Data();
5744 int r = (int)(long)v->Data();
5745 int c = (int)(long)w->Data();
5746 if ((r<1)||(r>bim->rows())||(c<1)||(c>bim->cols()))
5747 {
5748 Werror("wrong range[%d,%d] in bigintmat %s(%d x %d)",
5749 r,c,u->Fullname(),bim->rows(),bim->cols());
5750 return TRUE;
5751 }
5752 res->data=u->data; u->data=NULL;
5753 res->rtyp=u->rtyp; u->rtyp=0;
5754 res->name=u->name; u->name=NULL;
5755 Subexpr e=jjMakeSub(v);
5756 e->next=jjMakeSub(w);
5757 if (u->e==NULL)
5758 res->e=e;
5759 else
5760 {
5761 Subexpr h=u->e;
5762 while (h->next!=NULL) h=h->next;
5763 h->next=e;
5764 res->e=u->e;
5765 u->e=NULL;
5766 }
5767 return FALSE;
5768}
int cols() const
Definition: bigintmat.h:144
int rows() const
Definition: bigintmat.h:145
static Subexpr jjMakeSub(leftv e)
Definition: iparith.cc:8698
STATIC_VAR Poly * h
Definition: janet.cc:971

◆ jjBRACK_Im()

static BOOLEAN jjBRACK_Im ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5714 of file iparith.cc.

5715{
5716 intvec *iv = (intvec *)u->Data();
5717 int r = (int)(long)v->Data();
5718 int c = (int)(long)w->Data();
5719 if ((r<1)||(r>iv->rows())||(c<1)||(c>iv->cols()))
5720 {
5721 Werror("wrong range[%d,%d] in intmat %s(%d x %d)",
5722 r,c,u->Fullname(),iv->rows(),iv->cols());
5723 return TRUE;
5724 }
5725 res->data=u->data; u->data=NULL;
5726 res->rtyp=u->rtyp; u->rtyp=0;
5727 res->name=u->name; u->name=NULL;
5728 Subexpr e=jjMakeSub(v);
5729 e->next=jjMakeSub(w);
5730 if (u->e==NULL) res->e=e;
5731 else
5732 {
5733 Subexpr h=u->e;
5734 while (h->next!=NULL) h=h->next;
5735 h->next=e;
5736 res->e=u->e;
5737 u->e=NULL;
5738 }
5739 return FALSE;
5740}
int cols() const
Definition: intvec.h:95
int rows() const
Definition: intvec.h:96

◆ jjBRACK_Ma()

static BOOLEAN jjBRACK_Ma ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5769 of file iparith.cc.

5770{
5771 matrix m= (matrix)u->Data();
5772 int r = (int)(long)v->Data();
5773 int c = (int)(long)w->Data();
5774 //Print("gen. elem %d, %d\n",r,c);
5775 if ((r<1)||(r>MATROWS(m))||(c<1)||(c>MATCOLS(m)))
5776 {
5777 Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
5778 MATROWS(m),MATCOLS(m));
5779 return TRUE;
5780 }
5781 res->data=u->data; u->data=NULL;
5782 res->rtyp=u->rtyp; u->rtyp=0;
5783 res->name=u->name; u->name=NULL;
5784 Subexpr e=jjMakeSub(v);
5785 e->next=jjMakeSub(w);
5786 if (u->e==NULL)
5787 res->e=e;
5788 else
5789 {
5790 Subexpr h=u->e;
5791 while (h->next!=NULL) h=h->next;
5792 h->next=e;
5793 res->e=u->e;
5794 u->e=NULL;
5795 }
5796 return FALSE;
5797}
ip_smatrix * matrix
Definition: matpol.h:43
#define MATROWS(i)
Definition: matpol.h:26
#define MATCOLS(i)
Definition: matpol.h:27

◆ jjBRACK_Ma_I_IV()

static BOOLEAN jjBRACK_Ma_I_IV ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5827 of file iparith.cc.

5828{
5829 if ((u->rtyp!=IDHDL)||(u->e!=NULL))
5830 {
5831 WerrorS("cannot build expression lists from unnamed objects");
5832 return TRUE;
5833 }
5834
5835 leftv p=NULL;
5836 intvec *iv=(intvec *)w->Data();
5837 int l;
5838 BOOLEAN nok;
5839 sleftv ut;
5840 memcpy(&ut,u,sizeof(ut));
5841 sleftv t;
5842 t.Init();
5843 t.rtyp=INT_CMD;
5844 for (l=0;l< iv->length(); l++)
5845 {
5846 t.data=(char *)(long)((*iv)[l]);
5847 if (p==NULL)
5848 {
5849 p=res;
5850 }
5851 else
5852 {
5853 p->next=(leftv)omAlloc0Bin(sleftv_bin);
5854 p=p->next;
5855 }
5856 memcpy(u,&ut,sizeof(ut));
5857 if (u->Typ() == MATRIX_CMD)
5858 nok=jjBRACK_Ma(p,u,v,&t);
5859 else if (u->Typ() == BIGINTMAT_CMD)
5860 nok=jjBRACK_Bim(p,u,v,&t);
5861 else /* INTMAT_CMD */
5862 nok=jjBRACK_Im(p,u,v,&t);
5863 if (nok)
5864 {
5865 while (res->next!=NULL)
5866 {
5867 p=res->next->next;
5869 // res->e aufraeumen !!!!
5870 res->next=p;
5871 }
5872 return TRUE;
5873 }
5874 }
5875 return FALSE;
5876}
int length() const
Definition: intvec.h:94
static BOOLEAN jjBRACK_Bim(leftv res, leftv u, leftv v, leftv w)
Definition: iparith.cc:5741
static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v, leftv w)
Definition: iparith.cc:5714
static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v, leftv w)
Definition: iparith.cc:5769
#define IDHDL
Definition: tok.h:31

◆ jjBRACK_Ma_IV_I()

static BOOLEAN jjBRACK_Ma_IV_I ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5877 of file iparith.cc.

5878{
5879 if ((u->rtyp!=IDHDL)||(u->e!=NULL))
5880 {
5881 WerrorS("cannot build expression lists from unnamed objects");
5882 return TRUE;
5883 }
5884 leftv p=NULL;
5885 intvec *iv=(intvec *)v->Data();
5886 int l;
5887 BOOLEAN nok;
5888 sleftv ut;
5889 memcpy(&ut,u,sizeof(ut));
5890 sleftv t;
5891 t.Init();
5892 t.rtyp=INT_CMD;
5893 for (l=0;l< iv->length(); l++)
5894 {
5895 t.data=(char *)(long)((*iv)[l]);
5896 if (p==NULL)
5897 {
5898 p=res;
5899 }
5900 else
5901 {
5902 p->next=(leftv)omAlloc0Bin(sleftv_bin);
5903 p=p->next;
5904 }
5905 memcpy(u,&ut,sizeof(ut));
5906 if (u->Typ() == MATRIX_CMD)
5907 nok=jjBRACK_Ma(p,u,&t,w);
5908 else if (u->Typ() == BIGINTMAT_CMD)
5909 nok=jjBRACK_Bim(p,u,&t,w);
5910 else /* INTMAT_CMD */
5911 nok=jjBRACK_Im(p,u,&t,w);
5912 if (nok)
5913 {
5914 while (res->next!=NULL)
5915 {
5916 p=res->next->next;
5918 // res->e aufraeumen !!
5919 res->next=p;
5920 }
5921 return TRUE;
5922 }
5923 }
5924 return FALSE;
5925}

◆ jjBRACK_Ma_IV_IV()

static BOOLEAN jjBRACK_Ma_IV_IV ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5926 of file iparith.cc.

5927{
5928 if ((u->rtyp!=IDHDL)||(u->e!=NULL))
5929 {
5930 WerrorS("cannot build expression lists from unnamed objects");
5931 return TRUE;
5932 }
5933 leftv p=NULL;
5934 intvec *vv=(intvec *)v->Data();
5935 intvec *wv=(intvec *)w->Data();
5936 int vl;
5937 int wl;
5938 BOOLEAN nok;
5939
5940 sleftv t1,t2,ut;
5941 memcpy(&ut,u,sizeof(ut));
5942 t1.Init();
5943 t1.rtyp=INT_CMD;
5944 t2.Init();
5945 t2.rtyp=INT_CMD;
5946 for (vl=0;vl< vv->length(); vl++)
5947 {
5948 t1.data=(char *)(long)((*vv)[vl]);
5949 for (wl=0;wl< wv->length(); wl++)
5950 {
5951 t2.data=(char *)(long)((*wv)[wl]);
5952 if (p==NULL)
5953 {
5954 p=res;
5955 }
5956 else
5957 {
5958 p->next=(leftv)omAlloc0Bin(sleftv_bin);
5959 p=p->next;
5960 }
5961 memcpy(u,&ut,sizeof(ut));
5962 if (u->Typ() == MATRIX_CMD)
5963 nok=jjBRACK_Ma(p,u,&t1,&t2);
5964 else if (u->Typ() == BIGINTMAT_CMD)
5965 nok=jjBRACK_Bim(p,u,&t1,&t2);
5966 else /* INTMAT_CMD */
5967 nok=jjBRACK_Im(p,u,&t1,&t2);
5968 if (nok)
5969 {
5970 res->CleanUp();
5971 return TRUE;
5972 }
5973 }
5974 }
5975 return FALSE;
5976}

◆ jjBRACK_S()

static BOOLEAN jjBRACK_S ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5698 of file iparith.cc.

5699{
5700 char *s= (char *)u->Data();
5701 int r = (int)(long)v->Data();
5702 int c = (int)(long)w->Data();
5703 int l = strlen(s);
5704
5705 if ( (r<1) || (r>l) || (c<0) )
5706 {
5707 Werror("wrong range[%d,%d] in string %s",r,c,u->Fullname());
5708 return TRUE;
5709 }
5710 res->data = (char *)omAlloc((long)(c+1));
5711 sprintf((char *)res->data,"%-*.*s",c,c,s+r-1);
5712 return FALSE;
5713}
#define omAlloc(size)
Definition: omAllocDecl.h:210

◆ jjBRACK_SM()

static BOOLEAN jjBRACK_SM ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5798 of file iparith.cc.

5799{
5800 ideal m= (ideal)u->Data();
5801 int r = (int)(long)v->Data();
5802 int c = (int)(long)w->Data();
5803 //Print("gen. elem %d, %d\n",r,c);
5804 if ((r<1)||(r>m->rank)||(c<1)||(c>IDELEMS(m)))
5805 {
5806 Werror("wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->Fullname(),
5807 (int)m->rank,IDELEMS(m));
5808 return TRUE;
5809 }
5810 res->data=u->data; u->data=NULL;
5811 res->rtyp=u->rtyp; u->rtyp=0;
5812 res->name=u->name; u->name=NULL;
5813 Subexpr e=jjMakeSub(v);
5814 e->next=jjMakeSub(w);
5815 if (u->e==NULL)
5816 res->e=e;
5817 else
5818 {
5819 Subexpr h=u->e;
5820 while (h->next!=NULL) h=h->next;
5821 h->next=e;
5822 res->e=u->e;
5823 u->e=NULL;
5824 }
5825 return FALSE;
5826}

◆ jjBRACKET()

static BOOLEAN jjBRACKET ( leftv  res,
leftv  a,
leftv  b 
)
static

Definition at line 2892 of file iparith.cc.

2893{
2894 res->data=NULL;
2895
2897 {
2898 const poly q = (poly)b->Data();
2899
2900 if( q != NULL )
2901 {
2902 if( (poly)a->Data() != NULL )
2903 {
2905 {
2906 poly p = (poly)a->CopyD(POLY_CMD); // p = copy!
2907 res->data = nc_p_Bracket_qq(p,q, currRing); // p will be destroyed!
2908 }
2909 else if (rIsLPRing(currRing))
2910 {
2911 const poly p = (poly)a->Data();
2912 res->data = pAdd(ppMult_qq(p,q), pNeg(ppMult_qq(q,p)));
2913 }
2914 }
2915 }
2916 }
2917 return FALSE;
2918}
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
Definition: old.gring.cc:2243
#define pAdd(p, q)
Definition: polys.h:203
#define pNeg(p)
Definition: polys.h:198
#define ppMult_qq(p, q)
Definition: polys.h:208

◆ jjBRACKET_REC()

static BOOLEAN jjBRACKET_REC ( leftv  res,
leftv  a,
leftv  b,
leftv  c 
)
static

Definition at line 2919 of file iparith.cc.

2920{
2921 res->data=NULL;
2922
2924 {
2925 const poly q = (poly)b->Data();
2926 if(q != NULL)
2927 {
2928 if((poly)a->Data() != NULL)
2929 {
2930 const poly p = (poly)a->Data();
2931 int k=(int)(long)c->Data();
2932 if (k > 0)
2933 {
2934 poly qq = pCopy(q);
2935 for (int i = 0; i < k; i++)
2936 {
2937 poly qq_ref = qq;
2938 if (rIsLPRing(currRing))
2939 {
2940 qq = pAdd(ppMult_qq(p,qq), pNeg(ppMult_qq(qq,p)));
2941 }
2942 else if (rIsPluralRing(currRing))
2943 {
2944 qq = nc_p_Bracket_qq(pCopy(p), qq, currRing);
2945 }
2946 pDelete(&qq_ref);
2947 if (qq == NULL) break;
2948 }
2949 res->data = qq;
2950 }
2951 else
2952 {
2953 Werror("invalid number of iterations");
2954 }
2955 }
2956 }
2957 }
2958 return FALSE;
2959}
#define pDelete(p_ptr)
Definition: polys.h:186
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185

◆ jjBREAK0()

static BOOLEAN jjBREAK0 ( leftv  ,
leftv   
)
static

Definition at line 7120 of file iparith.cc.

7121{
7122#ifdef HAVE_SDB
7123 sdb_show_bp();
7124#endif
7125 return FALSE;
7126}
void sdb_show_bp()
Definition: sdb.cc:57

◆ jjBREAK1()

static BOOLEAN jjBREAK1 ( leftv  ,
leftv  v 
)
static

Definition at line 7127 of file iparith.cc.

7128{
7129#ifdef HAVE_SDB
7130 if(v->Typ()==PROC_CMD)
7131 {
7132 int lineno=0;
7133 if((v->next!=NULL) && (v->next->Typ()==INT_CMD))
7134 {
7135 lineno=(int)(long)v->next->Data();
7136 }
7137 return sdb_set_breakpoint(v->Name(),lineno);
7138 }
7139 return TRUE;
7140#else
7141 return FALSE;
7142#endif
7143}
Variable next() const
Definition: factory.h:146
BOOLEAN sdb_set_breakpoint(const char *pp, int given_lineno)
Definition: sdb.cc:64

◆ jjCALL1ARG()

static BOOLEAN jjCALL1ARG ( leftv  res,
leftv  v 
)
static

Definition at line 7144 of file iparith.cc.

7145{
7146 return iiExprArith1(res,v,iiOp);
7147}

◆ jjCALL1MANY()

static BOOLEAN jjCALL1MANY ( leftv  res,
leftv  u 
)
static

Definition at line 3857 of file iparith.cc.

3858{
3859 return iiExprArithM(res,u,iiOp);
3860}
BOOLEAN iiExprArithM(leftv res, leftv a, int op)
Definition: iparith.cc:9394

◆ jjCALL2ARG()

static BOOLEAN jjCALL2ARG ( leftv  res,
leftv  u 
)
static

Definition at line 7148 of file iparith.cc.

7149{
7150 leftv v=u->next;
7151 u->next=NULL;
7152 BOOLEAN b=iiExprArith2(res,u,iiOp,v, (iiOp > 255));
7153 u->next=v;
7154 return b;
7155}
BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
Definition: iparith.cc:8904

◆ jjCALL3ARG()

static BOOLEAN jjCALL3ARG ( leftv  res,
leftv  u 
)
static

Definition at line 7156 of file iparith.cc.

7157{
7158 leftv v = u->next;
7159 leftv w = v->next;
7160 u->next = NULL;
7161 v->next = NULL;
7162 BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
7163 u->next = v;
7164 v->next = w;
7165 return b;
7166}
BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
Definition: iparith.cc:9303

◆ jjCHAR()

static BOOLEAN jjCHAR ( leftv  res,
leftv  v 
)
static

Definition at line 3861 of file iparith.cc.

3862{
3863 res->data = (char *)(long)rChar((ring)v->Data());
3864 return FALSE;
3865}
int rChar(ring r)
Definition: ring.cc:713

◆ jjCHINREM_BI()

static BOOLEAN jjCHINREM_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1686 of file iparith.cc.

1687{
1688 intvec *c=(intvec*)u->Data();
1689 intvec* p=(intvec*)v->Data();
1690 int rl=p->length();
1691 number *x=(number *)omAlloc(rl*sizeof(number));
1692 number *q=(number *)omAlloc(rl*sizeof(number));
1693 int i;
1694 for(i=rl-1;i>=0;i--)
1695 {
1696 q[i]=n_Init((*p)[i], coeffs_BIGINT);
1697 x[i]=n_Init((*c)[i], coeffs_BIGINT);
1698 }
1699 CFArray iv(rl);
1700 number n=n_ChineseRemainderSym(x,q,rl,FALSE,iv,coeffs_BIGINT);
1701 for(i=rl-1;i>=0;i--)
1702 {
1703 n_Delete(&(q[i]),coeffs_BIGINT);
1705 }
1706 omFree(x); omFree(q);
1707 res->data=(char *)n;
1708 return FALSE;
1709}
Variable x
Definition: cfModGcd.cc:4082
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
Definition: coeffs.h:764
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:538
#define omFree(addr)
Definition: omAllocDecl.h:261

◆ jjCHINREM_ID()

static BOOLEAN jjCHINREM_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 9954 of file iparith.cc.

9955{
9956 if ((currRing!=NULL)
9958 && (!rField_is_Z(currRing)))
9959 {
9960 WerrorS("not implemented for rings with rings as coeffients (except ZZ)");
9961 return TRUE;
9962 }
9963 coeffs cf;
9964 lists c=(lists)u->CopyD(); // list of ideal or bigint/int
9965 int rl=c->nr+1;
9966 int return_type=c->m[0].Typ();
9967 if ((return_type!=IDEAL_CMD)
9968 && (return_type!=MODUL_CMD)
9969 && (return_type!=SMATRIX_CMD)
9970 && (return_type!=MATRIX_CMD)
9971 && (return_type!=POLY_CMD))
9972 {
9973 if((return_type==BIGINT_CMD)
9974 ||(return_type==INT_CMD))
9975 return_type=BIGINT_CMD;
9976 else if (return_type==LIST_CMD)
9977 {
9978 // create a tmp list of the correct size
9980 res_l->Init(rl /*c->nr+1*/);
9981 BOOLEAN bo=FALSE;
9982 int tab_pos=iiTabIndex(dArithTab2,JJTAB2LEN,CHINREM_CMD);
9983 for (unsigned i=0;i<=(unsigned)c->nr;i++)
9984 {
9985 sleftv tmp;
9986 tmp.Copy(v);
9987 bo=iiExprArith2TabIntern(&res_l->m[i],&c->m[i],CHINREM_CMD,&tmp,TRUE,dArith2+tab_pos,c->m[i].rtyp,tmp.rtyp,dConvertTypes);
9988 if (bo) { Werror("chinrem failed for list entry %d",i+1); break;}
9989 }
9990 c->Clean();
9991 res->data=res_l;
9992 res->rtyp=LIST_CMD;
9993 return bo;
9994 }
9995 else
9996 {
9997 c->Clean();
9998 WerrorS("poly/ideal/module/matrix/list expected");
9999 return TRUE;
10000 }
10001 }
10002 if (return_type==BIGINT_CMD)
10004 else
10005 {
10006 cf=currRing->cf;
10007 if (nCoeff_is_Extension(cf) && (cf->extRing!=NULL))
10008 cf=cf->extRing->cf;
10009 }
10010 lists pl=NULL;
10011 intvec *p=NULL;
10012 if (v->Typ()==LIST_CMD)
10013 {
10014 pl=(lists)v->Data();
10015 if (pl->nr!=rl-1)
10016 {
10017 WerrorS("wromg number of primes");
10018 return TRUE;
10019 }
10020 }
10021 else
10022 {
10023 p=(intvec*)v->Data();
10024 if (p->length()!=rl)
10025 {
10026 WerrorS("wromg number of primes");
10027 return TRUE;
10028 }
10029 }
10030 ideal result;
10031 ideal *x=(ideal *)omAlloc(rl*sizeof(ideal));
10032 number *xx=NULL;
10034 int i;
10035 if (return_type!=BIGINT_CMD)
10036 {
10037 for(i=rl-1;i>=0;i--)
10038 {
10039 if (c->m[i].Typ()!=return_type)
10040 {
10041 Werror("%s expected at pos %d",Tok2Cmdname(return_type),i+1);
10042 omFree(x); // delete c
10043 return TRUE;
10044 }
10045 if (return_type==POLY_CMD)
10046 {
10047 x[i]=idInit(1,1);
10048 x[i]->m[0]=(poly)c->m[i].CopyD();
10049 }
10050 else
10051 {
10052 x[i]=(ideal)c->m[i].CopyD();
10053 }
10054 //c->m[i].Init();
10055 }
10056 }
10057 else
10058 {
10059 if (nMap==NULL)
10060 {
10061 Werror("not implemented: map bigint -> %s", nCoeffName(cf));
10062 return TRUE;
10063 }
10064 xx=(number *)omAlloc(rl*sizeof(number));
10065 for(i=rl-1;i>=0;i--)
10066 {
10067 if (c->m[i].Typ()==INT_CMD)
10068 {
10069 xx[i]=n_Init(((int)(long)c->m[i].Data()),cf);
10070 }
10071 else if (c->m[i].Typ()==BIGINT_CMD)
10072 {
10073 xx[i]=nMap((number)c->m[i].Data(),coeffs_BIGINT,cf);
10074 }
10075 else
10076 {
10077 Werror("bigint expected at pos %d",i+1);
10078 omFree(x); // delete c
10079 omFree(xx); // delete c
10080 return TRUE;
10081 }
10082 }
10083 }
10084 number *q=(number *)omAlloc(rl*sizeof(number));
10085 if (p!=NULL)
10086 {
10087 for(i=rl-1;i>=0;i--)
10088 {
10089 q[i]=n_Init((*p)[i], cf);
10090 }
10091 }
10092 else
10093 {
10094 for(i=rl-1;i>=0;i--)
10095 {
10096 if (pl->m[i].Typ()==INT_CMD)
10097 {
10098 q[i]=n_Init((int)(long)pl->m[i].Data(),cf);
10099 }
10100 else if (pl->m[i].Typ()==BIGINT_CMD)
10101 {
10102 q[i]=nMap((number)(pl->m[i].Data()),coeffs_BIGINT,cf);
10103 }
10104 else
10105 {
10106 Werror("bigint expected at pos %d",i+1);
10107 for(i++;i<rl;i++)
10108 {
10109 n_Delete(&(q[i]),cf);
10110 }
10111 omFree(x); // delete c
10112 omFree(q); // delete pl
10113 if (xx!=NULL) omFree(xx); // delete c
10114 return TRUE;
10115 }
10116 }
10117 }
10118 if (return_type==BIGINT_CMD)
10119 {
10120 CFArray i_v(rl);
10121 number n=n_ChineseRemainderSym(xx,q,rl,TRUE,i_v,coeffs_BIGINT);
10122 res->data=(char *)n;
10123 }
10124 else
10125 {
10126 #if 0
10127 #ifdef HAVE_VSPACE
10128 int cpus = (long) feOptValue(FE_OPT_CPUS);
10129 if ((cpus>1) && (rField_is_Q(currRing)))
10130 result=id_ChineseRemainder_0(x,q,rl,currRing); // deletes also x
10131 else
10132 #endif
10133 #endif
10134 result=id_ChineseRemainder(x,q,rl,currRing); // deletes also x
10135 c->Clean();
10136 if ((return_type==POLY_CMD) &&(result!=NULL))
10137 {
10138 res->data=(char *)result->m[0];
10139 result->m[0]=NULL;
10140 idDelete(&result);
10141 }
10142 else
10143 res->data=(char *)result;
10144 }
10145 for(i=rl-1;i>=0;i--)
10146 {
10147 n_Delete(&(q[i]),cf);
10148 }
10149 omFree(q);
10150 res->rtyp=return_type;
10151 return result==NULL;
10152}
void Copy(leftv e)
Definition: subexpr.cc:685
sleftv * m
Definition: lists.h:46
void Clean(ring r=currRing)
Definition: lists.h:26
INLINE_THIS void Init(int l=0)
int nr
Definition: lists.h:44
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
Definition: coeffs.h:846
return result
Definition: facAbsBiFact.cc:75
static void * feOptValue(feOptIndex opt)
Definition: feOpt.h:40
@ SMATRIX_CMD
Definition: grammar.cc:291
#define idDelete(H)
delete an ideal
Definition: ideals.h:29
ideal id_ChineseRemainder_0(ideal *xx, number *q, int rl, const ring r)
Definition: kChinese.cc:196
The main handler for Singular numbers which are suitable for Singular polynomials.
static BOOLEAN rField_is_Z(const ring r)
Definition: ring.h:510
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:507
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
ideal id_ChineseRemainder(ideal *xx, number *q, int rl, const ring r)
@ BIGINT_CMD
Definition: tok.h:38
@ LIST_CMD
Definition: tok.h:118
@ CHINREM_CMD
Definition: tok.h:45

◆ jjCOEF()

static BOOLEAN jjCOEF ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1797 of file iparith.cc.

1798{
1799 poly p=(poly)v->Data();
1800 if ((p==NULL)||(pNext(p)!=NULL)) return TRUE;
1801 res->data=(char *)mp_CoeffProc((poly)u->Data(),p /*(poly)v->Data()*/,currRing);
1802 return FALSE;
1803}
matrix mp_CoeffProc(poly f, poly vars, const ring R)
Definition: matpol.cc:399
#define pNext(p)
Definition: monomials.h:36

◆ jjCOEF_Id()

static BOOLEAN jjCOEF_Id ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1804 of file iparith.cc.

1805{
1806 poly p=(poly)v->Data();
1807 if ((p==NULL)||(pNext(p)!=NULL)) return TRUE;
1808 res->data=(char *)mp_CoeffProcId((ideal)u->Data(),p /*(poly)v->Data()*/,currRing);
1809 return FALSE;
1810}
matrix mp_CoeffProcId(ideal I, poly vars, const ring R)
Definition: matpol.cc:476

◆ jjCOEF_M()

static BOOLEAN jjCOEF_M ( leftv  ,
leftv  v 
)
static

Definition at line 7168 of file iparith.cc.

7169{
7170 const short t[]={4,VECTOR_CMD,POLY_CMD,MATRIX_CMD,MATRIX_CMD};
7171 if (iiCheckTypes(v,t,1))
7172 {
7173 idhdl c=(idhdl)v->next->next->data;
7174 if (v->next->next->next->rtyp!=IDHDL) return TRUE;
7175 idhdl m=(idhdl)v->next->next->next->data;
7176 idDelete((ideal *)&(c->data.uideal));
7177 idDelete((ideal *)&(m->data.uideal));
7178 mp_Coef2((poly)v->Data(),(poly)v->next->Data(),
7179 (matrix *)&(c->data.umatrix),(matrix *)&(m->data.umatrix),currRing);
7180 return FALSE;
7181 }
7182 return TRUE;
7183}
Definition: idrec.h:35
utypes data
Definition: idrec.h:40
@ VECTOR_CMD
Definition: grammar.cc:292
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
Definition: ipshell.cc:6562
void mp_Coef2(poly v, poly mon, matrix *c, matrix *m, const ring R)
corresponds to Macauley's coef: the exponent vector of vars has to contain the variables,...
Definition: matpol.cc:581
idrec * idhdl
Definition: ring.h:21

◆ jjCOEFFS2_KB()

static BOOLEAN jjCOEFFS2_KB ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1822 of file iparith.cc.

1823{
1824 poly p = pInit();
1825 int i;
1826 for (i=1; i<=currRing->N; i++)
1827 {
1828 pSetExp(p, i, 1);
1829 }
1830 pSetm(p);
1831 res->data = (void*)idCoeffOfKBase((ideal)(u->Data()),
1832 (ideal)(v->Data()), p);
1833 pLmFree(&p);
1834 return FALSE;
1835}
matrix idCoeffOfKBase(ideal arg, ideal kbase, poly how)
Definition: ideals.cc:2621
#define pSetm(p)
Definition: polys.h:271
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
Definition: polys.h:70
#define pInit()
allocates a new monomial and initializes everything to 0
Definition: polys.h:61
#define pSetExp(p, i, v)
Definition: polys.h:42

◆ jjCOEFFS3_Id()

static BOOLEAN jjCOEFFS3_Id ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6021 of file iparith.cc.

6022{
6023 if ((w->rtyp!=IDHDL)||(w->e!=NULL))
6024 {
6025 WerrorS("3rd argument must be a name of a matrix");
6026 return TRUE;
6027 }
6028 ideal i=(ideal)u->Data();
6029 int rank=(int)i->rank;
6030 BOOLEAN r=jjCOEFFS_Id(res,u,v);
6031 if (r) return TRUE;
6032 mp_Monomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data(),currRing);
6033 return FALSE;
6034}
static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
Definition: iparith.cc:1811
void mp_Monomials(matrix c, int r, int var, matrix m, const ring R)
Definition: matpol.cc:362
#define pVar(m)
Definition: polys.h:381

◆ jjCOEFFS3_KB()

static BOOLEAN jjCOEFFS3_KB ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6035 of file iparith.cc.

6036{
6037 res->data=(void*)idCoeffOfKBase((ideal)(u->Data()),
6038 (ideal)(v->Data()),(poly)(w->Data()));
6039 return FALSE;
6040}

◆ jjCOEFFS3_P()

static BOOLEAN jjCOEFFS3_P ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6041 of file iparith.cc.

6042{
6043 if ((w->rtyp!=IDHDL)||(w->e!=NULL))
6044 {
6045 WerrorS("3rd argument must be a name of a matrix");
6046 return TRUE;
6047 }
6048 // CopyD for POLY_CMD and VECTOR_CMD are identical:
6049 poly p=(poly)u->CopyD(POLY_CMD);
6050 ideal i=idInit(1,1);
6051 i->m[0]=p;
6052 sleftv t;
6053 t.Init();
6054 t.data=(char *)i;
6055 t.rtyp=IDEAL_CMD;
6056 int rank=1;
6057 if (u->Typ()==VECTOR_CMD)
6058 {
6059 i->rank=rank=pMaxComp(p);
6060 t.rtyp=MODUL_CMD;
6061 }
6062 BOOLEAN r=jjCOEFFS_Id(res,&t,v);
6063 t.CleanUp();
6064 if (r) return TRUE;
6065 mp_Monomials((matrix)res->data, rank, pVar((poly)v->Data()),(matrix)w->Data(),currRing);
6066 return FALSE;
6067}
#define pMaxComp(p)
Definition: polys.h:299

◆ jjCOEFFS_Id()

static BOOLEAN jjCOEFFS_Id ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1811 of file iparith.cc.

1812{
1813 int i=pVar((poly)v->Data());
1814 if (i==0)
1815 {
1816 WerrorS("ringvar expected");
1817 return TRUE;
1818 }
1819 res->data=(char *)mp_Coeffs((ideal)u->CopyD(),i,currRing);
1820 return FALSE;
1821}
matrix mp_Coeffs(ideal I, int var, const ring R)
corresponds to Maple's coeffs: var has to be the number of a variable
Definition: matpol.cc:313

◆ jjCOLCOL()

static BOOLEAN jjCOLCOL ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 698 of file iparith.cc.

699{
700 switch(u->Typ())
701 {
702 case 0:
703 {
704 int name_err=0;
705 if(isupper(u->name[0]))
706 {
707 const char *c=u->name+1;
708 while((*c!='\0')&&(islower(*c)||(isdigit(*c))||(*c=='_'))) c++;
709 if (*c!='\0')
710 name_err=1;
711 else
712 {
713 Print("%s of type 'ANY'. Trying load.\n", u->name);
714 if(iiTryLoadLib(u, u->name))
715 {
716 Werror("'%s' no such package", u->name);
717 return TRUE;
718 }
719 syMake(u,u->name,NULL);
720 }
721 }
722 else name_err=1;
723 if(name_err)
724 { Werror("'%s' is an invalid package name",u->name);return TRUE;}
725 // and now, after the loading: use next case !!! no break !!!
726 }
727 case PACKAGE_CMD:
728 {
729 package pa=(package)u->Data();
730 if (u->rtyp==IDHDL) pa=IDPACKAGE((idhdl)u->data);
731 if((!pa->loaded)
732 && (pa->language > LANG_TOP))
733 {
734 Werror("'%s' not loaded", u->name);
735 return TRUE;
736 }
737 if(v->rtyp == IDHDL)
738 {
739 v->name = omStrDup(v->name);
740 }
741 else if (v->rtyp!=0)
742 {
743 WerrorS("reserved name with ::");
744 return TRUE;
745 }
746 v->req_packhdl=pa;
747 syMake(v, v->name, pa);
748 memcpy(res, v, sizeof(sleftv));
749 v->Init();
750 }
751 break;
752 case DEF_CMD:
753 break;
754 default:
755 WerrorS("<package>::<id> expected");
756 return TRUE;
757 }
758 return FALSE;
759}
char name() const
Definition: variable.cc:122
BOOLEAN pa(leftv res, leftv args)
Definition: cohomo.cc:4323
#define IDPACKAGE(a)
Definition: ipid.h:139
BOOLEAN iiTryLoadLib(leftv v, const char *id)
Definition: iplib.cc:823
void syMake(leftv v, const char *id, package pa)
Definition: subexpr.cc:1562
@ LANG_TOP
Definition: subexpr.h:22
@ PACKAGE_CMD
Definition: tok.h:149
@ DEF_CMD
Definition: tok.h:58

◆ jjCOLON()

static BOOLEAN jjCOLON ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 327 of file iparith.cc.

328{
329 int l=(int)(long)v->Data();
330 if (l>=0)
331 {
332 int d=(int)(long)u->Data();
333 intvec *vv=new intvec(l);
334 int i;
335 for(i=l-1;i>=0;i--) { (*vv)[i]=d; }
336 res->data=(char *)vv;
337 }
338 return (l<0);
339}

◆ jjCOLS()

static BOOLEAN jjCOLS ( leftv  res,
leftv  v 
)
static

Definition at line 3866 of file iparith.cc.

3867{
3868 res->data = (char *)(long)MATCOLS((matrix)(v->Data()));
3869 return FALSE;
3870}

◆ jjCOLS_BIM()

static BOOLEAN jjCOLS_BIM ( leftv  res,
leftv  v 
)
static

Definition at line 3871 of file iparith.cc.

3872{
3873 res->data = (char *)(long)((bigintmat*)(v->Data()))->cols();
3874 return FALSE;
3875}

◆ jjCOLS_IV()

static BOOLEAN jjCOLS_IV ( leftv  res,
leftv  v 
)
static

Definition at line 3876 of file iparith.cc.

3877{
3878 res->data = (char *)(long)((intvec*)(v->Data()))->cols();
3879 return FALSE;
3880}

◆ jjCOMPARE_ALL()

static int jjCOMPARE_ALL ( const void *  aa,
const void *  bb 
)
static

Definition at line 10172 of file iparith.cc.

10173{
10174 leftv a=(leftv)aa;
10175 int at=a->Typ();
10176 leftv b=(leftv)bb;
10177 int bt=b->Typ();
10178 if (at < bt) return -1;
10179 if (at > bt) return 1;
10180 int tab_pos=iiTabIndex(dArithTab2,JJTAB2LEN,'<');
10181 sleftv tmp;
10182 tmp.Init();
10183 iiOp='<';
10184 BOOLEAN bo=iiExprArith2TabIntern(&tmp,a,'<',b,FALSE,dArith2+tab_pos,at,bt,dConvertTypes);
10185 if (bo)
10186 {
10187 Werror(" no `<` for %s",Tok2Cmdname(at));
10188 unsigned long ad=(unsigned long)a->Data();
10189 unsigned long bd=(unsigned long)b->Data();
10190 if (ad<bd) return -1;
10191 else if (ad==bd) return 0;
10192 else return 1;
10193 }
10194 else if (tmp.data==NULL) /* not < */
10195 {
10197 tab_pos=iiTabIndex(dArithTab2,JJTAB2LEN,EQUAL_EQUAL);
10199 if (bo)
10200 {
10201 Werror(" no `==` for %s",Tok2Cmdname(at));
10202 unsigned long ad=(unsigned long)a->Data();
10203 unsigned long bd=(unsigned long)b->Data();
10204 if (ad<bd) return -1;
10205 else if (ad==bd) return 0;
10206 else return 1;
10207 }
10208 else if (tmp.data==NULL) /* not <,== */ return 1;
10209 else return 0;
10210 }
10211 else return -1;
10212}
@ EQUAL_EQUAL
Definition: grammar.cc:268

◆ jjCOMPARE_BIM()

static BOOLEAN jjCOMPARE_BIM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 374 of file iparith.cc.

375{
376 bigintmat* a = (bigintmat * )(u->Data());
377 bigintmat* b = (bigintmat * )(v->Data());
378 int r=a->compare(b);
379 switch (iiOp)
380 {
381 case '<':
382 res->data = (char *) (r<0);
383 break;
384 case '>':
385 res->data = (char *) (r>0);
386 break;
387 case LE:
388 res->data = (char *) (r<=0);
389 break;
390 case GE:
391 res->data = (char *) (r>=0);
392 break;
393 case EQUAL_EQUAL:
394 case NOTEQUAL: /* negation handled by jjEQUAL_REST */
395 res->data = (char *) (r==0);
396 break;
397 }
398 jjEQUAL_REST(res,u,v);
399 if(r==-2) { WerrorS("size incompatible"); return TRUE; }
400 return FALSE;
401}
int compare(const bigintmat *op) const
Definition: bigintmat.cc:362
@ GE
Definition: grammar.cc:269
@ LE
Definition: grammar.cc:270
@ NOTEQUAL
Definition: grammar.cc:273
static void jjEQUAL_REST(leftv res, leftv u, leftv v)
Definition: iparith.cc:1371

◆ jjCOMPARE_IV()

static BOOLEAN jjCOMPARE_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 346 of file iparith.cc.

347{
348 intvec* a = (intvec * )(u->Data());
349 intvec* b = (intvec * )(v->Data());
350 int r=a->compare(b);
351 switch (iiOp)
352 {
353 case '<':
354 res->data = (char *) (r<0);
355 break;
356 case '>':
357 res->data = (char *) (r>0);
358 break;
359 case LE:
360 res->data = (char *) (r<=0);
361 break;
362 case GE:
363 res->data = (char *) (r>=0);
364 break;
365 case EQUAL_EQUAL:
366 case NOTEQUAL: /* negation handled by jjEQUAL_REST */
367 res->data = (char *) (r==0);
368 break;
369 }
370 jjEQUAL_REST(res,u,v);
371 if(r==-2) { WerrorS("size incompatible"); return TRUE; }
372 return FALSE;
373}
int compare(const intvec *o) const
Definition: intvec.cc:206

◆ jjCOMPARE_IV_I()

static BOOLEAN jjCOMPARE_IV_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 402 of file iparith.cc.

403{
404 intvec* a = (intvec * )(u->Data());
405 int b = (int)(long)(v->Data());
406 int r=a->compare(b);
407 switch (iiOp)
408 {
409 case '<':
410 res->data = (char *) (r<0);
411 break;
412 case '>':
413 res->data = (char *) (r>0);
414 break;
415 case LE:
416 res->data = (char *) (r<=0);
417 break;
418 case GE:
419 res->data = (char *) (r>=0);
420 break;
421 case EQUAL_EQUAL:
422 case NOTEQUAL: /* negation handled by jjEQUAL_REST */
423 res->data = (char *) (r==0);
424 break;
425 }
426 jjEQUAL_REST(res,u,v);
427 return FALSE;
428}

◆ jjCOMPARE_MA()

static BOOLEAN jjCOMPARE_MA ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 429 of file iparith.cc.

430{
431 //Print("in: >>%s<<\n",my_yylinebuf);
432 matrix a=(matrix)u->Data();
433 matrix b=(matrix)v->Data();
434 int r=mp_Compare(a,b,currRing);
435 switch (iiOp)
436 {
437 case '<':
438 res->data = (char *) (long)(r < 0);
439 break;
440 case '>':
441 res->data = (char *) (long)(r > 0);
442 break;
443 case LE:
444 res->data = (char *) (long)(r <= 0);
445 break;
446 case GE:
447 res->data = (char *) (long)(r >= 0);
448 break;
449 case EQUAL_EQUAL:
450 case NOTEQUAL: /* negation handled by jjEQUAL_REST */
451 res->data = (char *)(long) (r == 0);
452 break;
453 }
454 jjEQUAL_REST(res,u,v);
455 return FALSE;
456}
int mp_Compare(matrix a, matrix b, const ring R)
Definition: matpol.cc:643

◆ jjCOMPARE_P()

static BOOLEAN jjCOMPARE_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 457 of file iparith.cc.

458{
459 poly p=(poly)u->Data();
460 poly q=(poly)v->Data();
461 int r=p_Compare(p,q,currRing);
462 switch (iiOp)
463 {
464 case '<':
465 res->data = (char *) (r < 0);
466 break;
467 case '>':
468 res->data = (char *) (r > 0);
469 break;
470 case LE:
471 res->data = (char *) (r <= 0);
472 break;
473 case GE:
474 res->data = (char *) (r >= 0);
475 break;
476 //case EQUAL_EQUAL:
477 //case NOTEQUAL: /* negation handled by jjEQUAL_REST */
478 // res->data = (char *) (r == 0);
479 // break;
480 }
481 jjEQUAL_REST(res,u,v);
482 return FALSE;
483}
int p_Compare(const poly a, const poly b, const ring R)
Definition: p_polys.cc:5023

◆ jjCOMPARE_S()

static BOOLEAN jjCOMPARE_S ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 484 of file iparith.cc.

485{
486 char* a = (char * )(u->Data());
487 char* b = (char * )(v->Data());
488 int result = strcmp(a,b);
489 switch (iiOp)
490 {
491 case '<':
492 res->data = (char *) (result < 0);
493 break;
494 case '>':
495 res->data = (char *) (result > 0);
496 break;
497 case LE:
498 res->data = (char *) (result <= 0);
499 break;
500 case GE:
501 res->data = (char *) (result >= 0);
502 break;
503 case EQUAL_EQUAL:
504 case NOTEQUAL: /* negation handled by jjEQUAL_REST */
505 res->data = (char *) (result == 0);
506 break;
507 }
508 jjEQUAL_REST(res,u,v);
509 return FALSE;
510}

◆ jjCONTENT()

static BOOLEAN jjCONTENT ( leftv  res,
leftv  v 
)
static

Definition at line 3881 of file iparith.cc.

3882{
3883 // CopyD for POLY_CMD and VECTOR_CMD are identical:
3884 poly p=(poly)v->CopyD(POLY_CMD);
3885 if (p!=NULL) p_Cleardenom(p, currRing);
3886 res->data = (char *)p;
3887 return FALSE;
3888}
poly p_Cleardenom(poly p, const ring r)
Definition: p_polys.cc:2910

◆ jjCONTRACT()

static BOOLEAN jjCONTRACT ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1836 of file iparith.cc.

1837{
1838 res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data(),FALSE);
1839 return FALSE;
1840}
matrix idDiffOp(ideal I, ideal J, BOOLEAN multiply)
Definition: ideals.cc:2151

◆ jjCOUNT_BI()

static BOOLEAN jjCOUNT_BI ( leftv  res,
leftv  v 
)
static

Definition at line 3889 of file iparith.cc.

3890{
3891 res->data = (char *)(long)n_Size((number)v->Data(),coeffs_BIGINT);
3892 return FALSE;
3893}
static FORCE_INLINE int n_Size(number n, const coeffs r)
return a non-negative measure for the complexity of n; return 0 only when n represents zero; (used fo...
Definition: coeffs.h:570

◆ jjCOUNT_BIM()

static BOOLEAN jjCOUNT_BIM ( leftv  res,
leftv  v 
)
static

Definition at line 3894 of file iparith.cc.

3895{
3896 bigintmat* aa= (bigintmat *)v->Data();
3897 res->data = (char *)(long)(aa->rows()*aa->cols());
3898 return FALSE;
3899}

◆ jjCOUNT_IV()

static BOOLEAN jjCOUNT_IV ( leftv  res,
leftv  v 
)
static

Definition at line 3917 of file iparith.cc.

3918{
3919 res->data = (char *)(long)((intvec*)(v->Data()))->length();
3920 return FALSE;
3921}

◆ jjCOUNT_L()

static BOOLEAN jjCOUNT_L ( leftv  res,
leftv  v 
)
static

Definition at line 3905 of file iparith.cc.

3906{
3907 lists l=(lists)v->Data();
3908 res->data = (char *)(long)(lSize(l)+1);
3909 return FALSE;
3910}
int lSize(lists L)
Definition: lists.cc:25

◆ jjCOUNT_M()

static BOOLEAN jjCOUNT_M ( leftv  res,
leftv  v 
)
static

Definition at line 3911 of file iparith.cc.

3912{
3913 matrix m=(matrix)v->Data();
3914 res->data = (char *)(long)(MATROWS(m)*MATCOLS(m));
3915 return FALSE;
3916}

◆ jjCOUNT_N()

static BOOLEAN jjCOUNT_N ( leftv  res,
leftv  v 
)
static

Definition at line 3900 of file iparith.cc.

3901{
3902 res->data = (char *)(long)nSize((number)v->Data());
3903 return FALSE;
3904}

◆ jjCOUNT_RES()

static BOOLEAN jjCOUNT_RES ( leftv  res,
leftv  v 
)
static

Definition at line 5667 of file iparith.cc.

5668{
5669 res->data=(char *)(long)sySize((syStrategy)v->Data());
5670 return FALSE;
5671}
int sySize(syStrategy syzstr)
Definition: syz1.cc:1829

◆ jjCOUNT_RG()

static BOOLEAN jjCOUNT_RG ( leftv  res,
leftv  v 
)
static

Definition at line 3922 of file iparith.cc.

3923{
3924 ring r=(ring)v->Data();
3925 int elems=-1;
3926 if (rField_is_Zp(r)) elems=r->cf->ch;
3927 else if (rField_is_GF(r)) elems=r->cf->m_nfCharQ;
3928 else if (rField_is_Zp_a(r) && (r->cf->type==n_algExt))
3929 {
3930 extern int ipower ( int b, int n ); /* factory/cf_util */
3931 elems=ipower(r->cf->ch,r->cf->extRing->pFDeg(r->cf->extRing->qideal->m[0],r->cf->extRing));
3932 }
3933 res->data = (char *)(long)elems;
3934 return FALSE;
3935}
int ipower(int b, int m)
int ipower ( int b, int m )
Definition: cf_util.cc:27
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition: coeffs.h:35
static BOOLEAN rField_is_Zp_a(const ring r)
Definition: ring.h:530
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:501
static BOOLEAN rField_is_GF(const ring r)
Definition: ring.h:522

◆ jjDEFINED()

static BOOLEAN jjDEFINED ( leftv  res,
leftv  v 
)
static

Definition at line 3974 of file iparith.cc.

3975{
3976 if ((v->rtyp==IDHDL)
3977 && ((myynest==IDLEV((idhdl)v->data))||(0==IDLEV((idhdl)v->data))))
3978 {
3979 res->data=(void *)(long)(IDLEV((idhdl)v->data)+1);
3980 }
3981 else if (v->rtyp!=0) res->data=(void *)(-1);
3982 return FALSE;
3983}
#define IDLEV(a)
Definition: ipid.h:121

◆ jjDEG()

static BOOLEAN jjDEG ( leftv  res,
leftv  v 
)
static

Definition at line 3936 of file iparith.cc.

3937{
3938 int dummy;
3939 poly p=(poly)v->Data();
3940 if (p!=NULL) res->data = (char *)currRing->pLDeg(p,&dummy,currRing);
3941 else res->data=(char *)-1;
3942 return FALSE;
3943}

◆ jjDEG_IV()

static BOOLEAN jjDEG_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1852 of file iparith.cc.

1853{
1854 poly p=(poly)u->Data();
1855 if (p!=NULL)
1856 {
1857 int *iv=iv2array((intvec *)v->Data(),currRing);
1858 const long d = p_DegW(p,iv,currRing);
1859 omFreeSize( (ADDRESS)iv, (rVar(currRing)+1)*sizeof(int) );
1860 res->data = (char *)(d);
1861 }
1862 else
1863 res->data=(char *)(long)(-1);
1864 return FALSE;
1865}
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
long p_DegW(poly p, const int *w, const ring R)
Definition: p_polys.cc:690
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:593
int * iv2array(intvec *iv, const ring R)
Definition: weight.cc:200

◆ jjDEG_M()

static BOOLEAN jjDEG_M ( leftv  res,
leftv  u 
)
static

Definition at line 3944 of file iparith.cc.

3945{
3946 ideal I=(ideal)u->Data();
3947 int d=-1;
3948 int dummy;
3949 int i;
3950 for(i=IDELEMS(I)-1;i>=0;i--)
3951 if (I->m[i]!=NULL) d=si_max(d,(int)currRing->pLDeg(I->m[i],&dummy,currRing));
3952 res->data = (char *)(long)d;
3953 return FALSE;
3954}
static int si_max(const int a, const int b)
Definition: auxiliary.h:124

◆ jjDEG_M_IV()

static BOOLEAN jjDEG_M_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1841 of file iparith.cc.

1842{
1843 int *iv=iv2array((intvec *)v->Data(),currRing);
1844 ideal I=(ideal)u->Data();
1845 int d=-1;
1846 int i;
1847 for(i=IDELEMS(I);i>=0;i--) d=si_max(d,(int)p_DegW(I->m[i],iv,currRing));
1848 omFreeSize( (ADDRESS)iv, (rVar(currRing)+1)*sizeof(int) );
1849 res->data = (char *)((long)d);
1850 return FALSE;
1851}

◆ jjDEGREE()

static BOOLEAN jjDEGREE ( leftv  res,
leftv  v 
)
static

Definition at line 3955 of file iparith.cc.

3956{
3957 SPrintStart();
3958#ifdef HAVE_RINGS
3959 if (rField_is_Z(currRing))
3960 {
3961 PrintS("// NOTE: computation of degree is being performed for\n");
3962 PrintS("// generic fibre, that is, over Q\n");
3963 }
3964#endif
3966 intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
3967 scDegree((ideal)v->Data(),module_w,currRing->qideal);
3968 char *s=SPrintEnd();
3969 int l=strlen(s)-1;
3970 s[l]='\0';
3971 res->data=(void*)s;
3972 return FALSE;
3973}
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
Definition: attrib.cc:132
void scDegree(ideal S, intvec *modulweight, ideal Q)
Definition: hdegree.cc:926
void SPrintStart()
Definition: reporter.cc:246
void PrintS(const char *s)
Definition: reporter.cc:284
char * SPrintEnd()
Definition: reporter.cc:273
BOOLEAN assumeStdFlag(leftv h)
Definition: subexpr.cc:1536

◆ jjDelete_ID()

static BOOLEAN jjDelete_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1873 of file iparith.cc.

1874{
1875 int pos=(int)(long)v->Data();
1876 ideal I=(ideal)u->Data();
1877 res->data=(void*)id_Delete_Pos(I,pos-1,currRing);
1878 return res->data==NULL;
1879}
ideal id_Delete_Pos(const ideal I, const int p, const ring r)

◆ jjDelete_IV()

static BOOLEAN jjDelete_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1866 of file iparith.cc.

1867{
1868 int pos=(int)(long)v->Data();
1869 intvec *iv=(intvec*)u->Data();
1870 res->data=(void*)iv->delete_pos(pos-1);
1871 return res->data==NULL;
1872}
intvec * delete_pos(int p)
Definition: intvec.cc:842

◆ jjDENOMINATOR()

static BOOLEAN jjDENOMINATOR ( leftv  res,
leftv  v 
)
static

Return the denominator of the input number.

Definition at line 3986 of file iparith.cc.

3987{
3988 number n = reinterpret_cast<number>(v->CopyD());
3989 res->data = reinterpret_cast<void*>(n_GetDenom(n, currRing->cf));
3990 n_Delete(&n,currRing->cf);
3991 return FALSE;
3992}
static FORCE_INLINE number n_GetDenom(number &n, const coeffs r)
return the denominator of n (if elements of r are by nature not fractional, result is 1)
Definition: coeffs.h:603

◆ jjDET()

static BOOLEAN jjDET ( leftv  res,
leftv  v 
)
static

Definition at line 4003 of file iparith.cc.

4004{
4005 matrix m=(matrix)v->Data();
4006 res ->data = mp_Det(m,currRing);
4007 return FALSE;
4008}
poly mp_Det(matrix a, const ring r, DetVariant d)
Definition: matpol.cc:2143

◆ jjDET2()

static BOOLEAN jjDET2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1880 of file iparith.cc.

1881{
1882 matrix m=(matrix)u->Data();
1883 DetVariant d=mp_GetAlgorithmDet((char*)v->Data());
1884 res ->data = mp_Det(m,currRing,d);
1885 return FALSE;
1886}
DetVariant mp_GetAlgorithmDet(matrix m, const ring r)
Definition: matpol.cc:2112
DetVariant
Definition: matpol.h:35

◆ jjDET2_S()

static BOOLEAN jjDET2_S ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1887 of file iparith.cc.

1888{
1889 DetVariant d=mp_GetAlgorithmDet((char*)v->Data());
1890 ideal m=(ideal)u->Data();
1891 res ->data = sm_Det(m,currRing,d);
1892 return FALSE;
1893}
poly sm_Det(ideal a, const ring r, DetVariant d)
Definition: matpol.cc:2167

◆ jjDET_BI()

static BOOLEAN jjDET_BI ( leftv  res,
leftv  v 
)
static

Definition at line 4009 of file iparith.cc.

4010{
4011 bigintmat * m=(bigintmat*)v->Data();
4012 int i,j;
4013 i=m->rows();j=m->cols();
4014 if(i==j)
4015 res->data = (char *)(long)singclap_det_bi(m,coeffs_BIGINT);
4016 else
4017 {
4018 Werror("det of %d x %d bigintmat",i,j);
4019 return TRUE;
4020 }
4021 return FALSE;
4022}
number singclap_det_bi(bigintmat *m, const coeffs cf)
Definition: clapsing.cc:1798
int j
Definition: facHensel.cc:110

◆ jjDET_I()

static BOOLEAN jjDET_I ( leftv  res,
leftv  v 
)
static

Definition at line 4045 of file iparith.cc.

4046{
4047 intvec * m=(intvec*)v->Data();
4048 int i,j;
4049 i=m->rows();j=m->cols();
4050 if(i==j)
4051 res->data = (char *)(long)singclap_det_i(m,currRing);
4052 else
4053 {
4054 Werror("det of %d x %d intmat",i,j);
4055 return TRUE;
4056 }
4057 return FALSE;
4058}
int singclap_det_i(intvec *m, const ring)
Definition: clapsing.cc:1780

◆ jjDET_S()

static BOOLEAN jjDET_S ( leftv  res,
leftv  v 
)
static

Definition at line 4059 of file iparith.cc.

4060{
4061 ideal I=(ideal)v->Data();
4062 res->data=(char*)sm_Det(I,currRing);
4063 return FALSE;
4064}

◆ jjDIFF_COEF()

static BOOLEAN jjDIFF_COEF ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 4429 of file iparith.cc.

4430{
4431 if (!nCoeff_is_transExt(currRing->cf))
4432 {
4433 WerrorS("differentiation not defined in the coefficient ring");
4434 return TRUE;
4435 }
4436 number n = (number) u->Data();
4437 number k = (number) v->Data();
4438 res->data = ntDiff(n,k,currRing->cf);
4439 return FALSE;
4440}
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
Definition: coeffs.h:918
number ntDiff(number a, number d, const coeffs cf)
Definition: transext.cc:897

◆ jjDIFF_ID()

static BOOLEAN jjDIFF_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1905 of file iparith.cc.

1906{
1907 int i=pVar((poly)v->Data());
1908 if (i==0)
1909 {
1910 WerrorS("ringvar expected");
1911 return TRUE;
1912 }
1913 res->data=(char *)idDiff((matrix)(u->Data()),i);
1914 return FALSE;
1915}
matrix idDiff(matrix i, int k)
Definition: ideals.cc:2138

◆ jjDIFF_ID_ID()

static BOOLEAN jjDIFF_ID_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1916 of file iparith.cc.

1917{
1918 res->data=(char *)idDiffOp((ideal)u->Data(),(ideal)v->Data());
1919 return FALSE;
1920}

◆ jjDIFF_P()

static BOOLEAN jjDIFF_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1894 of file iparith.cc.

1895{
1896 int i=pVar((poly)v->Data());
1897 if (i==0)
1898 {
1899 WerrorS("ringvar expected");
1900 return TRUE;
1901 }
1902 res->data=(char *)pDiff((poly)(u->Data()),i);
1903 return FALSE;
1904}
#define pDiff(a, b)
Definition: polys.h:296

◆ jjDIM()

static BOOLEAN jjDIM ( leftv  res,
leftv  v 
)
static

Definition at line 4065 of file iparith.cc.

4066{
4068#ifdef HAVE_SHIFTBBA
4069 if (rIsLPRing(currRing))
4070 {
4071#ifdef HAVE_RINGS
4073 {
4074 WerrorS("`dim` is not implemented for letterplace rings over rings");
4075 return TRUE;
4076 }
4077#endif
4078 if (currRing->qideal != NULL)
4079 {
4080 WerrorS("qring not supported by `dim` for letterplace rings at the moment");
4081 return TRUE;
4082 }
4083 int gkDim = lp_gkDim((ideal)(v->Data()));
4084 res->data = (char *)(long)gkDim;
4085 return (gkDim == -2);
4086 }
4087#endif
4089 {
4090 Warn("dim(%s) may be wrong because the mixed monomial ordering",v->Name());
4091 }
4092 res->data = (char *)(long)scDimIntRing((ideal)(v->Data()),currRing->qideal);
4093 return FALSE;
4094}
int scDimIntRing(ideal vid, ideal Q)
scDimInt for ring-coefficients
Definition: hdegree.cc:136
int lp_gkDim(const ideal _G)
Definition: hdegree.cc:1862
BOOLEAN rHasMixedOrdering(const ring r)
Definition: ring.h:762

◆ jjDIM2()

static BOOLEAN jjDIM2 ( leftv  res,
leftv  v,
leftv  w 
)
static

Definition at line 1921 of file iparith.cc.

1922{
1925 {
1926 Warn("dim(%s,...) may be wrong because the mixed monomial ordering",v->Name());
1927 }
1928 if(currRing->qideal==NULL)
1929 res->data = (char *)((long)scDimIntRing((ideal)(v->Data()),(ideal)w->Data()));
1930 else
1931 {
1932 ideal q=idSimpleAdd(currRing->qideal,(ideal)w->Data());
1933 res->data = (char *)((long)scDimIntRing((ideal)(v->Data()),q));
1934 idDelete(&q);
1935 }
1936 return FALSE;
1937}
#define idSimpleAdd(A, B)
Definition: ideals.h:42

◆ jjDIM_R()

static BOOLEAN jjDIM_R ( leftv  res,
leftv  v 
)
static

Definition at line 5672 of file iparith.cc.

5673{
5674 res->data = (char *)(long)syDim((syStrategy)v->Data());
5675 return FALSE;
5676}
int syDim(syStrategy syzstr)
Definition: syz1.cc:1849

◆ jjDIV_BI()

static BOOLEAN jjDIV_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1254 of file iparith.cc.

1255{
1256 number q=(number)v->Data();
1257 if (n_IsZero(q,coeffs_BIGINT))
1258 {
1260 return TRUE;
1261 }
1262 q = n_Div((number)u->Data(),q,coeffs_BIGINT);
1264 res->data = (char *)q;
1265 return FALSE;
1266}
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
Definition: coeffs.h:615
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
Definition: coeffs.h:464
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
Definition: coeffs.h:578
#define ii_div_by_0
Definition: iparith.cc:220

◆ jjDIV_Ma()

static BOOLEAN jjDIV_Ma ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1298 of file iparith.cc.

1299{
1300 poly q=(poly)v->Data();
1301 if (q==NULL)
1302 {
1304 return TRUE;
1305 }
1306 matrix m=(matrix)(u->Data());
1307 int r=m->rows();
1308 int c=m->cols();
1309 matrix mm=mpNew(r,c);
1310 unsigned i,j;
1311 for(i=r;i>0;i--)
1312 {
1313 for(j=c;j>0;j--)
1314 {
1315 if (pNext(q)!=NULL)
1316 {
1318 q /*(poly)(v->Data())*/, currRing );
1319 }
1320 else
1321 MATELEM(mm,i,j) = pp_DivideM(MATELEM(m,i,j),q,currRing);
1322 }
1323 }
1324 res->data=(char *)mm;
1325 return FALSE;
1326}
poly singclap_pdivide(poly f, poly g, const ring r)
Definition: clapsing.cc:624
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29
poly pp_DivideM(poly a, poly b, const ring r)
Definition: p_polys.cc:1629

◆ jjDIV_N()

static BOOLEAN jjDIV_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1267 of file iparith.cc.

1268{
1269 number q=(number)v->Data();
1270 if (nIsZero(q))
1271 {
1273 return TRUE;
1274 }
1275 q = nDiv((number)u->Data(),q);
1276 nNormalize(q);
1277 res->data = (char *)q;
1278 return FALSE;
1279}
#define nDiv(a, b)
Definition: numbers.h:32
#define nNormalize(n)
Definition: numbers.h:30

◆ jjDIV_P()

static BOOLEAN jjDIV_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1280 of file iparith.cc.

1281{
1282 poly q=(poly)v->Data();
1283 poly p=(poly)(u->Data());
1284 if (q!=NULL)
1285 {
1286 res->data=(void*)(pp_Divide(p /*(poly)(u->Data())*/ ,
1287 q /*(poly)(v->Data())*/ ,currRing));
1288 if (res->data!=NULL) pNormalize((poly)res->data);
1289 return errorreported; /*there may be errors in p_Divide: div. ny 0, etc.*/
1290 }
1291 else
1292 {
1293 WerrorS("div. by 0");
1294 return TRUE;
1295 }
1296
1297}
poly pp_Divide(poly p, poly q, const ring r)
polynomial division a/b, ignoring the rest via singclap_pdivide resp. idLift does not destroy a,...
Definition: polys.cc:174
#define pNormalize(p)
Definition: polys.h:317

◆ jjDIVISION()

static BOOLEAN jjDIVISION ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1938 of file iparith.cc.

1939{
1940 ideal vi=(ideal)v->Data();
1941 int vl= IDELEMS(vi);
1942 ideal ui=(ideal)u->Data();
1943 unsigned ul= IDELEMS(ui);
1944 ideal R; matrix U;
1945 ideal m = idLift(vi,ui,&R, FALSE,hasFlag(v,FLAG_STD),TRUE,&U);
1946 if (m==NULL) return TRUE;
1947 // now make sure that all matrices have the correct size:
1949 assume (MATCOLS(U) == (int)ul);
1951 L->Init(3);
1952 L->m[0].rtyp=MATRIX_CMD; L->m[0].data=(void *)T;
1953 L->m[1].rtyp=u->Typ(); L->m[1].data=(void *)R;
1954 L->m[2].rtyp=MATRIX_CMD; L->m[2].data=(void *)U;
1955 res->data=(char *)L;
1956 return FALSE;
1957}
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit, GbVariant alg)
represents the generators of submod in terms of the generators of mod (Matrix(SM)*U-Matrix(rest)) = M...
Definition: ideals.cc:1105
#define hasFlag(A, F)
Definition: ipid.h:112
#define FLAG_STD
Definition: ipid.h:106
STATIC_VAR jList * T
Definition: janet.cc:30
matrix id_Module2formatedMatrix(ideal mod, int rows, int cols, const ring R)
#define R
Definition: sirandom.c:27

◆ jjDIVISION4()

static BOOLEAN jjDIVISION4 ( leftv  res,
leftv  v 
)
static

Definition at line 7185 of file iparith.cc.

7186{ // may have 3 or 4 arguments
7187 leftv v1=v;
7188 leftv v2=v1->next;
7189 leftv v3=v2->next;
7190 leftv v4=v3->next;
7191 assumeStdFlag(v2);
7192
7193 int i1=iiTestConvert(v1->Typ(),MODUL_CMD);
7194 int i2=iiTestConvert(v2->Typ(),MODUL_CMD);
7195
7196 if((i1==0)||(i2==0)
7197 ||(v3->Typ()!=INT_CMD)||((v4!=NULL)&&(v4->Typ()!=INTVEC_CMD)))
7198 {
7199 WarnS("<module>,<module>,<int>[,<intvec>] expected!");
7200 return TRUE;
7201 }
7202
7203 sleftv w1,w2;
7204 iiConvert(v1->Typ(),MODUL_CMD,i1,v1,&w1);
7205 iiConvert(v2->Typ(),MODUL_CMD,i2,v2,&w2);
7206 ideal P=(ideal)w1.Data();
7207 ideal Q=(ideal)w2.Data();
7208
7209 int n=(int)(long)v3->Data();
7210 int *w=NULL;
7211 if(v4!=NULL)
7212 {
7213 w = iv2array((intvec *)v4->Data(),currRing);
7214 int * w0 = w + 1;
7215 int i = currRing->N;
7216 while( (i > 0) && ((*w0) > 0) )
7217 {
7218 w0++;
7219 i--;
7220 }
7221 if(i>0)
7222 WarnS("not all weights are positive!");
7223 }
7224
7225 matrix T;
7226 ideal R;
7227 idLiftW(P,Q,n,T,R,w);
7228
7229 w1.CleanUp();
7230 w2.CleanUp();
7231 if(w!=NULL)
7232 omFreeSize( (ADDRESS)w, (rVar(currRing)+1)*sizeof(int) );
7233
7235 L->Init(2);
7236 L->m[1].rtyp=v1->Typ();
7237 if(v1->Typ()==POLY_CMD||v1->Typ()==VECTOR_CMD)
7238 {
7239 if(v1->Typ()==POLY_CMD)
7240 p_Shift(&R->m[0],-1,currRing);
7241 L->m[1].data=(void *)R->m[0];
7242 R->m[0]=NULL;
7243 idDelete(&R);
7244 }
7245 else if(v1->Typ()==IDEAL_CMD||v1->Typ()==MATRIX_CMD)
7246 L->m[1].data=(void *)id_Module2Matrix(R,currRing);
7247 else
7248 {
7249 L->m[1].rtyp=MODUL_CMD;
7250 L->m[1].data=(void *)R;
7251 }
7252 L->m[0].rtyp=MATRIX_CMD;
7253 L->m[0].data=(char *)T;
7254
7255 res->data=L;
7256
7257 return FALSE;
7258}
void idLiftW(ideal P, ideal Q, int n, matrix &T, ideal &R, int *w)
Definition: ideals.cc:1324
STATIC_VAR jList * Q
Definition: janet.cc:30
matrix id_Module2Matrix(ideal mod, const ring R)

◆ jjDIVMOD_I()

static BOOLEAN jjDIVMOD_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1231 of file iparith.cc.

1232{
1233 if (iiOp=='/') Warn("int division with `/`: use `div` instead in line >>%s<<",my_yylinebuf);
1234 int a= (int)(long)u->Data();
1235 int b= (int)(long)v->Data();
1236 if (b==0)
1237 {
1239 return TRUE;
1240 }
1241 int c=a%b;
1242 int r=0;
1243 switch (iiOp)
1244 {
1245 case '%':
1246 r=c; break;
1247 case '/':
1248 case INTDIV_CMD:
1249 r=((a-c) /b); break;
1250 }
1251 res->data=(void *)((long)r);
1252 return FALSE;
1253}
@ INTDIV_CMD
Definition: tok.h:97

◆ jjDOTDOT()

static BOOLEAN jjDOTDOT ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 340 of file iparith.cc.

341{
342 res->data=(char *)new intvec((int)(long)u->Data(),(int)(long)v->Data());
343 return FALSE;
344}

◆ jjDUMMY()

static BOOLEAN jjDUMMY ( leftv  res,
leftv  u 
)
static

Definition at line 3689 of file iparith.cc.

3690{
3691// res->data = (char *)u->CopyD();
3692// also copy attributes:
3693 res->Copy(u);
3694 return FALSE;
3695}

◆ jjDUMP()

static BOOLEAN jjDUMP ( leftv  ,
leftv  v 
)
static

Definition at line 4095 of file iparith.cc.

4096{
4097 si_link l = (si_link)v->Data();
4098 if (slDump(l))
4099 {
4100 const char *s;
4101 if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
4102 else s=sNoName_fe;
4103 Werror("cannot dump to `%s`",s);
4104 return TRUE;
4105 }
4106 else
4107 return FALSE;
4108}

◆ jjE()

static BOOLEAN jjE ( leftv  res,
leftv  v 
)
static

Definition at line 4109 of file iparith.cc.

4110{
4111 res->data = (char *)pOne();
4112 int co=(int)(long)v->Data();
4113 if (co>0)
4114 {
4115 pSetComp((poly)res->data,co);
4116 pSetm((poly)res->data);
4117 }
4118 else WerrorS("argument of gen must be positive");
4119 return (co<=0);
4120}
#define pSetComp(p, v)
Definition: polys.h:38
#define pOne()
Definition: polys.h:315

◆ jjELIMIN()

static BOOLEAN jjELIMIN ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1958 of file iparith.cc.

1959{
1960 res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data());
1961 //setFlag(res,FLAG_STD);
1962 return v->next!=NULL; //do not allow next like in eliminate(I,a(1..4))
1963}
ideal idElimination(ideal h1, poly delVar, intvec *hilb, GbVariant alg)
Definition: ideals.cc:1593

◆ jjELIMIN_ALG()

static BOOLEAN jjELIMIN_ALG ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6068 of file iparith.cc.

6069{
6070 ideal I=(ideal)u->Data();
6071 GbVariant alg=syGetAlgorithm((char*)w->Data(),currRing,I);
6072 res->data=(char *)idElimination(I,(poly)v->Data(),NULL,alg);
6073 //setFlag(res,FLAG_STD);
6074 return v->next!=NULL; //do not allow next like in eliminate(I,a(1..4))
6075}
GbVariant syGetAlgorithm(char *n, const ring r, const ideal)
Definition: ideals.cc:3154
GbVariant
Definition: ideals.h:119

◆ jjELIMIN_HILB()

static BOOLEAN jjELIMIN_HILB ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6076 of file iparith.cc.

6077{
6078 res->data=(char *)idElimination((ideal)u->Data(),(poly)v->Data(),
6079 (intvec *)w->Data());
6080 //setFlag(res,FLAG_STD);
6081 return FALSE;
6082}

◆ jjELIMIN_IV()

static BOOLEAN jjELIMIN_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1964 of file iparith.cc.

1965{
1966 poly p=pOne();
1967 intvec *iv=(intvec*)v->Data();
1968 for(int i=iv->length()-1; i>=0; i--)
1969 {
1970 pSetExp(p,(*iv)[i],1);
1971 }
1972 pSetm(p);
1973 res->data=(char *)idElimination((ideal)u->Data(),p);
1974 pLmDelete(&p);
1975 //setFlag(res,FLAG_STD);
1976 return FALSE;
1977}
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76

◆ jjENVELOPE()

static BOOLEAN jjENVELOPE ( leftv  res,
leftv  a 
)
static

Definition at line 5238 of file iparith.cc.

5239{
5240#ifdef HAVE_PLURAL
5241 ring r = (ring)a->Data();
5242 if (rIsPluralRing(r))
5243 {
5244 ring s = rEnvelope(r);
5245 res->data = s;
5246 }
5247 else res->data = rCopy(r);
5248 return FALSE;
5249#else
5250 return TRUE;
5251#endif
5252}
ring rEnvelope(ring R)
Definition: ring.cc:5772
ring rCopy(ring r)
Definition: ring.cc:1731

◆ jjEQUAL_BI()

static BOOLEAN jjEQUAL_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1327 of file iparith.cc.

1328{
1329 res->data = (char *)((long)n_Equal((number)u->Data(),(number)v->Data(),coeffs_BIGINT));
1330 jjEQUAL_REST(res,u,v);
1331 return FALSE;
1332}
static FORCE_INLINE BOOLEAN n_Equal(number a, number b, const coeffs r)
TRUE iff 'a' and 'b' represent the same number; they may have different representations.
Definition: coeffs.h:460

◆ jjEQUAL_I()

static BOOLEAN jjEQUAL_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1333 of file iparith.cc.

1334{
1335 res->data = (char *)((int)((long)u->Data()) == (int)((long)v->Data()));
1336 jjEQUAL_REST(res,u,v);
1337 return FALSE;
1338}

◆ jjEQUAL_Ma()

static BOOLEAN jjEQUAL_Ma ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1339 of file iparith.cc.

1340{
1341 res->data = (char *)((long)mp_Equal((matrix)u->Data(),(matrix)v->Data(),currRing));
1342 jjEQUAL_REST(res,u,v);
1343 return FALSE;
1344}
BOOLEAN mp_Equal(matrix a, matrix b, const ring R)
Definition: matpol.cc:662

◆ jjEQUAL_N()

static BOOLEAN jjEQUAL_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1357 of file iparith.cc.

1358{
1359 res->data = (char *)((long)nEqual((number)u->Data(),(number)v->Data()));
1360 jjEQUAL_REST(res,u,v);
1361 return FALSE;
1362}
#define nEqual(n1, n2)
Definition: numbers.h:20

◆ jjEQUAL_P()

static BOOLEAN jjEQUAL_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1363 of file iparith.cc.

1364{
1365 poly p=(poly)u->Data();
1366 poly q=(poly)v->Data();
1367 res->data = (char *) ((long)pEqualPolys(p,q));
1368 jjEQUAL_REST(res,u,v);
1369 return FALSE;
1370}
#define pEqualPolys(p1, p2)
Definition: polys.h:400

◆ jjEQUAL_R()

static BOOLEAN jjEQUAL_R ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1351 of file iparith.cc.

1352{
1353 res->data = (char *)(long)(u->Data()==v->Data());
1354 jjEQUAL_REST(res,u,v);
1355 return FALSE;
1356}

◆ jjEQUAL_REST()

static void jjEQUAL_REST ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1371 of file iparith.cc.

1372{
1373 if ((res->data) && (u->next!=NULL) && (v->next!=NULL))
1374 {
1375 int save_iiOp=iiOp;
1376 if (iiOp==NOTEQUAL)
1378 else
1380 iiOp=save_iiOp;
1381 }
1382 if (iiOp==NOTEQUAL) res->data=(char *)(!(long)res->data);
1383}

◆ jjEQUAL_SM()

static BOOLEAN jjEQUAL_SM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1345 of file iparith.cc.

1346{
1347 res->data = (char *)((long)sm_Equal((ideal)u->Data(),(ideal)v->Data(),currRing));
1348 jjEQUAL_REST(res,u,v);
1349 return FALSE;
1350}
BOOLEAN sm_Equal(ideal a, ideal b, const ring R)
Definition: matpol.cc:2003

◆ jjERROR()

static BOOLEAN jjERROR ( leftv  ,
leftv  u 
)
static

Definition at line 1983 of file iparith.cc.

1984{
1985 WerrorS((char *)u->Data());
1986 EXTERN_VAR int inerror;
1987 inerror=3;
1988 return TRUE;
1989}
#define EXTERN_VAR
Definition: globaldefs.h:6
EXTERN_VAR int inerror

◆ jjEXECUTE()

static BOOLEAN jjEXECUTE ( leftv  ,
leftv  v 
)
static

Definition at line 4121 of file iparith.cc.

4122{
4123 char * d = (char *)v->Data();
4124 char * s = (char *)omAlloc(strlen(d) + 13);
4125 strcpy( s, (char *)d);
4126 strcat( s, "\n;RETURN();\n");
4128 return yyparse();
4129}
void newBuffer(char *s, feBufferTypes t, procinfo *pi, int lineno)
Definition: fevoices.cc:166
@ BT_execute
Definition: fevoices.h:23
int yyparse(void)
Definition: grammar.cc:2111

◆ jjEXPORTTO()

static BOOLEAN jjEXPORTTO ( leftv  ,
leftv  u,
leftv  v 
)
static

Definition at line 1978 of file iparith.cc.

1979{
1980 //Print("exportto %s -> %s\n",v->Name(),u->Name() );
1981 return iiExport(v,0,IDPACKAGE((idhdl)u->data));
1982}
BOOLEAN iiExport(leftv v, int toLev)
Definition: ipshell.cc:1511

◆ jjEXTGCD_BI()

static BOOLEAN jjEXTGCD_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1990 of file iparith.cc.

1991{
1992 number uu=(number)u->Data();number vv=(number)v->Data();
1994 number a,b;
1995 number p0=n_ExtGcd(uu,vv,&a,&b,coeffs_BIGINT);
1996 L->Init(3);
1997 L->m[0].rtyp=BIGINT_CMD; L->m[0].data=(void *)p0;
1998 L->m[1].rtyp=BIGINT_CMD; L->m[1].data=(void *)a;
1999 L->m[2].rtyp=BIGINT_CMD; L->m[2].data=(void *)b;
2000 res->rtyp=LIST_CMD;
2001 res->data=(char *)L;
2002 return FALSE;
2003}
static FORCE_INLINE number n_ExtGcd(number a, number b, number *s, number *t, const coeffs r)
beware that ExtGCD is only relevant for a few chosen coeff. domains and may perform something unexpec...
Definition: coeffs.h:671

◆ jjEXTGCD_I()

static BOOLEAN jjEXTGCD_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2004 of file iparith.cc.

2005{
2006 int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
2007 int p0=ABS(uu),p1=ABS(vv);
2008 int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
2009
2010 while ( p1!=0 )
2011 {
2012 q=p0 / p1;
2013 r=p0 % p1;
2014 p0 = p1; p1 = r;
2015 r = g0 - g1 * q;
2016 g0 = g1; g1 = r;
2017 r = f0 - f1 * q;
2018 f0 = f1; f1 = r;
2019 }
2020 int a = f0;
2021 int b = g0;
2022 if ( uu /*(int)(long)u->Data()*/ < 0 ) a=-a;
2023 if ( vv /*(int)(long)v->Data()*/ < 0 ) b=-b;
2025 L->Init(3);
2026 L->m[0].rtyp=INT_CMD; L->m[0].data=(void *)(long)p0;
2027 L->m[1].rtyp=INT_CMD; L->m[1].data=(void *)(long)a;
2028 L->m[2].rtyp=INT_CMD; L->m[2].data=(void *)(long)b;
2029 res->data=(char *)L;
2030 return FALSE;
2031}
static int ABS(int v)
Definition: auxiliary.h:112

◆ jjEXTGCD_P()

static BOOLEAN jjEXTGCD_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2032 of file iparith.cc.

2033{
2034 poly r,pa,pb;
2035 BOOLEAN ret=singclap_extgcd((poly)u->Data(),(poly)v->Data(),r,pa,pb,currRing);
2036 if (ret) return TRUE;
2038 L->Init(3);
2039 res->data=(char *)L;
2040 L->m[0].data=(void *)r;
2041 L->m[0].rtyp=POLY_CMD;
2042 L->m[1].data=(void *)pa;
2043 L->m[1].rtyp=POLY_CMD;
2044 L->m[2].data=(void *)pb;
2045 L->m[2].rtyp=POLY_CMD;
2046 return FALSE;
2047}
BOOLEAN singclap_extgcd(poly f, poly g, poly &res, poly &pa, poly &pb, const ring r)
Definition: clapsing.cc:489
BOOLEAN pb(leftv res, leftv args)
Definition: cohomo.cc:4350

◆ jjFAC_P()

static BOOLEAN jjFAC_P ( leftv  res,
leftv  u 
)
static

Definition at line 4170 of file iparith.cc.

4171{
4172 intvec *v=NULL;
4174 ideal f=singclap_factorize((poly)(u->CopyD()), &v, 0,currRing);
4175 if (f==NULL) return TRUE;
4176 ivTest(v);
4178 l->Init(2);
4179 l->m[0].rtyp=IDEAL_CMD;
4180 l->m[0].data=(void *)f;
4181 l->m[1].rtyp=INTVEC_CMD;
4182 l->m[1].data=(void *)v;
4183 res->data=(void *)l;
4184 return FALSE;
4185}
FILE * f
Definition: checklibs.c:9
ideal singclap_factorize(poly f, intvec **v, int with_exps, const ring r)
Definition: clapsing.cc:948
#define ivTest(v)
Definition: intvec.h:169
EXTERN_VAR int singclap_factorize_retry
Definition: iparith.cc:2048

◆ jjFAC_P2()

static BOOLEAN jjFAC_P2 ( leftv  res,
leftv  u,
leftv  dummy 
)
static

Definition at line 2049 of file iparith.cc.

2050{
2051 intvec *v=NULL;
2052 int sw=(int)(long)dummy->Data();
2053 int fac_sw=sw;
2054 if ((sw<0)||(sw>2)) fac_sw=1;
2056 ideal f=singclap_factorize((poly)(u->CopyD()), &v, fac_sw,currRing);
2057 if (f==NULL)
2058 return TRUE;
2059 switch(sw)
2060 {
2061 case 0:
2062 case 2:
2063 {
2065 l->Init(2);
2066 l->m[0].rtyp=IDEAL_CMD;
2067 l->m[0].data=(void *)f;
2068 l->m[1].rtyp=INTVEC_CMD;
2069 l->m[1].data=(void *)v;
2070 res->data=(void *)l;
2071 res->rtyp=LIST_CMD;
2072 return FALSE;
2073 }
2074 case 1:
2075 res->data=(void *)f;
2076 return FALSE;
2077 case 3:
2078 {
2079 poly p=f->m[0];
2080 int i=IDELEMS(f);
2081 f->m[0]=NULL;
2082 while(i>1)
2083 {
2084 i--;
2085 p=pMult(p,f->m[i]);
2086 f->m[i]=NULL;
2087 }
2088 res->data=(void *)p;
2089 res->rtyp=POLY_CMD;
2090 }
2091 return FALSE;
2092 }
2093 WerrorS("invalid switch");
2094 return TRUE;
2095}
#define pMult(p, q)
Definition: polys.h:207

◆ jjFACSTD()

static BOOLEAN jjFACSTD ( leftv  res,
leftv  v 
)
static

Definition at line 4130 of file iparith.cc.

4131{
4133 if (currRing->cf->convSingNFactoryN!=ndConvSingNFactoryN) /* conversion to factory*/
4134 {
4135 ideal_list p,h;
4136 h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL);
4137 if (h==NULL)
4138 {
4139 L->Init(1);
4140 L->m[0].data=(char *)idInit(1);
4141 L->m[0].rtyp=IDEAL_CMD;
4142 }
4143 else
4144 {
4145 p=h;
4146 int l=0;
4147 while (p!=NULL) { p=p->next;l++; }
4148 L->Init(l);
4149 l=0;
4150 while(h!=NULL)
4151 {
4152 L->m[l].data=(char *)h->d;
4153 L->m[l].rtyp=IDEAL_CMD;
4154 p=h->next;
4155 omFreeSize(h,sizeof(*h));
4156 h=p;
4157 l++;
4158 }
4159 }
4160 }
4161 else
4162 {
4163 WarnS("no factorization implemented");
4164 L->Init(1);
4165 iiExprArith1(&(L->m[0]),v,STD_CMD);
4166 }
4167 res->data=(void *)L;
4168 return FALSE;
4169}
ideal_list kStdfac(ideal F, ideal Q, tHomog h, intvec **w, ideal D)
Definition: kstdfac.cc:798
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
Definition: numbers.cc:303
@ testHomog
Definition: structs.h:38
@ STD_CMD
Definition: tok.h:184

◆ jjFACSTD2()

static BOOLEAN jjFACSTD2 ( leftv  res,
leftv  v,
leftv  w 
)
static

Definition at line 2096 of file iparith.cc.

2097{
2098 ideal_list p,h;
2099 h=kStdfac((ideal)v->Data(),NULL,testHomog,NULL,(ideal)w->Data());
2100 p=h;
2101 int l=0;
2102 while (p!=NULL) { p=p->next;l++; }
2104 L->Init(l);
2105 l=0;
2106 while(h!=NULL)
2107 {
2108 L->m[l].data=(char *)h->d;
2109 L->m[l].rtyp=IDEAL_CMD;
2110 p=h->next;
2111 omFreeSize(h,sizeof(*h));
2112 h=p;
2113 l++;
2114 }
2115 res->data=(void *)L;
2116 return FALSE;
2117}

◆ jjFactModD_M()

static BOOLEAN jjFactModD_M ( leftv  res,
leftv  v 
)
static

Definition at line 8386 of file iparith.cc.

8387{
8388 /* compute two factors of h(x,y) modulo x^(d+1) in K[[x]][y],
8389 see a detailed documentation in /kernel/linear_algebra/linearAlgebra.h
8390
8391 valid argument lists:
8392 - (poly h, int d),
8393 - (poly h, int d, poly f0, poly g0), optional: factors of h(0,y),
8394 - (poly h, int d, int xIndex, int yIndex), optional: indices of vars x & y
8395 in list of ring vars,
8396 - (poly h, int d, poly f0, poly g0, int xIndex, int yIndec),
8397 optional: all 4 optional args
8398 (The defaults are xIndex = 1, yIndex = 2, f0 and g0 polynomials as found
8399 by singclap_factorize and h(0, y)
8400 has exactly two distinct monic factors [possibly with exponent > 1].)
8401 result:
8402 - list with the two factors f and g such that
8403 h(x,y) = f(x,y)*g(x,y) mod x^(d+1) */
8404
8405 poly h = NULL;
8406 int d = 1;
8407 poly f0 = NULL;
8408 poly g0 = NULL;
8409 int xIndex = 1; /* default index if none provided */
8410 int yIndex = 2; /* default index if none provided */
8411
8412 leftv u = v; int factorsGiven = 0;
8413 if ((u == NULL) || (u->Typ() != POLY_CMD))
8414 {
8415 WerrorS("expected arguments (poly, int [, poly, poly] [, int, int])");
8416 return TRUE;
8417 }
8418 else h = (poly)u->Data();
8419 u = u->next;
8420 if ((u == NULL) || (u->Typ() != INT_CMD))
8421 {
8422 WerrorS("expected arguments (poly, int [, poly, poly] [, int, int])");
8423 return TRUE;
8424 }
8425 else d = (int)(long)u->Data();
8426 u = u->next;
8427 if ((u != NULL) && (u->Typ() == POLY_CMD))
8428 {
8429 if ((u->next == NULL) || (u->next->Typ() != POLY_CMD))
8430 {
8431 WerrorS("expected arguments (poly, int [, poly, poly] [, int, int])");
8432 return TRUE;
8433 }
8434 else
8435 {
8436 f0 = (poly)u->Data();
8437 g0 = (poly)u->next->Data();
8438 factorsGiven = 1;
8439 u = u->next->next;
8440 }
8441 }
8442 if ((u != NULL) && (u->Typ() == INT_CMD))
8443 {
8444 if ((u->next == NULL) || (u->next->Typ() != INT_CMD))
8445 {
8446 WerrorS("expected arguments (poly, int [, poly, poly] [, int, int])");
8447 return TRUE;
8448 }
8449 else
8450 {
8451 xIndex = (int)(long)u->Data();
8452 yIndex = (int)(long)u->next->Data();
8453 u = u->next->next;
8454 }
8455 }
8456 if (u != NULL)
8457 {
8458 WerrorS("expected arguments (poly, int [, poly, poly] [, int, int])");
8459 return TRUE;
8460 }
8461
8462 /* checks for provided arguments */
8463 if (pIsConstant(h) || (factorsGiven && (pIsConstant(f0) || pIsConstant(g0))))
8464 {
8465 WerrorS("expected non-constant polynomial argument(s)");
8466 return TRUE;
8467 }
8468 int n = rVar(currRing);
8469 if ((xIndex < 1) || (n < xIndex))
8470 {
8471 Werror("index for variable x (%d) out of range [1..%d]", xIndex, n);
8472 return TRUE;
8473 }
8474 if ((yIndex < 1) || (n < yIndex))
8475 {
8476 Werror("index for variable y (%d) out of range [1..%d]", yIndex, n);
8477 return TRUE;
8478 }
8479 if (xIndex == yIndex)
8480 {
8481 WerrorS("expected distinct indices for variables x and y");
8482 return TRUE;
8483 }
8484
8485 /* computation of f0 and g0 if missing */
8486 if (factorsGiven == 0)
8487 {
8488 poly h0 = pSubst(pCopy(h), xIndex, NULL);
8489 intvec* v = NULL;
8490 ideal i = singclap_factorize(h0, &v, 0,currRing);
8491
8492 ivTest(v);
8493
8494 if (i == NULL) return TRUE;
8495
8496 idTest(i);
8497
8498 if ((v->rows() != 3) || ((*v)[0] =! 1) || (!nIsOne(pGetCoeff(i->m[0]))))
8499 {
8500 WerrorS("expected h(0,y) to have exactly two distinct monic factors");
8501 return TRUE;
8502 }
8503 f0 = pPower(pCopy(i->m[1]), (*v)[1]);
8504 g0 = pPower(pCopy(i->m[2]), (*v)[2]);
8505 idDelete(&i);
8506 }
8507
8508 poly f; poly g;
8509 henselFactors(xIndex, yIndex, h, f0, g0, d, f, g);
8511 L->Init(2);
8512 L->m[0].rtyp = POLY_CMD; L->m[0].data=(void*)f;
8513 L->m[1].rtyp = POLY_CMD; L->m[1].data=(void*)g;
8514 res->rtyp = LIST_CMD;
8515 res->data = (char*)L;
8516 return FALSE;
8517}
g
Definition: cfModGcd.cc:4090
#define idTest(id)
Definition: ideals.h:47
VAR idhdl h0
Definition: libparse.cc:1143
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,...
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
#define nIsOne(n)
Definition: numbers.h:25
#define pIsConstant(p)
like above, except that Comp must be 0
Definition: polys.h:238
#define pPower(p, q)
Definition: polys.h:204
#define pSubst(p, n, e)
Definition: polys.h:366

◆ jjFAREY_BI()

static BOOLEAN jjFAREY_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2118 of file iparith.cc.

2119{
2120 if (rField_is_Q(currRing))
2121 {
2122 number uu=(number)u->Data();
2123 number vv=(number)v->Data();
2124 res->data=(char *)n_Farey(uu,vv,currRing->cf);
2125 return FALSE;
2126 }
2127 else return TRUE;
2128}
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
Definition: coeffs.h:767

◆ jjFAREY_ID()

static BOOLEAN jjFAREY_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2129 of file iparith.cc.

2130{
2131 ideal uu=(ideal)u->Data();
2132 number vv=(number)v->Data();
2133 //timespec buf1,buf2;
2134 //clock_gettime(CLOCK_THREAD_CPUTIME_ID,&buf1);
2135 #if 1
2136 #ifdef HAVE_VSPACE
2137 int cpus = (long) feOptValue(FE_OPT_CPUS);
2138 if ((cpus>1) && (rField_is_Q(currRing)))
2139 res->data=(void*)id_Farey_0(uu,vv,currRing);
2140 else
2141 #endif
2142 #endif
2143 res->data=(void*)id_Farey(uu,vv,currRing);
2144 //clock_gettime(CLOCK_THREAD_CPUTIME_ID,&buf2);
2145 //const unsigned long SEC = 1000L*1000L*1000L;
2146 //all_farey+=((buf2.tv_sec-buf1.tv_sec)*SEC+
2147 // buf2.tv_nsec-buf1.tv_nsec);
2148 //farey_cnt++;
2149 return FALSE;
2150}
ideal id_Farey(ideal x, number N, const ring r)
Definition: ideals.cc:2848
ideal id_Farey_0(ideal x, number N, const ring r)
Definition: kChinese.cc:298

◆ jjFAREY_LI()

static BOOLEAN jjFAREY_LI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 10153 of file iparith.cc.

10154{
10155 lists c=(lists)u->CopyD();
10157 res_l->Init(c->nr+1);
10158 BOOLEAN bo=FALSE;
10159 int tab_pos=iiTabIndex(dArithTab2,JJTAB2LEN,FAREY_CMD);
10160 for (unsigned i=0;i<=(unsigned)c->nr;i++)
10161 {
10162 sleftv tmp;
10163 tmp.Copy(v);
10164 bo=iiExprArith2TabIntern(&res_l->m[i],&c->m[i],FAREY_CMD,&tmp,TRUE,dArith2+tab_pos,c->m[i].rtyp,tmp.rtyp,dConvertTypes);
10165 if (bo) { Werror("farey failed for list entry %d",i+1); break;}
10166 }
10167 c->Clean();
10168 res->data=res_l;
10169 return bo;
10170}
@ FAREY_CMD
Definition: tok.h:77

◆ jjFETCH()

static BOOLEAN jjFETCH ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2152 of file iparith.cc.

2153{
2154 ring r=(ring)u->Data();
2155 idhdl w;
2156 int op=iiOp;
2157 nMapFunc nMap;
2158
2159 if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
2160 {
2161 int *perm=NULL;
2162 int *par_perm=NULL;
2163 int par_perm_size=0;
2164 BOOLEAN bo;
2165 nMap=n_SetMap(r->cf,currRing->cf);
2166 if (nMap==NULL)
2167 {
2168 // Allow imap/fetch to be make an exception only for:
2169 if (nCoeff_is_Extension(r->cf) && // Q(a..) -> Q(a..) || Q || Zp || Zp(a)
2170 ((n_SetMap(r->cf->extRing->cf,currRing->cf)!=NULL)
2171 || (nCoeff_is_Extension(currRing->cf) && (n_SetMap(r->cf->extRing->cf,currRing->cf->extRing->cf)!=NULL))))
2172 {
2173 par_perm_size=rPar(r);
2174 }
2175 else
2176 {
2177 goto err_fetch;
2178 }
2179 }
2180 if (
2181 (iiOp!=FETCH_CMD) || (r->N!=currRing->N) || (rPar(r)!=rPar(currRing))
2182#ifdef HAVE_SHIFTBBA
2184#endif
2185 )
2186 {
2187 perm=(int *)omAlloc0((r->N+1)*sizeof(int));
2188 if (par_perm_size!=0)
2189 par_perm=(int *)omAlloc0(par_perm_size*sizeof(int));
2190 op=IMAP_CMD;
2191 if (iiOp==IMAP_CMD)
2192 {
2193 int r_par=0;
2194 char ** r_par_names=NULL;
2195 if (r->cf->extRing!=NULL)
2196 {
2197 r_par=r->cf->extRing->N;
2198 r_par_names=r->cf->extRing->names;
2199 }
2200 int c_par=0;
2201 char ** c_par_names=NULL;
2202 if (currRing->cf->extRing!=NULL)
2203 {
2204 c_par=currRing->cf->extRing->N;
2205 c_par_names=currRing->cf->extRing->names;
2206 }
2207 if (!rIsLPRing(r))
2208 {
2209 maFindPerm(r->names, r->N, r_par_names, r_par,
2210 currRing->names,currRing->N,c_par_names, c_par,
2211 perm,par_perm, currRing->cf->type);
2212 }
2213 #ifdef HAVE_SHIFTBBA
2214 else
2215 {
2216 maFindPermLP(r->names, r->N, r_par_names, r_par,
2217 currRing->names,currRing->N,c_par_names, c_par,
2218 perm,par_perm, currRing->cf->type,r->isLPring);
2219 }
2220 #endif
2221 }
2222 else
2223 {
2224#ifdef HAVE_SHIFTBBA
2225 if (rIsLPRing(currRing))
2226 {
2227 maFetchPermLP(r, currRing, perm);
2228 }
2229 else
2230#endif
2231 {
2232 unsigned i;
2233 if (par_perm_size!=0)
2234 for(i=si_min(rPar(r),rPar(currRing));i>0;i--) par_perm[i-1]=-i;
2235 for(i=si_min(r->N,currRing->N);i>0;i--) perm[i]=i;
2236 }
2237 }
2238 }
2239 if ((iiOp==FETCH_CMD) && (BVERBOSE(V_IMAP)))
2240 {
2241 unsigned i;
2242 for(i=0;i<(unsigned)si_min(r->N,currRing->N);i++)
2243 {
2244 Print("// var nr %d: %s -> %s\n",i,r->names[i],currRing->names[i]);
2245 }
2246 for(i=0;i<(unsigned)si_min(rPar(r),rPar(currRing));i++) // possibly empty loop
2247 {
2248 Print("// par nr %d: %s -> %s\n",
2250 }
2251 }
2252 if (IDTYP(w)==ALIAS_CMD) w=(idhdl)IDDATA(w);
2253 sleftv tmpW;
2254 tmpW.Init();
2255 tmpW.rtyp=IDTYP(w);
2256 tmpW.data=IDDATA(w);
2257 if ((bo=maApplyFetch(op,NULL,res,&tmpW, r,
2258 perm,par_perm,par_perm_size,nMap)))
2259 {
2260 Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
2261 }
2262 if (perm!=NULL)
2263 omFreeSize((ADDRESS)perm,(r->N+1)*sizeof(int));
2264 if (par_perm!=NULL)
2265 omFreeSize((ADDRESS)par_perm,par_perm_size*sizeof(int));
2266 return bo;
2267 }
2268 else
2269 {
2270 Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
2271 }
2272 return TRUE;
2273err_fetch:
2274 char *s1=nCoeffString(r->cf);
2275 char *s2=nCoeffString(currRing->cf);
2276 Werror("no identity map from %s (%s -> %s)",u->Fullname(),s1,s2);
2277 omFree(s2); omFree(s1);
2278 return TRUE;
2279}
static int si_min(const int a, const int b)
Definition: auxiliary.h:125
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition: coeffs.h:959
@ IMAP_CMD
Definition: grammar.cc:298
@ FETCH_CMD
Definition: grammar.cc:295
#define IDDATA(a)
Definition: ipid.h:126
#define IDTYP(a)
Definition: ipid.h:119
void maFetchPermLP(const ring preimage_r, const ring dst_r, int *perm)
Definition: maps.cc:306
void maFindPerm(char const *const *const preim_names, int preim_n, char const *const *const preim_par, int preim_p, char const *const *const names, int n, char const *const *const par, int nop, int *perm, int *par_perm, n_coeffType ch)
Definition: maps.cc:163
void maFindPermLP(char const *const *const preim_names, int preim_n, char const *const *const preim_par, int preim_p, char const *const *const names, int n, char const *const *const par, int nop, int *perm, int *par_perm, n_coeffType ch, int lV)
Definition: maps.cc:231
BOOLEAN maApplyFetch(int what, map theMap, leftv res, leftv w, ring preimage_r, int *perm, int *par_perm, int P, nMapFunc nMap)
Definition: maps_ip.cc:45
#define omAlloc0(size)
Definition: omAllocDecl.h:211
#define V_IMAP
Definition: options.h:53
static int rPar(const ring r)
(r->cf->P)
Definition: ring.h:600
static char const ** rParameter(const ring r)
(r->cf->parameter)
Definition: ring.h:626
@ ALIAS_CMD
Definition: tok.h:34

◆ jjFETCH_M()

static BOOLEAN jjFETCH_M ( leftv  res,
leftv  u 
)
static

Definition at line 7328 of file iparith.cc.

7329{
7330 ring r=(ring)u->Data();
7331 leftv v=u->next;
7332 leftv perm_var_l=v->next;
7333 leftv perm_par_l=v->next->next;
7334 if ((perm_var_l->Typ()!=INTVEC_CMD)
7335 ||((perm_par_l!=NULL)&&(perm_par_l->Typ()!=INTVEC_CMD))
7336 ||(u->Typ()!=RING_CMD))
7337 {
7338 WerrorS("fetch(<ring>,<name>[,<intvec>[,<intvec>])");
7339 return TRUE;
7340 }
7341 intvec *perm_var_v=(intvec*)perm_var_l->Data();
7342 intvec *perm_par_v=NULL;
7343 if (perm_par_l!=NULL)
7344 perm_par_v=(intvec*)perm_par_l->Data();
7345 idhdl w;
7346 nMapFunc nMap;
7347
7348 if ((w=r->idroot->get(v->Name(),myynest))!=NULL)
7349 {
7350 int *perm=NULL;
7351 int *par_perm=NULL;
7352 int par_perm_size=0;
7353 BOOLEAN bo;
7354 if ((nMap=n_SetMap(r->cf,currRing->cf))==NULL)
7355 {
7356 // Allow imap/fetch to be make an exception only for:
7357 if (nCoeff_is_Extension(r->cf) && // Q(a..) -> Q(a..) || Q || Zp || Zp(a)
7358 ((n_SetMap(r->cf->extRing->cf,currRing->cf)!=NULL)
7359 || (nCoeff_is_Extension(currRing->cf) && (n_SetMap(r->cf->extRing->cf,currRing->cf->extRing->cf)!=NULL))))
7360 {
7361 par_perm_size=rPar(r);
7362 }
7363 else
7364 {
7365 goto err_fetch;
7366 }
7367 }
7368 else
7369 par_perm_size=rPar(r);
7370 perm=(int *)omAlloc0((rVar(r)+1)*sizeof(int));
7371 if (par_perm_size!=0)
7372 par_perm=(int *)omAlloc0(par_perm_size*sizeof(int));
7373 int i;
7374 if (perm_par_l==NULL)
7375 {
7376 if (par_perm_size!=0)
7377 for(i=si_min(rPar(r),rPar(currRing))-1;i>=0;i--) par_perm[i]=-(i+1);
7378 }
7379 else
7380 {
7381 if (par_perm_size==0) WarnS("source ring has no parameters");
7382 else
7383 {
7384 for(i=rPar(r)-1;i>=0;i--)
7385 {
7386 if (i<perm_par_v->length()) par_perm[i]=(*perm_par_v)[i];
7387 if ((par_perm[i]<-rPar(currRing))
7388 || (par_perm[i]>rVar(currRing)))
7389 {
7390 Warn("invalid entry for par %d: %d\n",i,par_perm[i]);
7391 par_perm[i]=0;
7392 }
7393 }
7394 }
7395 }
7396 for(i=rVar(r)-1;i>=0;i--)
7397 {
7398 if (i<perm_var_v->length()) perm[i+1]=(*perm_var_v)[i];
7399 if ((perm[i]<-rPar(currRing))
7400 || (perm[i]>rVar(currRing)))
7401 {
7402 Warn("invalid entry for var %d: %d\n",i,perm[i]);
7403 perm[i]=0;
7404 }
7405 }
7406 if (BVERBOSE(V_IMAP))
7407 {
7408 for(i=1;i<=si_min(rVar(r),rVar(currRing));i++)
7409 {
7410 if (perm[i]>0)
7411 Print("// var nr %d: %s -> var %s\n",i,r->names[i-1],currRing->names[perm[i]-1]);
7412 else if (perm[i]<0)
7413 Print("// var nr %d: %s -> par %s\n",i,r->names[i-1],rParameter(currRing)[-perm[i]-1]);
7414 }
7415 for(i=1;i<=si_min(rPar(r),rPar(currRing));i++) // possibly empty loop
7416 {
7417 if (par_perm[i-1]<0)
7418 Print("// par nr %d: %s -> par %s\n",
7419 i,rParameter(r)[i-1],rParameter(currRing)[-par_perm[i-1]-1]);
7420 else if (par_perm[i-1]>0)
7421 Print("// par nr %d: %s -> var %s\n",
7422 i,rParameter(r)[i-1],currRing->names[par_perm[i-1]-1]);
7423 }
7424 }
7425 if (IDTYP(w)==ALIAS_CMD) w=(idhdl)IDDATA(w);
7426 sleftv tmpW;
7427 tmpW.Init();
7428 tmpW.rtyp=IDTYP(w);
7429 tmpW.data=IDDATA(w);
7430 if ((bo=maApplyFetch(IMAP_CMD,NULL,res,&tmpW, r,
7431 perm,par_perm,par_perm_size,nMap)))
7432 {
7433 Werror("cannot map %s of type %s(%d)",v->name, Tok2Cmdname(w->typ),w->typ);
7434 }
7435 if (perm!=NULL)
7436 omFreeSize((ADDRESS)perm,(rVar(r)+1)*sizeof(int));
7437 if (par_perm!=NULL)
7438 omFreeSize((ADDRESS)par_perm,par_perm_size*sizeof(int));
7439 return bo;
7440 }
7441 else
7442 {
7443 Werror("identifier %s not found in %s",v->Fullname(),u->Fullname());
7444 }
7445 return TRUE;
7446err_fetch:
7447 char *s1=nCoeffString(r->cf);
7448 char *s2=nCoeffString(currRing->cf);
7449 Werror("no identity map from %s (%s -> %s)",u->Fullname(),s1,s2);
7451 return TRUE;
7452}
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:257

◆ jjFIND2()

static BOOLEAN jjFIND2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2280 of file iparith.cc.

2281{
2282 /*4
2283 * look for the substring what in the string where
2284 * return the position of the first char of what in where
2285 * or 0
2286 */
2287 char *where=(char *)u->Data();
2288 char *what=(char *)v->Data();
2289 char *found = strstr(where,what);
2290 if (found != NULL)
2291 {
2292 res->data=(char *)((found-where)+1);
2293 }
2294 /*else res->data=NULL;*/
2295 return FALSE;
2296}
bool found
Definition: facFactorize.cc:55

◆ jjFIND3()

static BOOLEAN jjFIND3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6083 of file iparith.cc.

6084{
6085 /*4
6086 * look for the substring what in the string where
6087 * starting at position n
6088 * return the position of the first char of what in where
6089 * or 0
6090 */
6091 int n=(int)(long)w->Data();
6092 char *where=(char *)u->Data();
6093 char *what=(char *)v->Data();
6094 char *found;
6095 if ((1>n)||(n>(int)strlen(where)))
6096 {
6097 Werror("start position %d out of range",n);
6098 return TRUE;
6099 }
6100 found = strchr(where+n-1,*what);
6101 if (*(what+1)!='\0')
6102 {
6103 while((found !=NULL) && (strncmp(found+1,what+1,strlen(what+1))!=0))
6104 {
6105 found=strchr(found+1,*what);
6106 }
6107 }
6108 if (found != NULL)
6109 {
6110 res->data=(char *)((found-where)+1);
6111 }
6112 return FALSE;
6113}

◆ jjFRES()

static BOOLEAN jjFRES ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2335 of file iparith.cc.

2336{
2338 w->rtyp = STRING_CMD;
2339 w->data = (char *)"complete"; // default
2340 BOOLEAN RES = jjFRES3(res, u, v, w);
2342 return RES;
2343}
static BOOLEAN jjFRES3(leftv res, leftv u, leftv v, leftv w)
Definition: iparith.cc:2298

◆ jjFRES3()

static BOOLEAN jjFRES3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 2298 of file iparith.cc.

2299{
2300 assumeStdFlag(u);
2301 ideal id = (ideal)u->Data();
2302 int max_length = (int)(long)v->Data();
2303 if (max_length < 0)
2304 {
2305 WerrorS("length for fres must not be negative");
2306 return TRUE;
2307 }
2308 if (max_length == 0)
2309 {
2310 max_length = currRing->N+1;
2311 if (currRing->qideal != NULL)
2312 {
2313 Warn("full resolution in a qring may be infinite, "
2314 "setting max length to %d", max_length);
2315 }
2316 }
2317 char *method = (char *)w->Data();
2318 /* For the moment, only "complete" (default), "frame", or "extended frame"
2319 * are allowed. Another useful option would be "linear strand".
2320 */
2321 if (strcmp(method, "complete") != 0
2322 && strcmp(method, "frame") != 0
2323 && strcmp(method, "extended frame") != 0
2324 && strcmp(method, "single module") != 0)
2325 {
2326 WerrorS("wrong optional argument for fres");
2327 return TRUE;
2328 }
2329 syStrategy r = syFrank(id, max_length, method);
2330 assume(r->fullres != NULL);
2331 res->data = (void *)r;
2332 return FALSE;
2333}
resolvente fullres
Definition: syz.h:57
syStrategy syFrank(const ideal arg, const int length, const char *method, const bool use_cache=true, const bool use_tensor_trick=false)
Definition: syz4.cc:792

◆ jjFWALK()

static BOOLEAN jjFWALK ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2345 of file iparith.cc.

2346{
2347 res->data=(char *)fractalWalkProc(u,v);
2348 setFlag( res, FLAG_STD );
2349 return FALSE;
2350}
#define setFlag(A, F)
Definition: ipid.h:113
ideal fractalWalkProc(leftv first, leftv second)
Definition: walk_ip.cc:161

◆ jjFWALK3()

static BOOLEAN jjFWALK3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6114 of file iparith.cc.

6115{
6116 if ((int)(long)w->Data()==0)
6117 res->data=(char *)walkProc(u,v);
6118 else
6119 res->data=(char *)fractalWalkProc(u,v);
6120 setFlag( res, FLAG_STD );
6121 return FALSE;
6122}
ideal walkProc(leftv first, leftv second)
Definition: walk_ip.cc:55

◆ jjGCD_BI()

static BOOLEAN jjGCD_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2364 of file iparith.cc.

2365{
2366 number n1 = (number) u->Data();
2367 number n2 = (number) v->Data();
2368 res->data = n_Gcd(n1,n2,coeffs_BIGINT);
2369 return FALSE;
2370}
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of 'a' and 'b' in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ,...
Definition: coeffs.h:664

◆ jjGCD_I()

static BOOLEAN jjGCD_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2351 of file iparith.cc.

2352{
2353 int uu=(int)(long)u->Data();int vv=(int)(long)v->Data();
2354 int p0=ABS(uu),p1=ABS(vv);
2355 int r;
2356 while ( p1!=0 )
2357 {
2358 r=p0 % p1;
2359 p0 = p1; p1 = r;
2360 }
2361 res->data=(char *)(long)p0;
2362 return FALSE;
2363}

◆ jjGCD_N()

static BOOLEAN jjGCD_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2371 of file iparith.cc.

2372{
2373 number a=(number) u->Data();
2374 number b=(number) v->Data();
2375 if (nIsZero(a))
2376 {
2377 if (nIsZero(b)) res->data=(char *)nInit(1);
2378 else res->data=(char *)nCopy(b);
2379 }
2380 else
2381 {
2382 if (nIsZero(b)) res->data=(char *)nCopy(a);
2383 //else res->data=(char *)n_Gcd(a, b, currRing->cf);
2384 else res->data=(char *)n_SubringGcd(a, b, currRing->cf);
2385 }
2386 return FALSE;
2387}
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
Definition: coeffs.h:666
#define nCopy(n)
Definition: numbers.h:15
#define nInit(i)
Definition: numbers.h:24

◆ jjGCD_P()

static BOOLEAN jjGCD_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2388 of file iparith.cc.

2389{
2390 res->data=(void *)singclap_gcd((poly)(u->CopyD(POLY_CMD)),
2391 (poly)(v->CopyD(POLY_CMD)),currRing);
2392 return FALSE;
2393}
poly singclap_gcd(poly f, poly g, const ring r)
polynomial gcd via singclap_gcd_r resp. idSyzygies destroys f and g
Definition: polys.cc:380

◆ jjGE_BI()

static BOOLEAN jjGE_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1170 of file iparith.cc.

1171{
1172 number h=n_Sub((number)u->Data(),(number)v->Data(),coeffs_BIGINT);
1173 res->data = (char *) (n_GreaterZero(h,coeffs_BIGINT)||(n_IsZero(h,coeffs_BIGINT)));
1175 return FALSE;
1176}
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2),...
Definition: coeffs.h:494
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
Definition: coeffs.h:655

◆ jjGE_I()

static BOOLEAN jjGE_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1177 of file iparith.cc.

1178{
1179 res->data = (char *)(long)((int)((long)u->Data()) >= (int)((long)v->Data()));
1180 return FALSE;
1181}

◆ jjGE_N()

static BOOLEAN jjGE_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1182 of file iparith.cc.

1183{
1184 res->data = (char *)(long) (nGreater((number)u->Data(),(number)v->Data())
1185 || nEqual((number)u->Data(),(number)v->Data()));
1186 return FALSE;
1187}
#define nGreater(a, b)
Definition: numbers.h:28

◆ jjGETDUMP()

static BOOLEAN jjGETDUMP ( leftv  ,
leftv  v 
)
static

Definition at line 4186 of file iparith.cc.

4187{
4188 si_link l = (si_link)v->Data();
4189 if (slGetDump(l))
4190 {
4191 const char *s;
4192 if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
4193 else s=sNoName_fe;
4194 Werror("cannot get dump from `%s`",s);
4195 return TRUE;
4196 }
4197 else
4198 return FALSE;
4199}

◆ jjGT_BI()

static BOOLEAN jjGT_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1188 of file iparith.cc.

1189{
1190 number h=n_Sub((number)u->Data(),(number)v->Data(),coeffs_BIGINT);
1191 res->data = (char *)(long) (n_GreaterZero(h,coeffs_BIGINT)&&(!n_IsZero(h,coeffs_BIGINT)));
1193 return FALSE;
1194}

◆ jjGT_I()

static BOOLEAN jjGT_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1195 of file iparith.cc.

1196{
1197 res->data = (char *)(long)((int)((long)u->Data()) > (int)((long)v->Data()));
1198 return FALSE;
1199}

◆ jjGT_N()

static BOOLEAN jjGT_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1200 of file iparith.cc.

1201{
1202 res->data = (char *)(long)(nGreater((number)u->Data(),(number)v->Data()));
1203 return FALSE;
1204}

◆ jjHIGHCORNER()

static BOOLEAN jjHIGHCORNER ( leftv  res,
leftv  v 
)
static

Definition at line 4200 of file iparith.cc.

4201{
4203 ideal I=(ideal)v->Data();
4204 res->data=(void *)iiHighCorner(I,0);
4205 return FALSE;
4206}
poly iiHighCorner(ideal I, int ak)
Definition: ipshell.cc:1606

◆ jjHIGHCORNER_M()

static BOOLEAN jjHIGHCORNER_M ( leftv  res,
leftv  v 
)
static

Definition at line 4207 of file iparith.cc.

4208{
4210 intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
4211 BOOLEAN delete_w=FALSE;
4212 ideal I=(ideal)v->Data();
4213 int i;
4214 poly p=NULL,po=NULL;
4215 int rk=id_RankFreeModule(I,currRing);
4216 if (w==NULL)
4217 {
4218 w = new intvec(rk);
4219 delete_w=TRUE;
4220 }
4221 for(i=rk;i>0;i--)
4222 {
4223 p=iiHighCorner(I,i);
4224 if (p==NULL)
4225 {
4226 WerrorS("module must be zero-dimensional");
4227 if (delete_w) delete w;
4228 return TRUE;
4229 }
4230 if (po==NULL)
4231 {
4232 po=p;
4233 }
4234 else
4235 {
4236 // now po!=NULL, p!=NULL
4237 int d=(currRing->pFDeg(po,currRing)-(*w)[pGetComp(po)-1] - currRing->pFDeg(p,currRing)+(*w)[i-1]);
4238 if (d==0)
4239 d=pLmCmp(po,p);
4240 if (d > 0)
4241 {
4242 pDelete(&p);
4243 }
4244 else // (d < 0)
4245 {
4246 pDelete(&po); po=p;
4247 }
4248 }
4249 }
4250 if (delete_w) delete w;
4251 res->data=(void *)po;
4252 return FALSE;
4253}
#define pGetComp(p)
Component.
Definition: polys.h:37
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s

◆ jjHILBERT()

static BOOLEAN jjHILBERT ( leftv  ,
leftv  v 
)
static

Definition at line 4254 of file iparith.cc.

4255{
4256#ifdef HAVE_RINGS
4257 if (rField_is_Z(currRing))
4258 {
4259 PrintS("// NOTE: computation of Hilbert series etc. is being\n");
4260 PrintS("// performed for generic fibre, that is, over Q\n");
4261 }
4262#endif
4264 intvec *module_w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
4265 //scHilbertPoly((ideal)v->Data(),currRing->qideal);
4266 hLookSeries((ideal)v->Data(),module_w,currRing->qideal);
4267 return FALSE;
4268}
void hLookSeries(ideal S, intvec *modulweight, ideal Q, intvec *wdegree)
Definition: hilb.cc:776

◆ jjHILBERT2()

static BOOLEAN jjHILBERT2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2394 of file iparith.cc.

2395{
2396#ifdef HAVE_RINGS
2397 if (rField_is_Z(currRing))
2398 {
2399 PrintS("// NOTE: computation of Hilbert series etc. is being\n");
2400 PrintS("// performed for generic fibre, that is, over Q\n");
2401 }
2402#endif
2403 assumeStdFlag(u);
2404 intvec *module_w=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
2405 intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currRing->qideal);
2406 if (errorreported) return TRUE;
2407
2408 switch((int)(long)v->Data())
2409 {
2410 case 1:
2411 res->data=(void *)iv;
2412 return FALSE;
2413 case 2:
2414 res->data=(void *)hSecondSeries(iv);
2415 delete iv;
2416 return FALSE;
2417 }
2418 delete iv;
2420 return TRUE;
2421}
intvec * hSecondSeries(intvec *hseries1)
Definition: hilb.cc:697
intvec * hFirstSeries(ideal A, intvec *module_w, ideal Q, intvec *wdegree)
Definition: hilb.cc:1947
const char feNotImplemented[]
Definition: reporter.cc:54

◆ jjHILBERT3()

static BOOLEAN jjHILBERT3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6123 of file iparith.cc.

6124{
6125 intvec *wdegree=(intvec*)w->Data();
6126 if (wdegree->length()!=currRing->N)
6127 {
6128 Werror("weight vector must have size %d, not %d",
6129 currRing->N,wdegree->length());
6130 return TRUE;
6131 }
6132#ifdef HAVE_RINGS
6133 if (rField_is_Z(currRing))
6134 {
6135 PrintS("// NOTE: computation of Hilbert series etc. is being\n");
6136 PrintS("// performed for generic fibre, that is, over Q\n");
6137 }
6138#endif
6139 assumeStdFlag(u);
6140 intvec *module_w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
6141 intvec *iv=hFirstSeries((ideal)u->Data(),module_w,currRing->qideal,wdegree);
6142 if (errorreported) return TRUE;
6143
6144 switch((int)(long)v->Data())
6145 {
6146 case 1:
6147 res->data=(void *)iv;
6148 return FALSE;
6149 case 2:
6150 res->data=(void *)hSecondSeries(iv);
6151 delete iv;
6152 return FALSE;
6153 }
6154 delete iv;
6156 return TRUE;
6157}

◆ jjHILBERT_IV()

static BOOLEAN jjHILBERT_IV ( leftv  res,
leftv  v 
)
static

Definition at line 4269 of file iparith.cc.

4270{
4271#ifdef HAVE_RINGS
4272 if (rField_is_Z(currRing))
4273 {
4274 PrintS("// NOTE: computation of Hilbert series etc. is being\n");
4275 PrintS("// performed for generic fibre, that is, over Q\n");
4276 }
4277#endif
4278 res->data=(void *)hSecondSeries((intvec *)v->Data());
4279 return FALSE;
4280}

◆ jjHOMOG1()

static BOOLEAN jjHOMOG1 ( leftv  res,
leftv  v 
)
static

Definition at line 4281 of file iparith.cc.

4282{
4283 intvec *w=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
4284 ideal v_id=(ideal)v->Data();
4285 if (w==NULL)
4286 {
4287 res->data=(void *)(long)idHomModule(v_id,currRing->qideal,&w);
4288 if (res->data!=NULL)
4289 {
4290 if (v->rtyp==IDHDL)
4291 {
4292 char *s_isHomog=omStrDup("isHomog");
4293 if (v->e==NULL)
4294 atSet((idhdl)(v->data),s_isHomog,w,INTVEC_CMD);
4295 else
4296 atSet((idhdl)(v->LData()),s_isHomog,w,INTVEC_CMD);
4297 }
4298 else if (w!=NULL) delete w;
4299 } // if res->data==NULL then w==NULL
4300 }
4301 else
4302 {
4303 res->data=(void *)(long)idTestHomModule(v_id,currRing->qideal,w);
4304 if((res->data==NULL) && (v->rtyp==IDHDL))
4305 {
4306 if (v->e==NULL)
4307 atKill((idhdl)(v->data),"isHomog");
4308 else
4309 atKill((idhdl)(v->LData()),"isHomog");
4310 }
4311 }
4312 return FALSE;
4313}
void atSet(idhdl root, char *name, void *data, int typ)
Definition: attrib.cc:153
#define atKill(H, A)
Definition: attrib.h:49
BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w)
Definition: ideals.cc:2069
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
Definition: ideals.h:96

◆ jjHOMOG1_W()

static BOOLEAN jjHOMOG1_W ( leftv  res,
leftv  v,
leftv  u 
)
static

Definition at line 2461 of file iparith.cc.

2462{
2463 intvec *w=new intvec(rVar(currRing));
2464 intvec *vw=(intvec*)u->Data();
2465 ideal v_id=(ideal)v->Data();
2466 pFDegProc save_FDeg=currRing->pFDeg;
2467 pLDegProc save_LDeg=currRing->pLDeg;
2468 BOOLEAN save_pLexOrder=currRing->pLexOrder;
2469 currRing->pLexOrder=FALSE;
2470 kHomW=vw;
2471 kModW=w;
2473 res->data=(void *)(long)idHomModule(v_id,currRing->qideal,&w);
2474 currRing->pLexOrder=save_pLexOrder;
2475 kHomW=NULL;
2476 kModW=NULL;
2477 pRestoreDegProcs(currRing,save_FDeg,save_LDeg);
2478 if (w!=NULL) delete w;
2479 return FALSE;
2480}
long kHomModDeg(poly p, ring r)
Definition: kstd1.cc:2420
VAR intvec * kHomW
Definition: kstd1.cc:2408
VAR intvec * kModW
Definition: kstd1.cc:2408
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
Definition: p_polys.cc:3765
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
Definition: p_polys.cc:3753
long(* pFDegProc)(poly p, ring r)
Definition: ring.h:38
long(* pLDegProc)(poly p, int *length, ring r)
Definition: ring.h:37

◆ jjHOMOG1_WI()

static BOOLEAN jjHOMOG1_WI ( leftv  res,
leftv  v,
leftv  u 
)
static

Definition at line 2481 of file iparith.cc.

2482{
2483 intvec *vw=(intvec*)u->Data();
2484 ideal v_id=(ideal)v->Data();
2485 res->data=(void *)(long)id_HomIdealW(v_id,currRing->qideal,vw,currRing);
2486 return FALSE;
2487}
BOOLEAN id_HomIdealW(ideal id, ideal Q, const intvec *w, const ring r)

◆ jjHOMOG_ID()

static BOOLEAN jjHOMOG_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2439 of file iparith.cc.

2440{
2441 int i=pVar((poly)v->Data());
2442 if (i==0)
2443 {
2444 WerrorS("ringvar expected");
2445 return TRUE;
2446 }
2447 pFDegProc deg;
2448 if (currRing->pLexOrder && (currRing->order[0]==ringorder_lp))
2449 deg=p_Totaldegree;
2450 else
2451 deg=currRing->pFDeg;
2452 poly p=pOne(); pSetExp(p,i,1); pSetm(p);
2453 int d=deg(p,currRing);
2454 pLmDelete(p);
2455 if (d==1)
2456 res->data = (char *)id_Homogen((ideal)u->Data(), i, currRing);
2457 else
2458 WerrorS("variable must have weight 1");
2459 return (d!=1);
2460}
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1509
@ ringorder_lp
Definition: ring.h:77
ideal id_Homogen(ideal h, int varnum, const ring r)

◆ jjHOMOG_ID_W()

static BOOLEAN jjHOMOG_ID_W ( leftv  res,
leftv  u,
leftv  v,
leftv   
)
static

Definition at line 6158 of file iparith.cc.

6159{
6160 PrintS("TODO\n");
6161 int i=pVar((poly)v->Data());
6162 if (i==0)
6163 {
6164 WerrorS("ringvar expected");
6165 return TRUE;
6166 }
6167 poly p=pOne(); pSetExp(p,i,1); pSetm(p);
6168 int d=pWTotaldegree(p);
6169 pLmDelete(p);
6170 if (d==1)
6171 res->data = (char *)id_Homogen((ideal)u->Data(), i, currRing);
6172 else
6173 WerrorS("variable must have weight 1");
6174 return (d!=1);
6175}
#define pWTotaldegree(p)
Definition: polys.h:283

◆ jjHOMOG_P()

static BOOLEAN jjHOMOG_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2422 of file iparith.cc.

2423{
2424 int i=pVar((poly)v->Data());
2425 if (i==0)
2426 {
2427 WerrorS("ringvar expected");
2428 return TRUE;
2429 }
2430 poly p=pOne(); pSetExp(p,i,1); pSetm(p);
2431 int d=pWTotaldegree(p);
2432 pLmDelete(p);
2433 if (d==1)
2434 res->data = (char *)p_Homogen((poly)u->Data(), i, currRing);
2435 else
2436 WerrorS("variable must have weight 1");
2437 return (d!=1);
2438}
poly p_Homogen(poly p, int varnum, const ring r)
Definition: p_polys.cc:3335

◆ jjHOMOG_P_W()

static BOOLEAN jjHOMOG_P_W ( leftv  res,
leftv  u,
leftv  v,
leftv   
)
static

Definition at line 6176 of file iparith.cc.

6177{
6178 PrintS("TODO\n");
6179 int i=pVar((poly)v->Data());
6180 if (i==0)
6181 {
6182 WerrorS("ringvar expected");
6183 return TRUE;
6184 }
6185 poly p=pOne(); pSetExp(p,i,1); pSetm(p);
6186 int d=pWTotaldegree(p);
6187 pLmDelete(p);
6188 if (d==1)
6189 res->data = (char *)p_Homogen((poly)u->Data(), i, currRing);
6190 else
6191 WerrorS("variable must have weight 1");
6192 return (d!=1);
6193}

◆ jjHOMOG_W_M()

static BOOLEAN jjHOMOG_W_M ( leftv  res,
leftv  v1,
leftv  v2,
leftv  v3 
)
static

Definition at line 6194 of file iparith.cc.

6195{
6196 intvec *w=(intvec *)v3->Data();
6197 intvec *vw=(intvec*)v2->Data();
6198 ideal v_id=(ideal)v1->Data();
6199 res->data=(void *)(long)id_HomModuleW(v_id,currRing->qideal,vw,w,currRing);
6200 return FALSE;
6201}
BOOLEAN id_HomModuleW(ideal id, ideal Q, const intvec *w, const intvec *module_w, const ring r)

◆ jjIDEAL_Ma()

static BOOLEAN jjIDEAL_Ma ( leftv  res,
leftv  v 
)
static

Definition at line 4331 of file iparith.cc.

4332{
4333 matrix mat=(matrix)v->CopyD(MATRIX_CMD);
4334 IDELEMS((ideal)mat)=MATCOLS(mat)*MATROWS(mat);
4335 if (IDELEMS((ideal)mat)==0)
4336 {
4337 idDelete((ideal *)&mat);
4338 mat=(matrix)idInit(1,1);
4339 }
4340 else
4341 {
4342 MATROWS(mat)=1;
4343 mat->rank=1;
4344 idTest((ideal)mat);
4345 }
4346 res->data=(char *)mat;
4347 return FALSE;
4348}

◆ jjIDEAL_Map()

static BOOLEAN jjIDEAL_Map ( leftv  res,
leftv  v 
)
static

Definition at line 4349 of file iparith.cc.

4350{
4351 map m=(map)v->CopyD(MAP_CMD);
4352 omFreeBinAddr((ADDRESS)m->preimage);
4353 m->preimage=NULL;
4354 ideal I=(ideal)m;
4355 I->rank=1;
4356 res->data=(char *)I;
4357 return FALSE;
4358}
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
Definition: cf_map_ext.cc:504

◆ jjIDEAL_PL()

static BOOLEAN jjIDEAL_PL ( leftv  res,
leftv  v 
)
static

Definition at line 7284 of file iparith.cc.

7285{
7286 int s=1;
7287 leftv h=v;
7288 if (h!=NULL) s=exprlist_length(h);
7289 ideal id=idInit(s,1);
7290 int rank=1;
7291 int i=0;
7292 poly p;
7293 int dest_type=POLY_CMD;
7294 if (iiOp==MODUL_CMD) dest_type=VECTOR_CMD;
7295 while (h!=NULL)
7296 {
7297 // use standard type conversions to poly/vector
7298 int ri;
7299 int ht=h->Typ();
7300 if (ht==dest_type)
7301 {
7302 p=(poly)h->CopyD();
7303 if (p!=NULL) rank=si_max(rank,(int)pMaxComp(p));
7304 }
7305 else if ((ri=iiTestConvert(ht,dest_type,dConvertTypes))!=0)
7306 {
7307 sleftv tmp;
7308 leftv hnext=h->next;
7309 h->next=NULL;
7310 iiConvert(ht,dest_type,ri,h,&tmp,dConvertTypes);
7311 h->next=hnext;
7312 p=(poly)tmp.data;
7313 if (p!=NULL) rank=si_max(rank,(int)pMaxComp(p));
7314 }
7315 else
7316 {
7317 idDelete(&id);
7318 return TRUE;
7319 }
7320 id->m[i]=p;
7321 i++;
7322 h=h->next;
7323 }
7324 id->rank=rank;
7325 res->data=(char *)id;
7326 return FALSE;
7327}
int exprlist_length(leftv v)
Definition: ipshell.cc:552

◆ jjIDEAL_R()

static BOOLEAN jjIDEAL_R ( leftv  res,
leftv  v 
)
static

Definition at line 4359 of file iparith.cc.

4360{
4361 if (currRing!=NULL)
4362 {
4363 ring q=(ring)v->Data();
4364 if (rSamePolyRep(currRing, q))
4365 {
4366 if (q->qideal==NULL)
4367 res->data=(char *)idInit(1,1);
4368 else
4369 res->data=(char *)idCopy(q->qideal);
4370 return FALSE;
4371 }
4372 }
4373 WerrorS("can only get ideal from identical qring");
4374 return TRUE;
4375}
ideal idCopy(ideal A)
Definition: ideals.h:60
BOOLEAN rSamePolyRep(ring r1, ring r2)
returns TRUE, if r1 and r2 represents the monomials in the same way FALSE, otherwise this is an analo...
Definition: ring.cc:1799

◆ jjidElem()

static BOOLEAN jjidElem ( leftv  res,
leftv  v 
)
static

Definition at line 5594 of file iparith.cc.

5595{
5596 res->data = (char *)(long)idElem((ideal)v->Data());
5597 return FALSE;
5598}
int idElem(const ideal F)
count non-zero elements

◆ jjidFreeModule()

static BOOLEAN jjidFreeModule ( leftv  res,
leftv  v 
)
static

Definition at line 5599 of file iparith.cc.

5600{
5601 res->data = (char *)id_FreeModule((int)(long)v->Data(), currRing);
5602 return FALSE;
5603}
ideal id_FreeModule(int i, const ring r)
the free module of rank i

◆ jjidHead()

static BOOLEAN jjidHead ( leftv  res,
leftv  v 
)
static

Definition at line 5619 of file iparith.cc.

5620{
5621 res->data = (char *)id_Head((ideal)v->Data(),currRing);
5623 return FALSE;
5624}
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms

◆ jjidMaxIdeal()

static BOOLEAN jjidMaxIdeal ( leftv  res,
leftv  v 
)
static

Definition at line 4314 of file iparith.cc.

4315{
4316#ifdef HAVE_SHIFTBBA
4317 if (rIsLPRing(currRing))
4318 {
4319 int deg = (int)(long)v->Data();
4320 if (deg > currRing->N/currRing->isLPring)
4321 {
4322 WerrorS("degree bound of Letterplace ring is to small");
4323 return TRUE;
4324 }
4325 }
4326#endif
4327 res->data = (char *)idMaxIdeal((int)(long)v->Data());
4329 return FALSE;
4330}
#define idMaxIdeal(D)
initialise the maximal ideal (at 0)
Definition: ideals.h:33

◆ jjidMinBase()

static BOOLEAN jjidMinBase ( leftv  res,
leftv  v 
)
static

Definition at line 5625 of file iparith.cc.

5626{
5627 res->data = (char *)idMinBase((ideal)v->Data());
5628 return FALSE;
5629}
ideal idMinBase(ideal h1)
Definition: ideals.cc:51

◆ jjidTransp()

static BOOLEAN jjidTransp ( leftv  res,
leftv  v 
)
static

Definition at line 5677 of file iparith.cc.

5678{
5679 res->data = (char *)id_Transp((ideal)v->Data(),currRing);
5680 return FALSE;
5681}
ideal id_Transp(ideal a, const ring rRing)
transpose a module

◆ jjidVec2Ideal()

static BOOLEAN jjidVec2Ideal ( leftv  res,
leftv  v 
)
static

Definition at line 5604 of file iparith.cc.

5605{
5606 res->data = (char *)id_Vec2Ideal((poly)v->Data(), currRing);
5607 return FALSE;
5608}
ideal id_Vec2Ideal(poly vec, const ring R)

◆ jjIm2Iv()

static BOOLEAN jjIm2Iv ( leftv  res,
leftv  v 
)
static

Definition at line 4376 of file iparith.cc.

4377{
4378 intvec *iv = (intvec *)v->CopyD(INTMAT_CMD);
4379 iv->makeVector();
4380 res->data = iv;
4381 return FALSE;
4382}
void makeVector()
Definition: intvec.h:102
@ INTMAT_CMD
Definition: grammar.cc:279

◆ jjIMPART()

static BOOLEAN jjIMPART ( leftv  res,
leftv  v 
)
static

Definition at line 4383 of file iparith.cc.

4384{
4385 res->data = (char *)n_ImPart((number)v->Data(),currRing->cf);
4386 return FALSE;
4387}
static FORCE_INLINE number n_ImPart(number i, const coeffs cf)
Definition: coeffs.h:793

◆ jjINDEPSET()

static BOOLEAN jjINDEPSET ( leftv  res,
leftv  v 
)
static

Definition at line 4388 of file iparith.cc.

4389{
4391 res->data=(void *)scIndIntvec((ideal)(v->Data()),currRing->qideal);
4392 return FALSE;
4393}
intvec * scIndIntvec(ideal S, ideal Q)
Definition: hdegree.cc:286

◆ jjINDEPSET2()

static BOOLEAN jjINDEPSET2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2488 of file iparith.cc.

2489{
2490 assumeStdFlag(u);
2491 res->data=(void *)scIndIndset((ideal)(u->Data()),(int)(long)(v->Data()),
2492 currRing->qideal);
2493 return FALSE;
2494}
lists scIndIndset(ideal S, BOOLEAN all, ideal Q)
Definition: ipshell.cc:1103

◆ jjINDEX_I()

static BOOLEAN jjINDEX_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1394 of file iparith.cc.

1395{
1396 res->rtyp=u->rtyp; u->rtyp=0;
1397 res->data=u->data; u->data=NULL;
1398 res->name=u->name; u->name=NULL;
1399 res->e=u->e; u->e=NULL;
1400 if (res->e==NULL) res->e=jjMakeSub(v);
1401 else
1402 {
1403 Subexpr sh=res->e;
1404 while (sh->next != NULL) sh=sh->next;
1405 sh->next=jjMakeSub(v);
1406 }
1407 if (u->next!=NULL)
1408 {
1410 BOOLEAN bo=iiExprArith2(rn,u->next,iiOp,v);
1411 res->next=rn;
1412 return bo;
1413 }
1414 return FALSE;
1415}

◆ jjINDEX_IV()

static BOOLEAN jjINDEX_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1416 of file iparith.cc.

1417{
1418 if ((u->rtyp!=IDHDL)||(u->e!=NULL))
1419 {
1420 WerrorS("indexed object must have a name");
1421 return TRUE;
1422 }
1423 intvec * iv=(intvec *)v->Data();
1424 leftv p=NULL;
1425 int i;
1426 sleftv t;
1427 t.Init();
1428 t.rtyp=INT_CMD;
1429 for (i=0;i<iv->length(); i++)
1430 {
1431 t.data=(char *)((long)(*iv)[i]);
1432 if (p==NULL)
1433 {
1434 p=res;
1435 }
1436 else
1437 {
1438 p->next=(leftv)omAlloc0Bin(sleftv_bin);
1439 p=p->next;
1440 }
1441 p->rtyp=IDHDL;
1442 p->data=u->data;
1443 p->name=u->name;
1444 p->flag=u->flag;
1445 p->e=jjMakeSub(&t);
1446 }
1447 u->rtyp=0;
1448 u->data=NULL;
1449 u->name=NULL;
1450 return FALSE;
1451}
BITSET flag
Definition: subexpr.h:90

◆ jjINDEX_P()

static BOOLEAN jjINDEX_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1452 of file iparith.cc.

1453{
1454 poly p=(poly)u->Data();
1455 int i=(int)(long)v->Data();
1456 int j=0;
1457 while (p!=NULL)
1458 {
1459 j++;
1460 if (j==i)
1461 {
1462 res->data=(char *)pHead(p);
1463 return FALSE;
1464 }
1465 pIter(p);
1466 }
1467 return FALSE;
1468}
#define pIter(p)
Definition: monomials.h:37
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67

◆ jjINDEX_P_IV()

static BOOLEAN jjINDEX_P_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1492 of file iparith.cc.

1493{
1494 poly p=(poly)u->Data();
1495 poly r=NULL;
1496 intvec *iv=(intvec *)v->CopyD(INTVEC_CMD);
1497 int i;
1498 int sum=0;
1499 for(i=iv->length()-1;i>=0;i--)
1500 sum+=(*iv)[i];
1501 int j=0;
1502 while ((p!=NULL) && (sum>0))
1503 {
1504 j++;
1505 for(i=iv->length()-1;i>=0;i--)
1506 {
1507 if (j==(*iv)[i])
1508 {
1509 r=pAdd(r,pHead(p));
1510 sum-=j;
1511 (*iv)[i]=0;
1512 break;
1513 }
1514 }
1515 pIter(p);
1516 }
1517 delete iv;
1518 res->data=(char *)r;
1519 return FALSE;
1520}

◆ jjINDEX_PBu()

static BOOLEAN jjINDEX_PBu ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1469 of file iparith.cc.

1470{
1473 int l; poly p,pp;
1474 sBucketDestroyAdd(b, &pp, &l);
1475 int i=(int)(long)v->Data();
1476 int j=0;
1477 p=pp;
1478 while (p!=NULL)
1479 {
1480 j++;
1481 if (j==i)
1482 {
1483 res->data=(char *)pHead(p);
1485 return FALSE;
1486 }
1487 pIter(p);
1488 }
1490 return FALSE;
1491}
CanonicalForm FACTORY_PUBLIC pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:676
void sBucketCanonicalize(sBucket_pt bucket)
Definition: sbuckets.cc:401
sBucket * sBucket_pt
Definition: sbuckets.h:16
void sBucketDestroyAdd(sBucket_pt bucket, poly *p, int *length)
Definition: sbuckets.h:68

◆ jjINDEX_V()

static BOOLEAN jjINDEX_V ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1521 of file iparith.cc.

1522{
1523 poly p=(poly)u->Data();
1524 int i=(int)(long)v->Data();
1525 res->data=(char *)p_Vec2Poly(p,i,currRing);
1526 return FALSE;
1527}
poly p_Vec2Poly(poly v, int k, const ring r)
Definition: p_polys.cc:3689

◆ jjINDEX_V_IV()

static BOOLEAN jjINDEX_V_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1528 of file iparith.cc.

1529{
1530 poly p=(poly)u->CopyD(VECTOR_CMD);
1531 if (p!=NULL)
1532 {
1533 poly r=pOne();
1534 poly hp=r;
1535 intvec *iv=(intvec *)v->Data();
1536 int i;
1537 loop
1538 {
1539 for(i=0;i<iv->length();i++)
1540 {
1541 if (((int)pGetComp(p))==(*iv)[i])
1542 {
1543 poly h;
1544 pSplit(p,&h);
1545 pNext(hp)=p;
1546 p=h;
1547 pIter(hp);
1548 break;
1549 }
1550 }
1551 if (p==NULL) break;
1552 if (i==iv->length())
1553 {
1554 pLmDelete(&p);
1555 if (p==NULL) break;
1556 }
1557 }
1558 pLmDelete(&r);
1559 res->data=(char *)r;
1560 }
1561 return FALSE;
1562}
#define pSplit(p, r)
Definition: polys.h:265

◆ jjINTERPOLATION()

static BOOLEAN jjINTERPOLATION ( leftv  res,
leftv  l,
leftv  v 
)
static

Definition at line 2501 of file iparith.cc.

2502{
2503 const lists L = (lists)l->Data();
2504 const int n = L->nr; assume (n >= 0);
2505 std::vector<ideal> V(n + 1);
2506
2507 for(int i = n; i >= 0; i--) V[i] = (ideal)(L->m[i].Data());
2508
2509 res->data=interpolation(V, (intvec*)v->Data());
2511 return errorreported;
2512}
ideal interpolation(const std::vector< ideal > &L, intvec *v)

◆ jjINTERRED()

static BOOLEAN jjINTERRED ( leftv  res,
leftv  v 
)
static

Definition at line 4394 of file iparith.cc.

4395{
4396 ideal result=kInterRed((ideal)(v->Data()), currRing->qideal);
4397 if (TEST_OPT_PROT) { PrintLn(); mflush(); }
4398 res->data = result;
4399 return FALSE;
4400}
ideal kInterRed(ideal F, ideal Q)
Definition: kstd1.cc:3743
#define TEST_OPT_PROT
Definition: options.h:104
void PrintLn()
Definition: reporter.cc:310
#define mflush()
Definition: reporter.h:58

◆ jjINTERSEC3S()

static BOOLEAN jjINTERSEC3S ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6229 of file iparith.cc.

6230{
6231 ideal I=(ideal)u->Data();
6232 GbVariant alg=syGetAlgorithm((char*)w->Data(),currRing,I);
6233 res->data=(char *)idSect(I,(ideal)v->Data(),alg);
6235 return FALSE;
6236}
ideal idSect(ideal h1, ideal h2, GbVariant alg)
Definition: ideals.cc:316
#define TEST_OPT_RETURN_SB
Definition: options.h:113

◆ jjINTERSECT()

static BOOLEAN jjINTERSECT ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2495 of file iparith.cc.

2496{
2497 res->data=(char *)idSect((ideal)u->Data(),(ideal)v->Data());
2499 return FALSE;
2500}

◆ jjINTERSECT3()

static BOOLEAN jjINTERSECT3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6216 of file iparith.cc.

6217{
6218 ideal I1=(ideal)u->Data();
6219 ideal I2=(ideal)v->Data();
6220 ideal I3=(ideal)w->Data();
6221 resolvente r=(resolvente)omAlloc0(3*sizeof(ideal));
6222 r[0]=I1;
6223 r[1]=I2;
6224 r[2]=I3;
6225 res->data=(char *)idMultSect(r,3);
6226 omFreeSize((ADDRESS)r,3*sizeof(ideal));
6227 return FALSE;
6228}
ideal idMultSect(resolvente arg, int length, GbVariant alg)
Definition: ideals.cc:472
ideal * resolvente
Definition: ideals.h:18

◆ jjINTERSECT_PL()

static BOOLEAN jjINTERSECT_PL ( leftv  res,
leftv  v 
)
static

Definition at line 7453 of file iparith.cc.

7454{
7455 leftv h=v;
7456 int l=v->listLength();
7457 resolvente r=(resolvente)omAlloc0(l*sizeof(ideal));
7458 BOOLEAN *copied=(BOOLEAN *)omAlloc0(l*sizeof(BOOLEAN));
7459 int t=0;
7460 // try to convert to IDEAL_CMD
7461 while (h!=NULL)
7462 {
7463 if (iiTestConvert(h->Typ(),IDEAL_CMD)!=0)
7464 {
7465 t=IDEAL_CMD;
7466 }
7467 else break;
7468 h=h->next;
7469 }
7470 // if failure, try MODUL_CMD
7471 if (t==0)
7472 {
7473 h=v;
7474 while (h!=NULL)
7475 {
7476 if (iiTestConvert(h->Typ(),MODUL_CMD)!=0)
7477 {
7478 t=MODUL_CMD;
7479 }
7480 else break;
7481 h=h->next;
7482 }
7483 }
7484 // check for success in converting
7485 if (t==0)
7486 {
7487 WerrorS("cannot convert to ideal or module");
7488 return TRUE;
7489 }
7490 // call idMultSect
7491 h=v;
7492 int i=0;
7493 sleftv tmp;
7494 while (h!=NULL)
7495 {
7496 if (h->Typ()==t)
7497 {
7498 r[i]=(ideal)h->Data(); /*no copy*/
7499 h=h->next;
7500 }
7501 else if(iiConvert(h->Typ(),t,iiTestConvert(h->Typ(),t),h,&tmp))
7502 {
7503 omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
7504 omFreeSize((ADDRESS)r,l*sizeof(ideal));
7505 Werror("cannot convert arg. %d to %s",i+1,Tok2Cmdname(t));
7506 return TRUE;
7507 }
7508 else
7509 {
7510 r[i]=(ideal)tmp.Data(); /*now it's a copy*/
7511 copied[i]=TRUE;
7512 h=tmp.next;
7513 }
7514 i++;
7515 }
7516 res->rtyp=t;
7517 res->data=(char *)idMultSect(r,i);
7518 while(i>0)
7519 {
7520 i--;
7521 if (copied[i]) idDelete(&(r[i]));
7522 }
7523 omFreeSize((ADDRESS)copied,l*sizeof(BOOLEAN));
7524 omFreeSize((ADDRESS)r,l*sizeof(ideal));
7525 return FALSE;
7526}

◆ jjINTMAT3()

static BOOLEAN jjINTMAT3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6202 of file iparith.cc.

6203{
6204 intvec* im= new intvec((int)(long)v->Data(),(int)(long)w->Data(), 0);
6205 intvec* arg = (intvec*) u->Data();
6206 int i, n = si_min(im->cols()*im->rows(), arg->cols()*arg->rows());
6207
6208 for (i=0; i<n; i++)
6209 {
6210 (*im)[i] = (*arg)[i];
6211 }
6212
6213 res->data = (char *)im;
6214 return FALSE;
6215}

◆ jjINTVEC_PL()

static BOOLEAN jjINTVEC_PL ( leftv  res,
leftv  v 
)
static

Definition at line 7689 of file iparith.cc.

7690{
7691 int i=0;
7692 leftv h=v;
7693 if (h!=NULL) i=exprlist_length(h);
7694 intvec *iv=new intvec(i);
7695 i=0;
7696 while (h!=NULL)
7697 {
7698 if(h->Typ()==INT_CMD)
7699 {
7700 (*iv)[i]=(int)(long)h->Data();
7701 }
7702 else if (h->Typ()==INTVEC_CMD)
7703 {
7704 intvec *ivv=(intvec*)h->Data();
7705 for(int j=0;j<ivv->length();j++,i++)
7706 {
7707 (*iv)[i]=(*ivv)[j];
7708 }
7709 i--;
7710 }
7711 else
7712 {
7713 delete iv;
7714 return TRUE;
7715 }
7716 i++;
7717 h=h->next;
7718 }
7719 res->data=(char *)iv;
7720 return FALSE;
7721}

◆ jjIS_RINGVAR0()

static BOOLEAN jjIS_RINGVAR0 ( leftv  res,
leftv   
)
static

Definition at line 4412 of file iparith.cc.

4413{
4414 res->data = (char *)0;
4415 return FALSE;
4416}

◆ jjIS_RINGVAR_P()

static BOOLEAN jjIS_RINGVAR_P ( leftv  res,
leftv  v 
)
static

Definition at line 4401 of file iparith.cc.

4402{
4403 res->data = (char *)(long)pVar((poly)v->Data());
4404 return FALSE;
4405}

◆ jjIS_RINGVAR_S()

static BOOLEAN jjIS_RINGVAR_S ( leftv  res,
leftv  v 
)
static

Definition at line 4406 of file iparith.cc.

4407{
4408 res->data = (char *)(long)(r_IsRingVar((char *)v->Data(), currRing->names,
4409 currRing->N)+1);
4410 return FALSE;
4411}
int r_IsRingVar(const char *n, char **names, int N)
Definition: ring.cc:212

◆ jjJACOB_M()

static BOOLEAN jjJACOB_M ( leftv  res,
leftv  a 
)
static

Definition at line 4448 of file iparith.cc.

4449{
4450 ideal id = (ideal)a->Data();
4451 id = id_Transp(id,currRing);
4452 int W = IDELEMS(id);
4453
4454 ideal result = idInit(W * currRing->N, id->rank);
4455 poly *p = result->m;
4456
4457 for( int v = 1; v <= currRing->N; v++ )
4458 {
4459 poly* q = id->m;
4460 for( int i = 0; i < W; i++, p++, q++ )
4461 *p = pDiff( *q, v );
4462 }
4463 idDelete(&id);
4464
4465 res->data = (char *)result;
4466 return FALSE;
4467}

◆ jjJACOB_P()

static BOOLEAN jjJACOB_P ( leftv  res,
leftv  v 
)
static

Definition at line 4417 of file iparith.cc.

4418{
4419 ideal i=idInit(currRing->N,1);
4420 int k;
4421 poly p=(poly)(v->Data());
4422 for (k=currRing->N;k>0;k--)
4423 {
4424 i->m[k-1]=pDiff(p,k);
4425 }
4426 res->data = (char *)i;
4427 return FALSE;
4428}

◆ jjJanetBasis()

static BOOLEAN jjJanetBasis ( leftv  res,
leftv  v 
)
static

Definition at line 2519 of file iparith.cc.

2520{
2521 extern BOOLEAN jjStdJanetBasis(leftv res, leftv v,int flag);
2522 return jjStdJanetBasis(res,v,0);
2523}
BOOLEAN jjStdJanetBasis(leftv res, leftv v, int flag)
flag: 0: JB, 1: SB
Definition: wrapper.cc:50

◆ jjJanetBasis2()

static BOOLEAN jjJanetBasis2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2513 of file iparith.cc.

2514{
2515 extern BOOLEAN jjStdJanetBasis(leftv res, leftv v,int flag);
2516 return jjStdJanetBasis(res,u,(int)(long)v->Data());
2517}

◆ jjJET4()

static BOOLEAN jjJET4 ( leftv  res,
leftv  u 
)
static

Definition at line 7722 of file iparith.cc.

7723{
7724 const short t1[]={4,POLY_CMD,POLY_CMD,POLY_CMD,INTVEC_CMD};
7725 const short t2[]={4,VECTOR_CMD,POLY_CMD,POLY_CMD,INTVEC_CMD};
7726 const short t3[]={4,IDEAL_CMD,MATRIX_CMD,INT_CMD,INTVEC_CMD};
7727 const short t4[]={4,MODUL_CMD,MATRIX_CMD,INT_CMD,INTVEC_CMD};
7728 leftv u1=u;
7729 leftv u2=u1->next;
7730 leftv u3=u2->next;
7731 leftv u4=u3->next;
7732 if (iiCheckTypes(u,t1)||iiCheckTypes(u,t2))
7733 {
7734 if(!pIsUnit((poly)u2->Data()))
7735 {
7736 WerrorS("2nd argument must be a unit");
7737 return TRUE;
7738 }
7739 res->rtyp=u1->Typ();
7740 res->data=(char*)pSeries((int)(long)u3->Data(),pCopy((poly)u1->Data()),
7741 pCopy((poly)u2->Data()),(intvec*)u4->Data());
7742 return FALSE;
7743 }
7744 else
7745 if (iiCheckTypes(u,t3)||iiCheckTypes(u,t4))
7746 {
7747 if(!mp_IsDiagUnit((matrix)u2->Data(), currRing))
7748 {
7749 WerrorS("2nd argument must be a diagonal matrix of units");
7750 return TRUE;
7751 }
7752 res->rtyp=u1->Typ();
7753 res->data=(char*)idSeries(
7754 (int)(long)u3->Data(),
7755 idCopy((ideal)u1->Data()),
7756 mp_Copy((matrix)u2->Data(), currRing),
7757 (intvec*)u4->Data()
7758 );
7759 return FALSE;
7760 }
7761 else
7762 {
7763 Werror("%s(`poly`,`poly`,`int`,`intvec`) exppected",
7764 Tok2Cmdname(iiOp));
7765 return TRUE;
7766 }
7767}
ideal idSeries(int n, ideal M, matrix U, intvec *w)
Definition: ideals.cc:2121
BOOLEAN mp_IsDiagUnit(matrix U, const ring R)
Definition: matpol.cc:816
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
Definition: matpol.cc:64
#define pIsUnit(p)
return true if the Lm is a constant <>0
Definition: polys.h:240
#define pSeries(n, p, u, w)
Definition: polys.h:372

◆ jjJET_ID()

static BOOLEAN jjJET_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2529 of file iparith.cc.

2530{
2531 res->data = (char *)id_Jet((ideal)u->Data(),(int)(long)v->Data(),currRing);
2532 return FALSE;
2533}
ideal id_Jet(const ideal i, int d, const ring R)

◆ jjJET_ID_IV()

static BOOLEAN jjJET_ID_IV ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6254 of file iparith.cc.

6255{
6256 res->data = (char *)id_JetW((ideal)u->Data(),(int)(long)v->Data(),
6257 (intvec *)w->Data(),currRing);
6258 return FALSE;
6259}
ideal id_JetW(const ideal i, int d, intvec *iv, const ring R)

◆ jjJET_ID_M()

static BOOLEAN jjJET_ID_M ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6260 of file iparith.cc.

6261{
6262 if (!mp_IsDiagUnit((matrix)v->Data(), currRing))
6263 {
6264 WerrorS("2nd argument must be a diagonal matrix of units");
6265 return TRUE;
6266 }
6267 res->data = (char *)idSeries((int)(long)w->Data(),(ideal)u->CopyD(),
6268 (matrix)v->CopyD());
6269 return FALSE;
6270}

◆ jjJET_P()

static BOOLEAN jjJET_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2524 of file iparith.cc.

2525{
2526 res->data = (char *)pJet((poly)u->CopyD(), (int)(long)v->Data());
2527 return FALSE;
2528}
#define pJet(p, m)
Definition: polys.h:368

◆ jjJET_P_IV()

static BOOLEAN jjJET_P_IV ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6237 of file iparith.cc.

6238{
6239 int *iw=iv2array((intvec *)w->Data(),currRing);
6240 res->data = (char *)ppJetW((poly)u->Data(),(int)(long)v->Data(),iw);
6241 omFreeSize( (ADDRESS)iw, (rVar(currRing)+1)*sizeof(int) );
6242 return FALSE;
6243}
#define ppJetW(p, m, iv)
Definition: polys.h:369

◆ jjJET_P_P()

static BOOLEAN jjJET_P_P ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6244 of file iparith.cc.

6245{
6246 if (!pIsUnit((poly)v->Data()))
6247 {
6248 WerrorS("2nd argument must be a unit");
6249 return TRUE;
6250 }
6251 res->data = (char *)p_Series((int)(long)w->Data(),(poly)u->CopyD(),(poly)v->CopyD(),NULL,currRing);
6252 return FALSE;
6253}
poly p_Series(int n, poly p, poly u, intvec *w, const ring R)
Definition: p_polys.cc:4614

◆ jjKBASE()

static BOOLEAN jjKBASE ( leftv  res,
leftv  v 
)
static

Definition at line 4487 of file iparith.cc.

4488{
4490 res->data = (char *)scKBase(-1,(ideal)(v->Data()),currRing->qideal);
4491 return FALSE;
4492}
ideal scKBase(int deg, ideal s, ideal Q, intvec *mv)
Definition: hdegree.cc:1449

◆ jjKBASE2()

static BOOLEAN jjKBASE2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2534 of file iparith.cc.

2535{
2536 assumeStdFlag(u);
2537 intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2538 res->data = (char *)scKBase((int)(long)v->Data(),
2539 (ideal)(u->Data()),currRing->qideal, w_u);
2540 if (w_u!=NULL)
2541 {
2542 atSet(res,omStrDup("isHomog"),ivCopy(w_u),INTVEC_CMD);
2543 }
2544 return FALSE;
2545}
intvec * ivCopy(const intvec *o)
Definition: intvec.h:145

◆ jjKERNEL()

static BOOLEAN jjKERNEL ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2547 of file iparith.cc.

2548{
2549 return jjPREIMAGE(res,u,v,NULL);
2550}
static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
Definition: iparith.cc:6477

◆ jjKERNEL_M()

static BOOLEAN jjKERNEL_M ( leftv  res,
leftv  v 
)
static

Definition at line 4469 of file iparith.cc.

4470{
4471#ifdef HAVE_FLINT
4472 res->data = (char *)singflint_kernel((matrix)(v->Data()),currRing);
4473 return res->data==NULL;
4474#else
4475 return TRUE;
4476#endif
4477}
matrix singflint_kernel(matrix m, const ring R)

◆ jjKERNEL_SM()

static BOOLEAN jjKERNEL_SM ( leftv  res,
leftv  v 
)
static

Definition at line 4478 of file iparith.cc.

4479{
4480#ifdef HAVE_FLINT
4481 res->data = (char *)singflint_kernel((ideal)(v->Data()),currRing);
4482 return res->data==NULL;
4483#else
4484 return TRUE;
4485#endif
4486}

◆ jjKLAMMER()

static BOOLEAN jjKLAMMER ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1564 of file iparith.cc.

1565{
1566 if(u->name==NULL) return TRUE;
1567 long slen = strlen(u->name) + 14;
1568 char *nn = (char*) omAlloc(slen);
1569 sprintf(nn,"%s(%d)",u->name,(int)(long)v->Data());
1570 char *n=omStrDup(nn);
1571 omFreeSize((ADDRESS)nn,slen);
1572 syMake(res,n);
1573 if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1574 return FALSE;
1575}
static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v)
Definition: iparith.cc:1603

◆ jjKLAMMER_IV()

static BOOLEAN jjKLAMMER_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1576 of file iparith.cc.

1577{
1578 if(u->name==NULL) return TRUE;
1579 intvec * iv=(intvec *)v->Data();
1580 leftv p=NULL;
1581 int i;
1582 long slen = strlen(u->name) + 14;
1583 char *n = (char*) omAlloc(slen);
1584
1585 for (i=0;i<iv->length(); i++)
1586 {
1587 if (p==NULL)
1588 {
1589 p=res;
1590 }
1591 else
1592 {
1593 p->next=(leftv)omAlloc0Bin(sleftv_bin);
1594 p=p->next;
1595 }
1596 sprintf(n,"%s(%d)",u->name,(*iv)[i]);
1597 syMake(p,omStrDup(n));
1598 }
1599 omFreeSize(n, slen);
1600 if (u->next!=NULL) return jjKLAMMER_rest(res,u->next,v);
1601 return FALSE;
1602}

◆ jjKLAMMER_PL()

static BOOLEAN jjKLAMMER_PL ( leftv  res,
leftv  u 
)
static

Definition at line 7805 of file iparith.cc.

7806{
7808 && ((strcmp(u->Name(),"real")==0) || (strcmp(u->Name(),"complex")==0)))
7809 {
7810 memcpy(res,u,sizeof(sleftv));
7811 u->Init();
7812 return FALSE;
7813 }
7814 leftv v=u->next;
7815 BOOLEAN b;
7816 if(v==NULL) // p()
7818 else if ((v->next==NULL) // p(1)
7819 || (u->Typ()!=UNKNOWN)) // p(1,2), p proc or map
7820 {
7821 u->next=NULL;
7822 b=iiExprArith2(res,u,iiOp,v);
7823 u->next=v;
7824 }
7825 else // p(1,2), p undefined
7826 {
7827 if (v->Typ()!=INT_CMD)
7828 {
7829 Werror("`%s` undefined or `int` expected while building `%s(`",u->name,u->name);
7830 return TRUE;
7831 }
7832 int l=u->listLength();
7833 char * nn = (char *)omAlloc(strlen(u->name) + 12*l);
7834 sprintf(nn,"%s(%d",u->name,(int)(long)v->Data());
7835 char *s=nn;
7836 do
7837 {
7838 while (*s!='\0') s++;
7839 v=v->next;
7840 if (v->Typ()!=INT_CMD)
7841 {
7842 Werror("`%s` undefined or `int` expected while building `%s(`",u->name,u->name);
7843 omFree((ADDRESS)nn);
7844 return TRUE;
7845 }
7846 sprintf(s,",%d",(int)(long)v->Data());
7847 } while (v->next!=NULL);
7848 while (*s!='\0') s++;
7849 nn=strcat(nn,")");
7850 char *n=omStrDup(nn);
7851 omFree((ADDRESS)nn);
7852 syMake(res,n);
7853 b=FALSE;
7854 }
7855 return b;
7856}
VAR BOOLEAN yyInRingConstruction
Definition: grammar.cc:172

◆ jjKLAMMER_rest()

static BOOLEAN jjKLAMMER_rest ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1603 of file iparith.cc.

1604{
1606 BOOLEAN b;
1607 if (v->Typ()==INTVEC_CMD)
1608 b=jjKLAMMER_IV(tmp,u,v);
1609 else
1610 b=jjKLAMMER(tmp,u,v);
1611 if (b)
1612 {
1613 omFreeBin(tmp,sleftv_bin);
1614 return TRUE;
1615 }
1616 leftv h=res;
1617 while (h->next!=NULL) h=h->next;
1618 h->next=tmp;
1619 return FALSE;
1620}
static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
Definition: iparith.cc:1576
static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
Definition: iparith.cc:1564

◆ jjKoszul()

static BOOLEAN jjKoszul ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2551 of file iparith.cc.

2552{
2553 return mpKoszul(res, u,v,NULL);
2554}
BOOLEAN mpKoszul(leftv res, leftv c, leftv b, leftv id)
Definition: ipshell.cc:3092

◆ jjKoszul_Id()

static BOOLEAN jjKoszul_Id ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2555 of file iparith.cc.

2556{
2557 sleftv h;
2558 h.Init();
2559 h.rtyp=INT_CMD;
2560 h.data=(void *)(long)IDELEMS((ideal)v->Data());
2561 return mpKoszul(res, u, &h, v);
2562}

◆ jjL2R()

static BOOLEAN jjL2R ( leftv  res,
leftv  v 
)
static

Definition at line 4493 of file iparith.cc.

4494{
4495 res->data=(char *)syConvList((lists)v->Data());
4496 if (res->data != NULL)
4497 return FALSE;
4498 else
4499 return TRUE;
4500}
syStrategy syConvList(lists li)
Definition: ipshell.cc:3255

◆ jjLagSolve()

static BOOLEAN jjLagSolve ( leftv  res,
leftv  v 
)
static

Definition at line 4570 of file iparith.cc.

4571{
4572 sleftv a2,a3;
4573 memset(&a2,0,sizeof(a2));
4574 memset(&a3,0,sizeof(a3));
4575 a2.rtyp=INT_CMD; a2.data=(void*)10;
4576 a3.rtyp=INT_CMD; a3.data=(void*)1;
4577 return nuLagSolve(res,v,&a2,&a3);
4578}
BOOLEAN nuLagSolve(leftv res, leftv arg1, leftv arg2, leftv arg3)
find the (complex) roots an univariate polynomial Determines the roots of an univariate polynomial us...
Definition: ipshell.cc:4677

◆ jjLE_BI()

static BOOLEAN jjLE_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1205 of file iparith.cc.

1206{
1207 return jjGE_BI(res,v,u);
1208}
static BOOLEAN jjGE_BI(leftv res, leftv u, leftv v)
Definition: iparith.cc:1170

◆ jjLE_I()

static BOOLEAN jjLE_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1209 of file iparith.cc.

1210{
1211 res->data = (char *)(long)((int)((long)u->Data()) <= (int)((long)v->Data()));
1212 return FALSE;
1213}

◆ jjLE_N()

static BOOLEAN jjLE_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1214 of file iparith.cc.

1215{
1216 return jjGE_N(res,v,u);
1217}
static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
Definition: iparith.cc:1182

◆ jjLEADCOEF()

static BOOLEAN jjLEADCOEF ( leftv  res,
leftv  v 
)
static

Definition at line 4501 of file iparith.cc.

4502{
4503 poly p=(poly)v->Data();
4504 if (p==NULL)
4505 {
4506 res->data=(char *)nInit(0);
4507 }
4508 else
4509 {
4511 res->data=(char *)nCopy(pGetCoeff(p));
4512 }
4513 return FALSE;
4514}

◆ jjLEADEXP()

static BOOLEAN jjLEADEXP ( leftv  res,
leftv  v 
)
static

Definition at line 4515 of file iparith.cc.

4516{
4517 poly p=(poly)v->Data();
4518 int s=currRing->N;
4519 if (v->Typ()==VECTOR_CMD) s++;
4520 intvec *iv=new intvec(s);
4521 if (p!=NULL)
4522 {
4523 for(int i = currRing->N;i;i--)
4524 {
4525 (*iv)[i-1]=pGetExp(p,i);
4526 }
4527 if (s!=currRing->N)
4528 (*iv)[currRing->N]=pGetComp(p);
4529 }
4530 res->data=(char *)iv;
4531 return FALSE;
4532}
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41

◆ jjLEADMONOM()

static BOOLEAN jjLEADMONOM ( leftv  res,
leftv  v 
)
static

Definition at line 4533 of file iparith.cc.

4534{
4535 poly p=(poly)v->Data();
4536 if (p == NULL)
4537 {
4538 res->data = (char*) NULL;
4539 }
4540 else
4541 {
4542 poly lm = pLmInit(p);
4543 pSetCoeff0(lm, nInit(1));
4544 res->data = (char*) lm;
4545 }
4546 return FALSE;
4547}
#define pSetCoeff0(p, n)
Definition: monomials.h:59
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
Definition: polys.h:64

◆ jjLIFT()

static BOOLEAN jjLIFT ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2563 of file iparith.cc.

2564{
2565 int ul= IDELEMS((ideal)u->Data());
2566 int vl= IDELEMS((ideal)v->Data());
2567#ifdef HAVE_SHIFTBBA
2568 if (rIsLPRing(currRing))
2569 {
2570 if (currRing->LPncGenCount < ul)
2571 {
2572 Werror("At least %d ncgen variables are needed for this computation.", ul);
2573 return TRUE;
2574 }
2575 }
2576#endif
2577 ideal m = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,
2578 hasFlag(u,FLAG_STD));
2579 if (m==NULL) return TRUE;
2580 res->data = (char *)id_Module2formatedMatrix(m,ul,vl,currRing);
2581 return FALSE;
2582}

◆ jjLIFT3()

static BOOLEAN jjLIFT3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6917 of file iparith.cc.

6918{
6919 if (w->rtyp!=IDHDL) return TRUE;
6920 int ul= IDELEMS((ideal)u->Data());
6921 int vl= IDELEMS((ideal)v->Data());
6922#ifdef HAVE_SHIFTBBA
6923 if (rIsLPRing(currRing))
6924 {
6925 if (currRing->LPncGenCount < ul)
6926 {
6927 Werror("At least %d ncgen variables are needed for this computation.", ul);
6928 return TRUE;
6929 }
6930 }
6931#endif
6932 ideal m
6933 = idLift((ideal)u->Data(),(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
6934 FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))));
6935 if (m==NULL) return TRUE;
6936 res->data = (char *)id_Module2formatedMatrix(m,ul,vl,currRing);
6937 return FALSE;
6938}
#define IDMATRIX(a)
Definition: ipid.h:134

◆ jjLIFT_4()

static BOOLEAN jjLIFT_4 ( leftv  res,
leftv  U 
)
static

Definition at line 7857 of file iparith.cc.

7858{
7859 const short t1[]={4,IDEAL_CMD,IDEAL_CMD,MATRIX_CMD,STRING_CMD};
7860 const short t2[]={4,MODUL_CMD,MODUL_CMD,MATRIX_CMD,STRING_CMD};
7861 leftv u=U;
7862 leftv v=u->next;
7863 leftv w=v->next;
7864 leftv u4=w->next;
7865 if (w->rtyp!=IDHDL) return TRUE;
7866 if (iiCheckTypes(U,t1)||iiCheckTypes(U,t2))
7867 {
7868 // see jjLIFT3
7869 ideal I=(ideal)u->Data();
7870 int ul= IDELEMS(I /*(ideal)u->Data()*/);
7871 int vl= IDELEMS((ideal)v->Data());
7872 GbVariant alg=syGetAlgorithm((char*)u4->Data(),currRing,I);
7873 ideal m
7874 = idLift(I,(ideal)v->Data(),NULL,FALSE,hasFlag(u,FLAG_STD),
7875 FALSE, (matrix *)(&(IDMATRIX((idhdl)(w->data)))),alg);
7876 if (m==NULL) return TRUE;
7877 res->data = (char *)id_Module2formatedMatrix(m,ul,vl,currRing);
7878 return FALSE;
7879 }
7880 else
7881 {
7882 Werror("%s(`ideal`,`ideal`,`matrix`,`string`)\n"
7883 "or (`module`,`module`,`matrix`,`string`) expected",
7884 Tok2Cmdname(iiOp));
7885 return TRUE;
7886 }
7887}

◆ jjLIFTSTD()

static BOOLEAN jjLIFTSTD ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2583 of file iparith.cc.

2584{
2585 if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
2586 idhdl h=(idhdl)v->data;
2587#ifdef HAVE_SHIFTBBA
2589 {
2590 if (currRing->LPncGenCount < IDELEMS((ideal)u->Data()))
2591 {
2592 Werror("At least %d ncgen variables are needed for this computation.", IDELEMS((ideal)u->Data()));
2593 return TRUE;
2594 }
2595 }
2596#endif
2597 // CopyD for IDEAL_CMD and MODUL_CMD are identical:
2598 res->data = (char *)idLiftStd((ideal)u->Data(),
2599 &(h->data.umatrix),testHomog);
2600 setFlag(res,FLAG_STD); v->flag=0;
2601 return FALSE;
2602}
ideal idLiftStd(ideal h1, matrix *T, tHomog hi, ideal *S, GbVariant alg, ideal h11)
Definition: ideals.cc:976

◆ jjLIFTSTD_ALG()

static BOOLEAN jjLIFTSTD_ALG ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6962 of file iparith.cc.

6963{
6964 if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
6965 idhdl hv=(idhdl)v->data;
6966 GbVariant alg=syGetAlgorithm((char*)w->Data(),currRing,(ideal)u->Data());
6967#ifdef HAVE_SHIFTBBA
6968 if (rIsLPRing(currRing))
6969 {
6970 if (currRing->LPncGenCount < IDELEMS((ideal)u->Data()))
6971 {
6972 Werror("At least %d ncgen variables are needed for this computation.", IDELEMS((ideal)u->Data()));
6973 return TRUE;
6974 }
6975 }
6976#endif
6977 // CopyD for IDEAL_CMD and MODUL_CMD are identical:
6978 res->data = (char *)idLiftStd((ideal)u->Data(),
6979 &(hv->data.umatrix),testHomog,
6980 NULL,alg);
6981 setFlag(res,FLAG_STD); v->flag=0;
6982 return FALSE;
6983}

◆ jjLIFTSTD_M()

static BOOLEAN jjLIFTSTD_M ( leftv  res,
leftv  U 
)
static

Definition at line 7888 of file iparith.cc.

7889{
7890 // we have 4 or 5 arguments
7891 leftv u=U;
7892 leftv v=u->next;
7893 leftv u3=v->next;
7894 leftv u4=u3->next;
7895 leftv u5=u4->next; // might be NULL
7896
7897 ideal *syz=NULL;
7898 GbVariant alg=GbDefault;
7899 ideal h11=NULL;
7900
7901 if(u5==NULL)
7902 {
7903 // test all three possibilities for 4 arguments
7904 const short t1[]={4,IDEAL_CMD,MATRIX_CMD,MODUL_CMD,STRING_CMD};
7905 const short t2[]={4,MODUL_CMD,MATRIX_CMD,MODUL_CMD,STRING_CMD};
7906 const short t3[]={4,IDEAL_CMD,MATRIX_CMD,MODUL_CMD,IDEAL_CMD};
7907 const short t4[]={4,MODUL_CMD,MATRIX_CMD,MODUL_CMD,MODUL_CMD};
7908 const short t5[]={4,IDEAL_CMD,MATRIX_CMD,STRING_CMD,IDEAL_CMD};
7909 const short t6[]={4,MODUL_CMD,MATRIX_CMD,STRING_CMD,MODUL_CMD};
7910
7911 if(iiCheckTypes(U,t1)||iiCheckTypes(U,t2))
7912 {
7913 if ((u3->rtyp!=IDHDL)||(u3->e!=NULL)) return TRUE;
7914 idhdl hw=(idhdl)u3->data;
7915 syz=&(hw->data.uideal);
7916 alg=syGetAlgorithm((char*)u4->Data(),currRing,(ideal)u->Data());
7917 }
7918 else if(iiCheckTypes(U,t3)||iiCheckTypes(U,t4))
7919 {
7920 if ((u3->rtyp!=IDHDL)||(u3->e!=NULL)) return TRUE;
7921 idhdl hw=(idhdl)u3->data;
7922 syz=&(hw->data.uideal);
7923 h11=(ideal)u4->Data();
7924 }
7925 else if(iiCheckTypes(U,t5)||iiCheckTypes(U,t6))
7926 {
7927 alg=syGetAlgorithm((char*)u3->Data(),currRing,(ideal)u->Data());
7928 h11=(ideal)u4->Data();
7929 }
7930 else
7931 {
7932 Werror("%s(`ideal/module`,`matrix`[,`module`][,`string`][,`ideal/module`]) expected",Tok2Cmdname(iiOp));
7933 return TRUE;
7934 }
7935 }
7936 else
7937 {
7938 // we have 5 arguments
7939 const short t1[]={5,IDEAL_CMD,MATRIX_CMD,MODUL_CMD,STRING_CMD,IDEAL_CMD};
7940 const short t2[]={5,MODUL_CMD,MATRIX_CMD,MODUL_CMD,STRING_CMD,MODUL_CMD};
7941 if(iiCheckTypes(U,t1)||iiCheckTypes(U,t2))
7942 {
7943 idhdl hw=(idhdl)u3->data;
7944 syz=&(hw->data.uideal);
7945 alg=syGetAlgorithm((char*)u4->Data(),currRing,(ideal)u->Data());
7946 h11=(ideal)u5->Data();
7947 }
7948 else
7949 {
7950 Werror("%s(`ideal/module`,`matrix`[,`module`][,`string`][,`ideal/module`]) expected",Tok2Cmdname(iiOp));
7951 return TRUE;
7952 }
7953 }
7954
7955#ifdef HAVE_SHIFTBBA
7956 if (rIsLPRing(currRing))
7957 {
7958 if (currRing->LPncGenCount < IDELEMS((ideal)u->Data()))
7959 {
7960 Werror("At least %d ncgen variables are needed for this computation.", IDELEMS((ideal)u->Data()));
7961 return TRUE;
7962 }
7963 }
7964#endif
7965
7966 if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
7967 idhdl hv=(idhdl)v->data;
7968 // CopyD for IDEAL_CMD and MODUL_CMD are identical:
7969 res->rtyp = u->Typ();
7970 res->data = (char *)idLiftStd((ideal)u->Data(),
7971 &(hv->data.umatrix),testHomog,
7972 syz,alg,h11);
7973 setFlag(res,FLAG_STD); v->flag=0;
7974 if(syz!=NULL)
7975 u3->flag=0;
7976 return FALSE;
7977}
@ GbDefault
Definition: ideals.h:120

◆ jjLIFTSTD_SYZ()

static BOOLEAN jjLIFTSTD_SYZ ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6939 of file iparith.cc.

6940{
6941 if ((v->rtyp!=IDHDL)||(v->e!=NULL)) return TRUE;
6942 if ((w->rtyp!=IDHDL)||(w->e!=NULL)) return TRUE;
6943 idhdl hv=(idhdl)v->data;
6944 idhdl hw=(idhdl)w->data;
6945#ifdef HAVE_SHIFTBBA
6946 if (rIsLPRing(currRing))
6947 {
6948 if (currRing->LPncGenCount < IDELEMS((ideal)u->Data()))
6949 {
6950 Werror("At least %d ncgen variables are needed for this computation.", IDELEMS((ideal)u->Data()));
6951 return TRUE;
6952 }
6953 }
6954#endif
6955 // CopyD for IDEAL_CMD and MODUL_CMD are identical:
6956 res->data = (char *)idLiftStd((ideal)u->Data(),
6957 &(hv->data.umatrix),testHomog,
6958 &(hw->data.uideal));
6959 setFlag(res,FLAG_STD); v->flag=0; w->flag=0;
6960 return FALSE;
6961}

◆ jjLIST_PL()

BOOLEAN jjLIST_PL ( leftv  res,
leftv  v 
)

Definition at line 7978 of file iparith.cc.

7979{
7980 int sl=0;
7981 if (v!=NULL) sl = v->listLength();
7982 lists L;
7983 if((sl==1)&&(v->Typ()==RESOLUTION_CMD))
7984 {
7985 int add_row_shift = 0;
7986 intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
7987 if (weights!=NULL) add_row_shift=weights->min_in();
7988 L=syConvRes((syStrategy)v->Data(),FALSE,add_row_shift);
7989 }
7990 else
7991 {
7993 leftv h=NULL;
7994 int i;
7995 int rt;
7996
7997 L->Init(sl);
7998 for (i=0;i<sl;i++)
7999 {
8000 if (h!=NULL)
8001 { /* e.g. not in the first step:
8002 * h is the pointer to the old sleftv,
8003 * v is the pointer to the next sleftv
8004 * (in this moment) */
8005 h->next=v;
8006 }
8007 h=v;
8008 v=v->next;
8009 h->next=NULL;
8010 rt=h->Typ();
8011 if (rt==0)
8012 {
8013 L->Clean();
8014 Werror("`%s` is undefined",h->Fullname());
8015 return TRUE;
8016 }
8017 if (rt==RING_CMD)
8018 {
8019 L->m[i].rtyp=rt;
8020 L->m[i].data=rIncRefCnt(((ring)h->Data()));
8021 }
8022 else
8023 L->m[i].Copy(h);
8024 }
8025 }
8026 res->data=(char *)L;
8027 return FALSE;
8028}
int min_in()
Definition: intvec.h:121
@ RESOLUTION_CMD
Definition: grammar.cc:290
lists syConvRes(syStrategy syzstr, BOOLEAN toDel, int add_row_shift)
Definition: ipshell.cc:3183
static ring rIncRefCnt(ring r)
Definition: ring.h:843

◆ jjLISTRING()

static BOOLEAN jjLISTRING ( leftv  res,
leftv  v 
)
static

Definition at line 4552 of file iparith.cc.

4553{
4554 lists l=(lists)v->Data();
4555 long mm=(long)atGet(v,"maxExp",INT_CMD);
4556 int isLetterplace=(int)(long)atGet(v,"isLetterplaceRing",INT_CMD);
4557 ring r=rCompose(l,TRUE,mm,isLetterplace);
4558 res->data=(char *)r;
4559 return (r==NULL);
4560}
ring rCompose(const lists L, const BOOLEAN check_comp, const long bitmask, const int isLetterplace)
Definition: ipshell.cc:2783

◆ jjLOAD()

BOOLEAN jjLOAD ( const char *  s,
BOOLEAN  autoexport 
)

load lib/module given in v

Definition at line 5492 of file iparith.cc.

5493{
5494 char libnamebuf[1024];
5496
5497#ifdef HAVE_DYNAMIC_LOADING
5498 extern BOOLEAN load_modules(const char *newlib, char *fullpath, BOOLEAN autoexport);
5499#endif /* HAVE_DYNAMIC_LOADING */
5500 switch(LT)
5501 {
5502 default:
5503 case LT_NONE:
5504 Werror("%s: unknown type", s);
5505 break;
5506 case LT_NOTFOUND:
5507 Werror("cannot open %s", s);
5508 break;
5509
5510 case LT_SINGULAR:
5511 {
5512 char *plib = iiConvName(s);
5513 idhdl pl = IDROOT->get_level(plib,0);
5514 if (pl==NULL)
5515 {
5516 pl = enterid( plib,0, PACKAGE_CMD, &(basePack->idroot), TRUE );
5517 IDPACKAGE(pl)->language = LANG_SINGULAR;
5518 IDPACKAGE(pl)->libname=omStrDup(s);
5519 }
5520 else if (IDTYP(pl)!=PACKAGE_CMD)
5521 {
5522 Werror("can not create package `%s`",plib);
5523 omFreeBinAddr(plib);
5524 return TRUE;
5525 }
5526 else /* package */
5527 {
5528 package pa=IDPACKAGE(pl);
5529 if ((pa->language==LANG_C)
5530 || (pa->language==LANG_MIX))
5531 {
5532 Werror("can not create package `%s` - binaries exists",plib);
5533 omFreeBinAddr(plib);
5534 return TRUE;
5535 }
5536 }
5537 omFreeBinAddr(plib);
5538 package savepack=currPack;
5539 currPack=IDPACKAGE(pl);
5540 IDPACKAGE(pl)->loaded=TRUE;
5541 char libnamebuf[1024];
5542 FILE * fp = feFopen( s, "r", libnamebuf, TRUE );
5543 BOOLEAN bo=iiLoadLIB(fp, libnamebuf, s, pl, autoexport, TRUE);
5544 currPack=savepack;
5545 IDPACKAGE(pl)->loaded=(!bo);
5546 return bo;
5547 }
5548 case LT_BUILTIN:
5549 SModulFunc_t iiGetBuiltinModInit(const char*);
5550 return load_builtin(s,autoexport, iiGetBuiltinModInit(s));
5551 case LT_MACH_O:
5552 case LT_ELF:
5553 case LT_HPUX:
5554#ifdef HAVE_DYNAMIC_LOADING
5555 return load_modules(s, libnamebuf, autoexport);
5556#else /* HAVE_DYNAMIC_LOADING */
5557 WerrorS("Dynamic modules are not supported by this version of Singular");
5558 break;
5559#endif /* HAVE_DYNAMIC_LOADING */
5560 }
5561 return TRUE;
5562}
CanonicalForm fp
Definition: cfModGcd.cc:4102
FILE * feFopen(const char *path, const char *mode, char *where, short useWerror, short path_only)
Definition: feFopen.cc:47
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition: ipid.cc:279
VAR package basePack
Definition: ipid.cc:58
VAR package currPack
Definition: ipid.cc:57
#define IDROOT
Definition: ipid.h:19
BOOLEAN load_builtin(const char *newlib, BOOLEAN autoexport, SModulFunc_t init)
Definition: iplib.cc:1294
int(* SModulFunc_t)(SModulFunctions *)
Definition: ipid.h:81
BOOLEAN iiLoadLIB(FILE *fp, const char *libnamebuf, const char *newlib, idhdl pl, BOOLEAN autoexport, BOOLEAN tellerror)
Definition: iplib.cc:973
char * iiConvName(const char *libname)
Definition: iplib.cc:1429
BOOLEAN load_modules(const char *newlib, char *fullname, BOOLEAN autoexport)
Definition: iplib.cc:1284
SModulFunc_t iiGetBuiltinModInit(const char *libname)
Definition: iplib.cc:807
VAR char libnamebuf[1024]
Definition: libparse.cc:1098
lib_types type_of_LIB(const char *newlib, char *libnamebuf)
Definition: mod_lib.cc:27
lib_types
Definition: mod_raw.h:16
@ LT_MACH_O
Definition: mod_raw.h:16
@ LT_HPUX
Definition: mod_raw.h:16
@ LT_SINGULAR
Definition: mod_raw.h:16
@ LT_BUILTIN
Definition: mod_raw.h:16
@ LT_ELF
Definition: mod_raw.h:16
@ LT_NONE
Definition: mod_raw.h:16
@ LT_NOTFOUND
Definition: mod_raw.h:16
@ LANG_SINGULAR
Definition: subexpr.h:22
@ LANG_MIX
Definition: subexpr.h:22
@ LANG_C
Definition: subexpr.h:22

◆ jjLOAD1()

static BOOLEAN jjLOAD1 ( leftv  ,
leftv  v 
)
static

Definition at line 4548 of file iparith.cc.

4549{
4550 return jjLOAD((char*)v->Data(),FALSE);
4551}
BOOLEAN jjLOAD(const char *s, BOOLEAN autoexport)
load lib/module given in v
Definition: iparith.cc:5492

◆ jjLOAD2()

static BOOLEAN jjLOAD2 ( leftv  ,
leftv  ,
leftv  v 
)
static

Definition at line 2603 of file iparith.cc.

2604{
2605 return jjLOAD((char*)v->Data(),TRUE);
2606}

◆ jjLOAD_E()

static BOOLEAN jjLOAD_E ( leftv  ,
leftv  v,
leftv  u 
)
static

Definition at line 2607 of file iparith.cc.

2608{
2609 char * s=(char *)u->Data();
2610 if(strcmp(s, "with")==0)
2611 return jjLOAD((char*)v->Data(), TRUE);
2612 if (strcmp(s,"try")==0)
2613 return jjLOAD_TRY((char*)v->Data());
2614 WerrorS("invalid second argument");
2615 WerrorS("load(\"libname\" [,option]);");
2616 return TRUE;
2617}
BOOLEAN jjLOAD_TRY(const char *s)
Definition: iparith.cc:5568

◆ jjLOAD_TRY()

BOOLEAN jjLOAD_TRY ( const char *  s)

Definition at line 5568 of file iparith.cc.

5569{
5570 if (!iiGetLibStatus(s))
5571 {
5572 void (*WerrorS_save)(const char *s) = WerrorS_callback;
5575 BOOLEAN bo=jjLOAD(s,TRUE);
5576 if (TEST_OPT_PROT && (bo || (WerrorS_dummy_cnt>0)))
5577 Print("loading of >%s< failed\n",s);
5578 WerrorS_callback=WerrorS_save;
5579 errorreported=0;
5580 }
5581 return FALSE;
5582}
VAR void(* WerrorS_callback)(const char *s)
Definition: feFopen.cc:21
STATIC_VAR int WerrorS_dummy_cnt
Definition: iparith.cc:5563
static void WerrorS_dummy(const char *)
Definition: iparith.cc:5564
BOOLEAN iiGetLibStatus(const char *lib)
Definition: iplib.cc:77

◆ jjLT_BI()

static BOOLEAN jjLT_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1218 of file iparith.cc.

1219{
1220 return jjGT_BI(res,v,u);
1221}
static BOOLEAN jjGT_BI(leftv res, leftv u, leftv v)
Definition: iparith.cc:1188

◆ jjLT_I()

static BOOLEAN jjLT_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1222 of file iparith.cc.

1223{
1224 res->data = (char *)(long)((int)((long)u->Data()) < (int)((long)v->Data()));
1225 return FALSE;
1226}

◆ jjLT_N()

static BOOLEAN jjLT_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1227 of file iparith.cc.

1228{
1229 return jjGT_N(res,v,u);
1230}
static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
Definition: iparith.cc:1200

◆ jjLU_DECOMP()

static BOOLEAN jjLU_DECOMP ( leftv  res,
leftv  v 
)
static

Definition at line 4579 of file iparith.cc.

4580{
4581 /* computes the LU-decomposition of a matrix M;
4582 i.e., M = P * L * U, where
4583 - P is a row permutation matrix,
4584 - L is in lower triangular form,
4585 - U is in upper row echelon form
4586 Then, we also have P * M = L * U.
4587 A list [P, L, U] is returned. */
4588 matrix mat = (const matrix)v->Data();
4589 if (!idIsConstant((ideal)mat))
4590 {
4591 WerrorS("matrix must be constant");
4592 return TRUE;
4593 }
4594 matrix pMat;
4595 matrix lMat;
4596 matrix uMat;
4597
4598 luDecomp(mat, pMat, lMat, uMat);
4599
4601 ll->Init(3);
4602 ll->m[0].rtyp=MATRIX_CMD; ll->m[0].data=(void *)pMat;
4603 ll->m[1].rtyp=MATRIX_CMD; ll->m[1].data=(void *)lMat;
4604 ll->m[2].rtyp=MATRIX_CMD; ll->m[2].data=(void *)uMat;
4605 res->data=(char*)ll;
4606
4607 return FALSE;
4608}
#define idIsConstant(I)
Definition: ideals.h:40
void luDecomp(const matrix aMat, matrix &pMat, matrix &lMat, matrix &uMat, const ring R)
LU-decomposition of a given (m x n)-matrix.

◆ jjLU_INVERSE()

static BOOLEAN jjLU_INVERSE ( leftv  res,
leftv  v 
)
static

Definition at line 7527 of file iparith.cc.

7528{
7529 /* computation of the inverse of a quadratic matrix A
7530 using the L-U-decomposition of A;
7531 There are two valid parametrisations:
7532 1) exactly one argument which is just the matrix A,
7533 2) exactly three arguments P, L, U which already
7534 realise the L-U-decomposition of A, that is,
7535 P * A = L * U, and P, L, and U satisfy the
7536 properties decribed in method 'jjLU_DECOMP';
7537 see there;
7538 If A is invertible, the list [1, A^(-1)] is returned,
7539 otherwise the list [0] is returned. Thus, the user may
7540 inspect the first entry of the returned list to see
7541 whether A is invertible. */
7542 matrix iMat; int invertible;
7543 const short t1[]={1,MATRIX_CMD};
7544 const short t2[]={3,MATRIX_CMD,MATRIX_CMD,MATRIX_CMD};
7545 if (iiCheckTypes(v,t1))
7546 {
7547 matrix aMat = (matrix)v->Data();
7548 int rr = aMat->rows();
7549 int cc = aMat->cols();
7550 if (rr != cc)
7551 {
7552 Werror("given matrix (%d x %d) is not quadratic, hence not invertible", rr, cc);
7553 return TRUE;
7554 }
7555 if (!idIsConstant((ideal)aMat))
7556 {
7557 WerrorS("matrix must be constant");
7558 return TRUE;
7559 }
7560 invertible = luInverse(aMat, iMat);
7561 }
7562 else if (iiCheckTypes(v,t2))
7563 {
7564 matrix pMat = (matrix)v->Data();
7565 matrix lMat = (matrix)v->next->Data();
7566 matrix uMat = (matrix)v->next->next->Data();
7567 int rr = uMat->rows();
7568 int cc = uMat->cols();
7569 if (rr != cc)
7570 {
7571 Werror("third matrix (%d x %d) is not quadratic, hence not invertible",
7572 rr, cc);
7573 return TRUE;
7574 }
7575 if (!idIsConstant((ideal)pMat)
7576 || (!idIsConstant((ideal)lMat))
7577 || (!idIsConstant((ideal)uMat))
7578 )
7579 {
7580 WerrorS("matricesx must be constant");
7581 return TRUE;
7582 }
7583 invertible = luInverseFromLUDecomp(pMat, lMat, uMat, iMat);
7584 }
7585 else
7586 {
7587 Werror("expected either one or three matrices");
7588 return TRUE;
7589 }
7590
7591 /* build the return structure; a list with either one or two entries */
7593 if (invertible)
7594 {
7595 ll->Init(2);
7596 ll->m[0].rtyp=INT_CMD; ll->m[0].data=(void *)(long)invertible;
7597 ll->m[1].rtyp=MATRIX_CMD; ll->m[1].data=(void *)iMat;
7598 }
7599 else
7600 {
7601 ll->Init(1);
7602 ll->m[0].rtyp=INT_CMD; ll->m[0].data=(void *)(long)invertible;
7603 }
7604
7605 res->data=(char*)ll;
7606 return FALSE;
7607}
int & cols()
Definition: matpol.h:24
int & rows()
Definition: matpol.h:23
bool luInverseFromLUDecomp(const matrix pMat, const matrix lMat, const matrix uMat, matrix &iMat, const ring R)
This code computes the inverse by inverting lMat and uMat, and then performing two matrix multiplicat...
bool luInverse(const matrix aMat, matrix &iMat, const ring R)
This code first computes the LU-decomposition of aMat, and then calls the method for inverting a matr...

◆ jjLU_SOLVE()

static BOOLEAN jjLU_SOLVE ( leftv  res,
leftv  v 
)
static

Definition at line 7608 of file iparith.cc.

7609{
7610 /* for solving a linear equation system A * x = b, via the
7611 given LU-decomposition of the matrix A;
7612 There is one valid parametrisation:
7613 1) exactly four arguments P, L, U, b;
7614 P, L, and U realise the L-U-decomposition of A, that is,
7615 P * A = L * U, and P, L, and U satisfy the
7616 properties decribed in method 'jjLU_DECOMP';
7617 see there;
7618 b is the right-hand side vector of the equation system;
7619 The method will return a list of either 1 entry or three entries:
7620 1) [0] if there is no solution to the system;
7621 2) [1, x, H] if there is at least one solution;
7622 x is any solution of the given linear system,
7623 H is the matrix with column vectors spanning the homogeneous
7624 solution space.
7625 The method produces an error if matrix and vector sizes do not fit. */
7626 const short t[]={4,MATRIX_CMD,MATRIX_CMD,MATRIX_CMD,MATRIX_CMD};
7627 if (!iiCheckTypes(v,t))
7628 {
7629 WerrorS("expected exactly three matrices and one vector as input");
7630 return TRUE;
7631 }
7632 matrix pMat = (matrix)v->Data();
7633 matrix lMat = (matrix)v->next->Data();
7634 matrix uMat = (matrix)v->next->next->Data();
7635 matrix bVec = (matrix)v->next->next->next->Data();
7636 matrix xVec; int solvable; matrix homogSolSpace;
7637 if (pMat->rows() != pMat->cols())
7638 {
7639 Werror("first matrix (%d x %d) is not quadratic",
7640 pMat->rows(), pMat->cols());
7641 return TRUE;
7642 }
7643 if (lMat->rows() != lMat->cols())
7644 {
7645 Werror("second matrix (%d x %d) is not quadratic",
7646 lMat->rows(), lMat->cols());
7647 return TRUE;
7648 }
7649 if (lMat->rows() != uMat->rows())
7650 {
7651 Werror("second matrix (%d x %d) and third matrix (%d x %d) do not fit",
7652 lMat->rows(), lMat->cols(), uMat->rows(), uMat->cols());
7653 return TRUE;
7654 }
7655 if (uMat->rows() != bVec->rows())
7656 {
7657 Werror("third matrix (%d x %d) and vector (%d x 1) do not fit",
7658 uMat->rows(), uMat->cols(), bVec->rows());
7659 return TRUE;
7660 }
7661 if (!idIsConstant((ideal)pMat)
7662 ||(!idIsConstant((ideal)lMat))
7663 ||(!idIsConstant((ideal)uMat))
7664 )
7665 {
7666 WerrorS("matrices must be constant");
7667 return TRUE;
7668 }
7669 solvable = luSolveViaLUDecomp(pMat, lMat, uMat, bVec, xVec, homogSolSpace);
7670
7671 /* build the return structure; a list with either one or three entries */
7673 if (solvable)
7674 {
7675 ll->Init(3);
7676 ll->m[0].rtyp=INT_CMD; ll->m[0].data=(void *)(long)solvable;
7677 ll->m[1].rtyp=MATRIX_CMD; ll->m[1].data=(void *)xVec;
7678 ll->m[2].rtyp=MATRIX_CMD; ll->m[2].data=(void *)homogSolSpace;
7679 }
7680 else
7681 {
7682 ll->Init(1);
7683 ll->m[0].rtyp=INT_CMD; ll->m[0].data=(void *)(long)solvable;
7684 }
7685
7686 res->data=(char*)ll;
7687 return FALSE;
7688}
bool luSolveViaLUDecomp(const matrix pMat, const matrix lMat, const matrix uMat, 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 LU-decompositi...

◆ jjMakeSub()

static Subexpr jjMakeSub ( leftv  e)
static

Definition at line 8698 of file iparith.cc.

8699{
8700 assume( e->Typ()==INT_CMD );
8701 Subexpr r=(Subexpr)omAlloc0Bin(sSubexpr_bin);
8702 r->start =(int)(long)e->Data();
8703 return r;
8704}
VAR omBin sSubexpr_bin
Definition: subexpr.cc:40

◆ jjMAP()

static BOOLEAN jjMAP ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1657 of file iparith.cc.

1658{
1659 //Print("try to map %s with %s\n",$3.Name(),$1.Name());
1660 if ((v->e==NULL)&&(v->name!=NULL)&&(v->next==NULL))
1661 {
1662 map m=(map)u->Data();
1663 leftv sl=iiMap(m,v->name);
1664 if (sl!=NULL)
1665 {
1666 memcpy(res,sl,sizeof(sleftv));
1668 return FALSE;
1669 }
1670 }
1671 else
1672 {
1673 Werror("%s(<name>) expected",u->Name());
1674 }
1675 return TRUE; /*sl==NULL or Werror*/
1676}
leftv iiMap(map theMap, const char *what)
Definition: ipshell.cc:615

◆ jjMATRIX_Id()

static BOOLEAN jjMATRIX_Id ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6740 of file iparith.cc.

6741{
6742 int mi=(int)(long)v->Data();
6743 int ni=(int)(long)w->Data();
6744 if ((mi<1)||(ni<1))
6745 {
6746 Werror("converting ideal to matrix: dimensions must be positive(%dx%d)",mi,ni);
6747 return TRUE;
6748 }
6749 matrix m=mpNew(mi,ni);
6750 ideal I=(ideal)u->CopyD(IDEAL_CMD);
6751 int i=si_min(IDELEMS(I),mi*ni);
6752 //for(i=i-1;i>=0;i--)
6753 //{
6754 // m->m[i]=I->m[i];
6755 // I->m[i]=NULL;
6756 //}
6757 memcpy(m->m,I->m,i*sizeof(poly));
6758 memset(I->m,0,i*sizeof(poly));
6759 id_Delete(&I,currRing);
6760 res->data = (char *)m;
6761 return FALSE;
6762}

◆ jjMATRIX_Ma()

static BOOLEAN jjMATRIX_Ma ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6776 of file iparith.cc.

6777{
6778 int mi=(int)(long)v->Data();
6779 int ni=(int)(long)w->Data();
6780 if ((mi<1)||(ni<1))
6781 {
6782 Werror("converting matrix to matrix: dimensions must be positive(%dx%d)",mi,ni);
6783 return TRUE;
6784 }
6785 matrix m=mpNew(mi,ni);
6787 int r=si_min(MATROWS(I),mi);
6788 int c=si_min(MATCOLS(I),ni);
6789 int i,j;
6790 for(i=r;i>0;i--)
6791 {
6792 for(j=c;j>0;j--)
6793 {
6794 MATELEM(m,i,j)=MATELEM(I,i,j);
6795 MATELEM(I,i,j)=NULL;
6796 }
6797 }
6798 id_Delete((ideal *)&I,currRing);
6799 res->data = (char *)m;
6800 return FALSE;
6801}

◆ jjMATRIX_Mo()

static BOOLEAN jjMATRIX_Mo ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6763 of file iparith.cc.

6764{
6765 int mi=(int)(long)v->Data();
6766 int ni=(int)(long)w->Data();
6767 if ((mi<0)||(ni<1))
6768 {
6769 Werror("converting module to matrix: dimensions must be positive(%dx%d)",mi,ni);
6770 return TRUE;
6771 }
6772 res->data = (char *)id_Module2formatedMatrix((ideal)u->CopyD(MODUL_CMD),
6773 mi,ni,currRing);
6774 return FALSE;
6775}

◆ jjMEMORY()

static BOOLEAN jjMEMORY ( leftv  res,
leftv  v 
)
static

Definition at line 4609 of file iparith.cc.

4610{
4611 // clean out "_":
4613 // collect all info:
4614 omUpdateInfo();
4615 switch(((int)(long)v->Data()))
4616 {
4617 case 0:
4618 res->data=(char *)n_Init(om_Info.UsedBytes,coeffs_BIGINT);
4619 break;
4620 case 1:
4621 res->data = (char *)n_Init(om_Info.CurrentBytesSystem,coeffs_BIGINT);
4622 break;
4623 case 2:
4624 res->data = (char *)n_Init(om_Info.MaxBytesSystem,coeffs_BIGINT);
4625 break;
4626 default:
4627 omPrintStats(stdout);
4628 omPrintInfo(stdout);
4629 omPrintBinStats(stdout);
4630 res->data = (char *)0;
4631 res->rtyp = NONE;
4632 }
4633 return FALSE;
4634}
omInfo_t om_Info
Definition: omStats.c:16
INST_VAR sleftv sLastPrinted
Definition: subexpr.cc:46
#define NONE
Definition: tok.h:221
#define omPrintStats(F)
Definition: xalloc.h:231
#define omPrintInfo(F)
Definition: xalloc.h:232
#define omPrintBinStats(F)
Definition: xalloc.h:233
#define omUpdateInfo()
Definition: xalloc.h:230

◆ jjMINOR_M()

static BOOLEAN jjMINOR_M ( leftv  res,
leftv  v 
)
static

Definition at line 6271 of file iparith.cc.

6272{
6273 /* Here's the use pattern for the minor command:
6274 minor ( matrix_expression m, int_expression minorSize,
6275 optional ideal_expression IasSB, optional int_expression k,
6276 optional string_expression algorithm,
6277 optional int_expression cachedMinors,
6278 optional int_expression cachedMonomials )
6279 This method here assumes that there are at least two arguments.
6280 - If IasSB is present, it must be a std basis. All minors will be
6281 reduced w.r.t. IasSB.
6282 - If k is absent, all non-zero minors will be computed.
6283 If k is present and k > 0, the first k non-zero minors will be
6284 computed.
6285 If k is present and k < 0, the first |k| minors (some of which
6286 may be zero) will be computed.
6287 If k is present and k = 0, an error is reported.
6288 - If algorithm is absent, all the following arguments must be absent too.
6289 In this case, a heuristic picks the best-suited algorithm (among
6290 Bareiss, Laplace, and Laplace with caching).
6291 If algorithm is present, it must be one of "Bareiss", "bareiss",
6292 "Laplace", "laplace", "Cache", "cache". In the cases "Cache" and
6293 "cache" two more arguments may be given, determining how many entries
6294 the cache may have at most, and how many cached monomials there are at
6295 most. (Cached monomials are counted over all cached polynomials.)
6296 If these two additional arguments are not provided, 200 and 100000
6297 will be used as defaults.
6298 */
6299 matrix m;
6300 leftv u=v->next;
6301 v->next=NULL;
6302 int v_typ=v->Typ();
6303 if (v_typ==MATRIX_CMD)
6304 {
6305 m = (const matrix)v->Data();
6306 }
6307 else
6308 {
6309 if (v_typ==0)
6310 {
6311 Werror("`%s` is undefined",v->Fullname());
6312 return TRUE;
6313 }
6314 // try to convert to MATRIX:
6315 int ii=iiTestConvert(v_typ,MATRIX_CMD);
6316 BOOLEAN bo;
6317 sleftv tmp;
6318 if (ii>0) bo=iiConvert(v_typ,MATRIX_CMD,ii,v,&tmp);
6319 else bo=TRUE;
6320 if (bo)
6321 {
6322 Werror("cannot convert %s to matrix",Tok2Cmdname(v_typ));
6323 return TRUE;
6324 }
6325 m=(matrix)tmp.data;
6326 }
6327 const int mk = (const int)(long)u->Data();
6328 bool noIdeal = true; bool noK = true; bool noAlgorithm = true;
6329 bool noCacheMinors = true; bool noCacheMonomials = true;
6330 ideal IasSB; int k; char* algorithm; int cacheMinors; int cacheMonomials;
6331
6332 /* here come the different cases of correct argument sets */
6333 if ((u->next != NULL) && (u->next->Typ() == IDEAL_CMD))
6334 {
6335 IasSB = (ideal)u->next->Data();
6336 noIdeal = false;
6337 if ((u->next->next != NULL) && (u->next->next->Typ() == INT_CMD))
6338 {
6339 k = (int)(long)u->next->next->Data();
6340 noK = false;
6341 if ((u->next->next->next != NULL) &&
6342 (u->next->next->next->Typ() == STRING_CMD))
6343 {
6344 algorithm = (char*)u->next->next->next->Data();
6345 noAlgorithm = false;
6346 if ((u->next->next->next->next != NULL) &&
6347 (u->next->next->next->next->Typ() == INT_CMD))
6348 {
6349 cacheMinors = (int)(long)u->next->next->next->next->Data();
6350 noCacheMinors = false;
6351 if ((u->next->next->next->next->next != NULL) &&
6352 (u->next->next->next->next->next->Typ() == INT_CMD))
6353 {
6354 cacheMonomials =
6355 (int)(long)u->next->next->next->next->next->Data();
6356 noCacheMonomials = false;
6357 }
6358 }
6359 }
6360 }
6361 }
6362 else if ((u->next != NULL) && (u->next->Typ() == INT_CMD))
6363 {
6364 k = (int)(long)u->next->Data();
6365 noK = false;
6366 if ((u->next->next != NULL) && (u->next->next->Typ() == STRING_CMD))
6367 {
6368 algorithm = (char*)u->next->next->Data();
6369 noAlgorithm = false;
6370 if ((u->next->next->next != NULL) &&
6371 (u->next->next->next->Typ() == INT_CMD))
6372 {
6373 cacheMinors = (int)(long)u->next->next->next->Data();
6374 noCacheMinors = false;
6375 if ((u->next->next->next->next != NULL) &&
6376 (u->next->next->next->next->Typ() == INT_CMD))
6377 {
6378 cacheMonomials = (int)(long)u->next->next->next->next->Data();
6379 noCacheMonomials = false;
6380 }
6381 }
6382 }
6383 }
6384 else if ((u->next != NULL) && (u->next->Typ() == STRING_CMD))
6385 {
6386 algorithm = (char*)u->next->Data();
6387 noAlgorithm = false;
6388 if ((u->next->next != NULL) && (u->next->next->Typ() == INT_CMD))
6389 {
6390 cacheMinors = (int)(long)u->next->next->Data();
6391 noCacheMinors = false;
6392 if ((u->next->next->next != NULL) &&
6393 (u->next->next->next->Typ() == INT_CMD))
6394 {
6395 cacheMonomials = (int)(long)u->next->next->next->Data();
6396 noCacheMonomials = false;
6397 }
6398 }
6399 }
6400
6401 /* upper case conversion for the algorithm if present */
6402 if (!noAlgorithm)
6403 {
6404 if (strcmp(algorithm, "bareiss") == 0)
6405 algorithm = (char*)"Bareiss";
6406 if (strcmp(algorithm, "laplace") == 0)
6407 algorithm = (char*)"Laplace";
6408 if (strcmp(algorithm, "cache") == 0)
6409 algorithm = (char*)"Cache";
6410 }
6411
6412 v->next=u;
6413 /* here come some tests */
6414 if (!noIdeal)
6415 {
6416 assumeStdFlag(u->next);
6417 }
6418 if ((!noK) && (k == 0))
6419 {
6420 WerrorS("Provided number of minors to be computed is zero.");
6421 return TRUE;
6422 }
6423 if ((!noAlgorithm) && (strcmp(algorithm, "Bareiss") != 0)
6424 && (strcmp(algorithm, "Laplace") != 0)
6425 && (strcmp(algorithm, "Cache") != 0))
6426 {
6427 WerrorS("Expected as algorithm one of 'B/bareiss', 'L/laplace', or 'C/cache'.");
6428 return TRUE;
6429 }
6430 if ((!noAlgorithm) && (strcmp(algorithm, "Bareiss") == 0)
6432 {
6433 Werror("Bareiss algorithm not defined over coefficient rings %s",
6434 "with zero divisors.");
6435 return TRUE;
6436 }
6437 if ((mk < 1) || (mk > m->rows()) || (mk > m->cols()))
6438 {
6439 ideal I=idInit(1,1);
6440 if (mk<1) I->m[0]=p_One(currRing);
6441 //Werror("invalid size of minors: %d (matrix is (%d x %d))", mk,
6442 // m->rows(), m->cols());
6443 res->data=(void*)I;
6444 return FALSE;
6445 }
6446 if ((!noAlgorithm) && (strcmp(algorithm, "Cache") == 0)
6447 && (noCacheMinors || noCacheMonomials))
6448 {
6449 cacheMinors = 200;
6450 cacheMonomials = 100000;
6451 }
6452
6453 /* here come the actual procedure calls */
6454 if (noAlgorithm)
6455 res->data = getMinorIdealHeuristic(m, mk, (noK ? 0 : k),
6456 (noIdeal ? 0 : IasSB), false);
6457 else if (strcmp(algorithm, "Cache") == 0)
6458 res->data = getMinorIdealCache(m, mk, (noK ? 0 : k),
6459 (noIdeal ? 0 : IasSB), 3, cacheMinors,
6460 cacheMonomials, false);
6461 else
6462 res->data = getMinorIdeal(m, mk, (noK ? 0 : k), algorithm,
6463 (noIdeal ? 0 : IasSB), false);
6464 if (v_typ!=MATRIX_CMD) idDelete((ideal *)&m);
6465 return FALSE;
6466}
ideal getMinorIdealCache(const matrix mat, const int minorSize, const int k, const ideal iSB, const int cacheStrategy, const int cacheN, const int cacheW, const bool allDifferent)
Returns the specified set of minors (= subdeterminantes) of the given matrix.
ideal getMinorIdeal(const matrix mat, const int minorSize, const int k, const char *algorithm, const ideal iSB, const bool allDifferent)
Returns the specified set of minors (= subdeterminantes) of the given matrix.
ideal getMinorIdealHeuristic(const matrix mat, const int minorSize, const int k, const ideal iSB, const bool allDifferent)
Returns the specified set of minors (= subdeterminantes) of the given matrix.
poly p_One(const ring r)
Definition: p_polys.cc:1313

◆ jjMINRES_R()

static BOOLEAN jjMINRES_R ( leftv  res,
leftv  v 
)
static

Definition at line 4660 of file iparith.cc.

4661{
4662 intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
4663
4664 syStrategy tmp=(syStrategy)v->Data();
4665 tmp = syMinimize(tmp); // enrich itself!
4666
4667 res->data=(char *)tmp;
4668
4669 if (weights!=NULL)
4670 atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
4671
4672 return FALSE;
4673}
syStrategy syMinimize(syStrategy syzstr)
Definition: syz1.cc:2393
ssyStrategy * syStrategy
Definition: syz.h:36

◆ jjMINUS_B()

static BOOLEAN jjMINUS_B ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 924 of file iparith.cc.

925{
927 poly p=(poly)u->CopyD(POLY_CMD);
928 int l=pLength(p);
930 p= (poly)v->CopyD(POLY_CMD);
931 p=p_Neg(p,currRing);
932 l=pLength(p);
934 res->data=(void*)b;
935 return jjPLUSMINUS_Gen(res,u,v);
936}
static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
Definition: iparith.cc:636
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1109
static unsigned pLength(poly a)
Definition: p_polys.h:191
void sBucket_Add_p(sBucket_pt bucket, poly p, int length)
adds poly p to bucket destroys p!
Definition: sbuckets.cc:203
sBucket_pt sBucketCreate(const ring r)
Definition: sbuckets.cc:96

◆ jjMINUS_B_P()

static BOOLEAN jjMINUS_B_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 914 of file iparith.cc.

915{
917 poly p= (poly)v->CopyD(POLY_CMD);
918 int l=pLength(p);
919 p=p_Neg(p,currRing);
921 res->data=(void*)b;
922 return jjPLUSMINUS_Gen(res,u,v);
923}
@ BUCKET_CMD
Definition: grammar.cc:283

◆ jjMINUS_BI()

static BOOLEAN jjMINUS_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 899 of file iparith.cc.

900{
901 res->data = (char *)(n_Sub((number)u->Data(), (number)v->Data(),coeffs_BIGINT));
902 return jjPLUSMINUS_Gen(res,u,v);
903}

◆ jjMINUS_BIM()

static BOOLEAN jjMINUS_BIM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 947 of file iparith.cc.

948{
949 res->data = (char *)bimSub((bigintmat*)(u->Data()), (bigintmat*)(v->Data()));
950 if (res->data==NULL)
951 {
952 WerrorS("bigintmat/cmatrix not compatible");
953 return TRUE;
954 }
955 return jjPLUSMINUS_Gen(res,u,v);
956}
bigintmat * bimSub(bigintmat *a, bigintmat *b)
Definition: bigintmat.cc:218

◆ jjMINUS_I()

static BOOLEAN jjMINUS_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 883 of file iparith.cc.

884{
885 void *ap=u->Data(); void *bp=v->Data();
886 long aa=(long)ap;
887 long bb=(long)bp;
888 long cc=aa-bb;
889 unsigned long a=(unsigned long)ap;
890 unsigned long b=(unsigned long)bp;
891 unsigned long c=a-b;
892 if (((Sy_bitL(bit31)&a)!=(Sy_bitL(bit31)&b))&&((Sy_bitL(bit31)&a)!=(Sy_bitL(bit31)&c)))
893 {
894 WarnS("int overflow(-), result may be wrong");
895 }
896 res->data = (char *)cc;
897 return jjPLUSMINUS_Gen(res,u,v);
898}
#define bit31
Definition: iparith.cc:124
Definition: ap.h:40
#define Sy_bitL(x)
Definition: options.h:32

◆ jjMINUS_IV()

static BOOLEAN jjMINUS_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 937 of file iparith.cc.

938{
939 res->data = (char *)ivSub((intvec*)(u->Data()), (intvec*)(v->Data()));
940 if (res->data==NULL)
941 {
942 WerrorS("intmat size not compatible");
943 return TRUE;
944 }
945 return jjPLUSMINUS_Gen(res,u,v);
946}
intvec * ivSub(intvec *a, intvec *b)
Definition: intvec.cc:297

◆ jjMINUS_MA()

static BOOLEAN jjMINUS_MA ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 957 of file iparith.cc.

958{
959 matrix A=(matrix)u->Data(); matrix B=(matrix)v->Data();
960 res->data = (char *)(mp_Sub(A , B, currRing));
961 if (res->data==NULL)
962 {
963 Werror("matrix size not compatible(%dx%d, %dx%d)",
965 return TRUE;
966 }
967 return jjPLUSMINUS_Gen(res,u,v);
968 return FALSE;
969}
b *CanonicalForm B
Definition: facBivar.cc:52
matrix mp_Sub(matrix a, matrix b, const ring R)
Definition: matpol.cc:196
#define A
Definition: sirandom.c:24

◆ jjMINUS_N()

static BOOLEAN jjMINUS_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 904 of file iparith.cc.

905{
906 res->data = (char *)(nSub((number)u->Data(), (number)v->Data()));
907 return jjPLUSMINUS_Gen(res,u,v);
908}
#define nSub(n1, n2)
Definition: numbers.h:22

◆ jjMINUS_SM()

static BOOLEAN jjMINUS_SM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 970 of file iparith.cc.

971{
972 ideal A=(ideal)u->Data(); ideal B=(ideal)v->Data();
973 res->data = (char *)(sm_Sub(A , B, currRing));
974 if (res->data==NULL)
975 {
976 Werror("matrix size not compatible(%dx%d, %dx%d)",
977 (int)A->rank,IDELEMS(A),(int)B->rank,IDELEMS(B));
978 return TRUE;
979 }
980 return jjPLUSMINUS_Gen(res,u,v);
981 return FALSE;
982}
ideal sm_Sub(ideal a, ideal b, const ring R)
Definition: matpol.cc:1881

◆ jjMINUS_V()

static BOOLEAN jjMINUS_V ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 909 of file iparith.cc.

910{
911 res->data = (char *)(pSub((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
912 return jjPLUSMINUS_Gen(res,u,v);
913}
#define pSub(a, b)
Definition: polys.h:287

◆ jjMOD_BI()

static BOOLEAN jjMOD_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2671 of file iparith.cc.

2672{
2673 number q=(number)v->Data();
2674 if (n_IsZero(q,coeffs_BIGINT))
2675 {
2677 return TRUE;
2678 }
2679 res->data =(char *) n_IntMod((number)u->Data(),q,coeffs_BIGINT);
2680 return FALSE;
2681}
static FORCE_INLINE number n_IntMod(number a, number b, const coeffs r)
for r a field, return n_Init(0,r) always: n_Div(a,b,r)*b+n_IntMod(a,b,r)==a n_IntMod(a,...
Definition: coeffs.h:628

◆ jjMOD_N()

static BOOLEAN jjMOD_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2682 of file iparith.cc.

2683{
2684 number q=(number)v->Data();
2685 if (nIsZero(q))
2686 {
2688 return TRUE;
2689 }
2690 res->data =(char *) n_IntMod((number)u->Data(),q,currRing->cf);
2691 return FALSE;
2692}

◆ jjMOD_P()

static BOOLEAN jjMOD_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2693 of file iparith.cc.

2694{
2695 poly q=(poly)v->Data();
2696 if (q==NULL)
2697 {
2699 return TRUE;
2700 }
2701 poly p=(poly)(u->Data());
2702 if (p==NULL)
2703 {
2704 res->data=NULL;
2705 return FALSE;
2706 }
2707 res->data=(void*)(singclap_pmod(p /*(poly)(u->Data())*/ ,
2708 q /*(poly)(v->Data())*/ ,currRing));
2709 return FALSE;
2710}
poly singclap_pmod(poly f, poly g, const ring r)
Definition: clapsing.cc:702

◆ jjMODULO()

static BOOLEAN jjMODULO ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2618 of file iparith.cc.

2619{
2620 intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
2621 tHomog hom=testHomog;
2622 if (w_u!=NULL)
2623 {
2624 //PrintS("modulo: wu:");w_u->show(INTVEC_CMD);PrintLn();
2625 w_u=ivCopy(w_u);
2626 hom=isHomog;
2627 }
2628 //else PrintS("modulo: wu:none\n");
2629 intvec *w_v=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
2630 if (w_v!=NULL)
2631 {
2632 //PrintS("modulo: wv:");w_v->show(INTVEC_CMD);PrintLn();
2633 w_v=ivCopy(w_v);
2634 hom=isHomog;
2635 }
2636 //else PrintS("modulo: wv:none\n");
2637 if ((w_u!=NULL) && (w_v==NULL))
2638 w_v=ivCopy(w_u);
2639 if ((w_v!=NULL) && (w_u==NULL))
2640 w_u=ivCopy(w_v);
2641 ideal u_id=(ideal)u->Data();
2642 ideal v_id=(ideal)v->Data();
2643 if (w_u!=NULL)
2644 {
2645 if ((*w_u).compare((w_v))!=0)
2646 {
2647 WarnS("incompatible weights");
2648 delete w_u; w_u=NULL;
2649 hom=testHomog;
2650 }
2651 else
2652 {
2653 if ((!idTestHomModule(u_id,currRing->qideal,w_v))
2654 || (!idTestHomModule(v_id,currRing->qideal,w_v)))
2655 {
2656 WarnS("wrong weights");
2657 delete w_u; w_u=NULL;
2658 hom=testHomog;
2659 }
2660 }
2661 }
2662 res->data = (char *)idModulo(u_id,v_id ,hom,&w_u);
2663 if (w_u!=NULL)
2664 {
2665 atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
2666 }
2667 delete w_v;
2668 //if (TEST_OPT_RETURN_SB) setFlag(res,FLAG_STD);
2669 return FALSE;
2670}
ideal idModulo(ideal h2, ideal h1, tHomog hom, intvec **w, matrix *T, GbVariant alg)
Definition: ideals.cc:2414
tHomog
Definition: structs.h:35
@ isHomog
Definition: structs.h:37

◆ jjMODULO3()

static BOOLEAN jjMODULO3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6802 of file iparith.cc.

6803{
6804 if (w->rtyp!=IDHDL) return TRUE; /* idhdhl required */
6805 intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
6806 tHomog hom=testHomog;
6807 if (w_u!=NULL)
6808 {
6809 w_u=ivCopy(w_u);
6810 hom=isHomog;
6811 }
6812 intvec *w_v=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
6813 if (w_v!=NULL)
6814 {
6815 w_v=ivCopy(w_v);
6816 hom=isHomog;
6817 }
6818 if ((w_u!=NULL) && (w_v==NULL))
6819 w_v=ivCopy(w_u);
6820 if ((w_v!=NULL) && (w_u==NULL))
6821 w_u=ivCopy(w_v);
6822 ideal u_id=(ideal)u->Data();
6823 ideal v_id=(ideal)v->Data();
6824 if (w_u!=NULL)
6825 {
6826 if ((*w_u).compare((w_v))!=0)
6827 {
6828 WarnS("incompatible weights");
6829 delete w_u; w_u=NULL;
6830 hom=testHomog;
6831 }
6832 else
6833 {
6834 if ((!idTestHomModule(u_id,currRing->qideal,w_v))
6835 || (!idTestHomModule(v_id,currRing->qideal,w_v)))
6836 {
6837 WarnS("wrong weights");
6838 delete w_u; w_u=NULL;
6839 hom=testHomog;
6840 }
6841 }
6842 }
6843 idhdl h=(idhdl)w->data;
6844 res->data = (char *)idModulo(u_id,v_id ,hom,&w_u, &(h->data.umatrix));
6845 if (w_u!=NULL)
6846 {
6847 atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
6848 }
6849 delete w_v;
6850 //if (TEST_OPT_RETURN_SB) setFlag(res,FLAG_STD);
6851 return FALSE;
6852}

◆ jjMODULO3S()

static BOOLEAN jjMODULO3S ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6853 of file iparith.cc.

6854{
6855 if (w->rtyp!=IDHDL) return TRUE; /* idhdhl required */
6856 intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
6857 tHomog hom=testHomog;
6858 if (w_u!=NULL)
6859 {
6860 w_u=ivCopy(w_u);
6861 hom=isHomog;
6862 }
6863 intvec *w_v=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
6864 if (w_v!=NULL)
6865 {
6866 w_v=ivCopy(w_v);
6867 hom=isHomog;
6868 }
6869 if ((w_u!=NULL) && (w_v==NULL))
6870 w_v=ivCopy(w_u);
6871 if ((w_v!=NULL) && (w_u==NULL))
6872 w_u=ivCopy(w_v);
6873 ideal u_id=(ideal)u->Data();
6874 GbVariant alg=syGetAlgorithm((char*)w->Data(),currRing,u_id);
6875 ideal v_id=(ideal)v->Data();
6876 if (w_u!=NULL)
6877 {
6878 if ((*w_u).compare((w_v))!=0)
6879 {
6880 WarnS("incompatible weights");
6881 delete w_u; w_u=NULL;
6882 hom=testHomog;
6883 }
6884 else
6885 {
6886 if ((!idTestHomModule(u_id,currRing->qideal,w_v))
6887 || (!idTestHomModule(v_id,currRing->qideal,w_v)))
6888 {
6889 WarnS("wrong weights");
6890 delete w_u; w_u=NULL;
6891 hom=testHomog;
6892 }
6893 }
6894 }
6895 res->data = (char *)idModulo(u_id,v_id ,hom,&w_u, NULL,alg);
6896 if (w_u!=NULL)
6897 {
6898 atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
6899 }
6900 delete w_v;
6901 //if (TEST_OPT_RETURN_SB) setFlag(res,FLAG_STD);
6902 return FALSE;
6903}

◆ jjMODULO4()

static BOOLEAN jjMODULO4 ( leftv  res,
leftv  u 
)
static

Definition at line 8029 of file iparith.cc.

8030{
8031 leftv v=u->next;
8032 leftv w=v->next;
8033 leftv u4=w->next;
8034 GbVariant alg;
8035 ideal u_id,v_id;
8036 // we have 4 arguments
8037 const short t1[]={4,IDEAL_CMD,IDEAL_CMD,MATRIX_CMD,STRING_CMD};
8038 const short t2[]={4,MODUL_CMD,MODUL_CMD,MATRIX_CMD,STRING_CMD};
8039 if(iiCheckTypes(u,t1)||iiCheckTypes(u,t2)||(w->rtyp!=IDHDL))
8040 {
8041 u_id=(ideal)u->Data();
8042 v_id=(ideal)v->Data();
8043 alg=syGetAlgorithm((char*)u4->Data(),currRing,u_id);
8044 }
8045 else
8046 {
8047 Werror("%s(`ideal/module`,`ideal/module`[,`matrix`][,`string`]) expected",Tok2Cmdname(iiOp));
8048 return TRUE;
8049 }
8050 intvec *w_u=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
8051 tHomog hom=testHomog;
8052 if (w_u!=NULL)
8053 {
8054 w_u=ivCopy(w_u);
8055 hom=isHomog;
8056 }
8057 intvec *w_v=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
8058 if (w_v!=NULL)
8059 {
8060 w_v=ivCopy(w_v);
8061 hom=isHomog;
8062 }
8063 if ((w_u!=NULL) && (w_v==NULL))
8064 w_v=ivCopy(w_u);
8065 if ((w_v!=NULL) && (w_u==NULL))
8066 w_u=ivCopy(w_v);
8067 if (w_u!=NULL)
8068 {
8069 if ((*w_u).compare((w_v))!=0)
8070 {
8071 WarnS("incompatible weights");
8072 delete w_u; w_u=NULL;
8073 hom=testHomog;
8074 }
8075 else
8076 {
8077 if ((!idTestHomModule(u_id,currRing->qideal,w_v))
8078 || (!idTestHomModule(v_id,currRing->qideal,w_v)))
8079 {
8080 WarnS("wrong weights");
8081 delete w_u; w_u=NULL;
8082 hom=testHomog;
8083 }
8084 }
8085 }
8086 idhdl h=(idhdl)w->data;
8087 res->data = (char *)idModulo(u_id,v_id ,hom,&w_u, &(h->data.umatrix),alg);
8088 if (w_u!=NULL)
8089 {
8090 atSet(res,omStrDup("isHomog"),w_u,INTVEC_CMD);
8091 }
8092 delete w_v;
8093 //if (TEST_OPT_RETURN_SB) setFlag(res,FLAG_STD);
8094 return FALSE;
8095}

◆ jjMONITOR1()

static BOOLEAN jjMONITOR1 ( leftv  res,
leftv  v 
)
static

Definition at line 2712 of file iparith.cc.

2713{
2714 return jjMONITOR2(res,v,NULL);
2715}
static BOOLEAN jjMONITOR2(leftv res, leftv u, leftv v)
Definition: iparith.cc:2716

◆ jjMONITOR2()

static BOOLEAN jjMONITOR2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2716 of file iparith.cc.

2717{
2718#if 0
2719 char *opt=(char *)v->Data();
2720 int mode=0;
2721 while(*opt!='\0')
2722 {
2723 if (*opt=='i') mode |= SI_PROT_I;
2724 else if (*opt=='o') mode |= SI_PROT_O;
2725 opt++;
2726 }
2727 monitor((char *)(u->Data()),mode);
2728#else
2729 si_link l=(si_link)u->Data();
2730 if (slOpen(l,SI_LINK_WRITE,u)) return TRUE;
2731 if(strcmp(l->m->type,"ASCII")!=0)
2732 {
2733 Werror("ASCII link required, not `%s`",l->m->type);
2734 slClose(l);
2735 return TRUE;
2736 }
2737 SI_LINK_SET_CLOSE_P(l); // febase handles the FILE*
2738 if ( l->name[0]!='\0') // "" is the stop condition
2739 {
2740 const char *opt;
2741 int mode=0;
2742 if (v==NULL) opt=(const char*)"i";
2743 else opt=(const char *)v->Data();
2744 while(*opt!='\0')
2745 {
2746 if (*opt=='i') mode |= SI_PROT_I;
2747 else if (*opt=='o') mode |= SI_PROT_O;
2748 opt++;
2749 }
2750 monitor((FILE *)l->data,mode);
2751 }
2752 else
2753 monitor(NULL,0);
2754 return FALSE;
2755#endif
2756}
void monitor(void *F, int mode)
Definition: febase.cc:68
#define SI_PROT_O
Definition: reporter.h:54
#define SI_PROT_I
Definition: reporter.h:53

◆ jjMONOM()

static BOOLEAN jjMONOM ( leftv  res,
leftv  v 
)
static

Definition at line 2757 of file iparith.cc.

2758{
2759 intvec *iv=(intvec *)v->Data();
2760 poly p=pOne();
2761 int e;
2762 BOOLEAN err=FALSE;
2763 for(unsigned i=si_min(currRing->N,iv->length()); i>0; i--)
2764 {
2765 e=(*iv)[i-1];
2766 if (e>=0) pSetExp(p,i,e);
2767 else err=TRUE;
2768 }
2769 if (iv->length()==(currRing->N+1))
2770 {
2771 res->rtyp=VECTOR_CMD;
2772 e=(*iv)[currRing->N];
2773 if (e>=0) pSetComp(p,e);
2774 else err=TRUE;
2775 }
2776 pSetm(p);
2777 res->data=(char*)p;
2778 if(err) { pDelete(&p); WerrorS("no negative exponent allowed"); }
2779 return err;
2780}

◆ jjmpTrace()

static BOOLEAN jjmpTrace ( leftv  res,
leftv  v 
)
static

Definition at line 5642 of file iparith.cc.

5643{
5644 res->data = (char *)mp_Trace((matrix)v->Data(),currRing);
5645 return FALSE;
5646}
poly mp_Trace(matrix a, const ring R)
Definition: matpol.cc:275

◆ jjmpTransp()

static BOOLEAN jjmpTransp ( leftv  res,
leftv  v 
)
static

Definition at line 5647 of file iparith.cc.

5648{
5649 res->data = (char *)mp_Transp((matrix)v->Data(),currRing);
5650 return FALSE;
5651}
matrix mp_Transp(matrix a, const ring R)
Definition: matpol.cc:254

◆ jjMSTD()

static BOOLEAN jjMSTD ( leftv  res,
leftv  v 
)
static

Definition at line 4639 of file iparith.cc.

4640{
4641 int t=v->Typ();
4642 ideal r,m;
4643 r=kMin_std((ideal)v->Data(),currRing->qideal,testHomog,NULL,m);
4645 l->Init(2);
4646 l->m[0].rtyp=t;
4647 l->m[0].data=(char *)r;
4648 setFlag(&(l->m[0]),FLAG_STD);
4649 l->m[1].rtyp=t;
4650 l->m[1].data=(char *)m;
4651 res->data=(char *)l;
4652 return FALSE;
4653}
ideal kMin_std(ideal F, ideal Q, tHomog h, intvec **w, ideal &M, intvec *hilb, int syzComp, int reduced)
Definition: kstd1.cc:3019

◆ jjMULT()

static BOOLEAN jjMULT ( leftv  res,
leftv  v 
)
static

Definition at line 4654 of file iparith.cc.

4655{
4657 res->data = (char *)(long)scMultInt((ideal)(v->Data()),currRing->qideal);
4658 return FALSE;
4659}
int scMultInt(ideal S, ideal Q)
Definition: hdegree.cc:903

◆ jjN2BI()

static BOOLEAN jjN2BI ( leftv  res,
leftv  v 
)
static

Definition at line 4674 of file iparith.cc.

4675{
4676 number n,i; i=(number)v->Data();
4678 if (nMap!=NULL)
4679 n=nMap(i,currRing->cf,coeffs_BIGINT);
4680 else goto err;
4681 res->data=(void *)n;
4682 return FALSE;
4683err:
4684 WerrorS("cannot convert to bigint"); return TRUE;
4685}

◆ jjNAMEOF()

static BOOLEAN jjNAMEOF ( leftv  res,
leftv  v 
)
static

Definition at line 4686 of file iparith.cc.

4687{
4688 if ((v->rtyp==IDHDL)||(v->rtyp==ALIAS_CMD))
4689 res->data=omStrDup(v->name);
4690 else if (v->name==NULL)
4691 res->data=omStrDup("");
4692 else
4693 {
4694 res->data = (char *)v->name;
4695 v->name=NULL;
4696 }
4697 return FALSE;
4698}

◆ jjNAMES()

static BOOLEAN jjNAMES ( leftv  res,
leftv  v 
)
static

Definition at line 4699 of file iparith.cc.

4700{
4701 res->data=ipNameList(((ring)v->Data())->idroot);
4702 return FALSE;
4703}
lists ipNameList(idhdl root)
Definition: ipid.cc:627

◆ jjNAMES0()

static BOOLEAN jjNAMES0 ( leftv  res,
leftv   
)
static

Definition at line 8096 of file iparith.cc.

8097{
8098 res->data=(void *)ipNameList(IDROOT);
8099 return FALSE;
8100}

◆ jjNAMES_I()

static BOOLEAN jjNAMES_I ( leftv  res,
leftv  v 
)
static

Definition at line 4704 of file iparith.cc.

4705{
4706 res->data=ipNameListLev((IDROOT),(int)(long)v->Data());
4707 return FALSE;
4708}
lists ipNameListLev(idhdl root, int lev)
Definition: ipid.cc:650

◆ jjNEWSTRUCT2()

static BOOLEAN jjNEWSTRUCT2 ( leftv  ,
leftv  u,
leftv  v 
)
static

Definition at line 2781 of file iparith.cc.

2782{
2783 // u: the name of the new type
2784 // v: the elements
2785 const char *s=(const char *)u->Data();
2786 newstruct_desc d=NULL;
2787 if (strlen(s)>=2)
2788 {
2789 d=newstructFromString((const char *)v->Data());
2790 if (d!=NULL) newstruct_setup(s,d);
2791 }
2792 else WerrorS("name of newstruct must be longer than 1 character");
2793 return d==NULL;
2794}
void newstruct_setup(const char *n, newstruct_desc d)
Definition: newstruct.cc:688
newstruct_desc newstructFromString(const char *s)
Definition: newstruct.cc:792

◆ jjNEWSTRUCT3()

static BOOLEAN jjNEWSTRUCT3 ( leftv  ,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6467 of file iparith.cc.

6468{
6469 // u: the name of the new type
6470 // v: the parent type
6471 // w: the elements
6472 newstruct_desc d=newstructChildFromString((const char *)v->Data(),
6473 (const char *)w->Data());
6474 if (d!=NULL) newstruct_setup((const char *)u->Data(),d);
6475 return (d==NULL);
6476}
newstruct_desc newstructChildFromString(const char *parent, const char *s)
Definition: newstruct.cc:799

◆ jjnInt()

static BOOLEAN jjnInt ( leftv  res,
leftv  u 
)
static

Definition at line 5682 of file iparith.cc.

5683{
5684 number n=(number)u->CopyD(); // n_Int may call n_Normalize
5685 res->data=(char *)(long)iin_Int(n,currRing->cf);
5686 n_Delete(&n,currRing->cf);
5687 return FALSE;
5688}
static int iin_Int(number &n, coeffs cf)
Definition: iparith.cc:225

◆ jjnlInt()

static BOOLEAN jjnlInt ( leftv  res,
leftv  u 
)
static

Definition at line 5689 of file iparith.cc.

5690{
5691 number n=(number)u->Data();
5692 res->data=(char *)(long)iin_Int(n,coeffs_BIGINT );
5693 return FALSE;
5694}

◆ jjNOT()

static BOOLEAN jjNOT ( leftv  res,
leftv  v 
)
static

Definition at line 4709 of file iparith.cc.

4710{
4711 res->data=(char*)(long)((long)v->Data()==0 ? 1 : 0);
4712 return FALSE;
4713}

◆ jjNULL()

static BOOLEAN jjNULL ( leftv  ,
leftv   
)
static

Definition at line 3696 of file iparith.cc.

3697{
3698 return FALSE;
3699}

◆ jjNUMERATOR()

static BOOLEAN jjNUMERATOR ( leftv  res,
leftv  v 
)
static

Return the numerator of the input number.

Definition at line 3995 of file iparith.cc.

3996{
3997 number n = reinterpret_cast<number>(v->CopyD());
3998 res->data = reinterpret_cast<void*>(n_GetNumerator(n, currRing->cf));
3999 n_Delete(&n,currRing->cf);
4000 return FALSE;
4001}
static FORCE_INLINE number n_GetNumerator(number &n, const coeffs r)
return the numerator of n (if elements of r are by nature not fractional, result is n)
Definition: coeffs.h:608

◆ jjNVARS()

static BOOLEAN jjNVARS ( leftv  res,
leftv  v 
)
static

Definition at line 4714 of file iparith.cc.

4715{
4716 res->data = (char *)(long)(((ring)(v->Data()))->N);
4717 return FALSE;
4718}

◆ jjOP_BI_BIM()

static BOOLEAN jjOP_BI_BIM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 283 of file iparith.cc.

284{
285 return jjOP_BIM_BI(res, v, u);
286}
static BOOLEAN jjOP_BIM_BI(leftv res, leftv u, leftv v)
Definition: iparith.cc:270

◆ jjOP_BIM_BI()

static BOOLEAN jjOP_BIM_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 270 of file iparith.cc.

271{
272 bigintmat* aa= (bigintmat *)u->Data();
273 number bb = (number)(v->Data());
274 if (errorreported) return TRUE;
275 bigintmat *cc=NULL;
276 switch (iiOp)
277 {
278 case '*': cc=bimMult(aa,bb,coeffs_BIGINT); break;
279 }
280 res->data=(char *)cc;
281 return cc==NULL;
282}
bigintmat * bimMult(bigintmat *a, bigintmat *b)
Definition: bigintmat.cc:255

◆ jjOP_BIM_I()

static BOOLEAN jjOP_BIM_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 251 of file iparith.cc.

252{
253 bigintmat* aa= (bigintmat *)u->Data();
254 long bb = (long)(v->Data());
255 if (errorreported) return TRUE;
256 bigintmat *cc=NULL;
257 switch (iiOp)
258 {
259 case '+': cc=bimAdd(aa,bb); break;
260 case '-': cc=bimSub(aa,bb); break;
261 case '*': cc=bimMult(aa,bb); break;
262 }
263 res->data=(char *)cc;
264 return cc==NULL;
265}
bigintmat * bimAdd(bigintmat *a, bigintmat *b)
Matrix-Add/-Sub/-Mult so oder mit operator+/-/* ? @Note: NULL as a result means an error (non-compati...
Definition: bigintmat.cc:182

◆ jjOP_I_BIM()

static BOOLEAN jjOP_I_BIM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 266 of file iparith.cc.

267{
268 return jjOP_BIM_I(res, v, u);
269}
static BOOLEAN jjOP_BIM_I(leftv res, leftv u, leftv v)
Definition: iparith.cc:251

◆ jjOP_I_IM()

static BOOLEAN jjOP_I_IM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 323 of file iparith.cc.

324{
325 return jjOP_IM_I(res,v,u);
326}
static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
Definition: iparith.cc:308

◆ jjOP_I_IV()

static BOOLEAN jjOP_I_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 304 of file iparith.cc.

305{
306 return jjOP_IV_I(res,v,u);
307}
static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
Definition: iparith.cc:287

◆ jjOP_IM_I()

static BOOLEAN jjOP_IM_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 308 of file iparith.cc.

309{
310 intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
311 int bb = (int)(long)(v->Data());
312 int i=si_min(aa->rows(),aa->cols());
313 switch (iiOp)
314 {
315 case '+': for (;i>0;i--) IMATELEM(*aa,i,i) += bb;
316 break;
317 case '-': for (;i>0;i--) IMATELEM(*aa,i,i) -= bb;
318 break;
319 }
320 res->data=(char *)aa;
321 return FALSE;
322}
#define IMATELEM(M, I, J)
Definition: intvec.h:85

◆ jjOP_IV_I()

static BOOLEAN jjOP_IV_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 287 of file iparith.cc.

288{
289 intvec* aa= (intvec *)u->CopyD(INTVEC_CMD);
290 int bb = (int)(long)(v->Data());
291 if (errorreported) return TRUE;
292 switch (iiOp)
293 {
294 case '+': (*aa) += bb; break;
295 case '-': (*aa) -= bb; break;
296 case '*': (*aa) *= bb; break;
297 case '/':
298 case INTDIV_CMD: (*aa) /= bb; break;
299 case '%': (*aa) %= bb; break;
300 }
301 res->data=(char *)aa;
302 return FALSE;
303}

◆ jjOP_REST()

static BOOLEAN jjOP_REST ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 511 of file iparith.cc.

512{
513 if (u->Next()!=NULL)
514 {
515 u=u->next;
516 res->next = (leftv)omAllocBin(sleftv_bin);
517 return iiExprArith2(res->next,u,iiOp,v);
518 }
519 else if (v->Next()!=NULL)
520 {
521 v=v->next;
522 res->next = (leftv)omAllocBin(sleftv_bin);
523 return iiExprArith2(res->next,u,iiOp,v);
524 }
525 return FALSE;
526}

◆ jjOpenClose()

static BOOLEAN jjOpenClose ( leftv  ,
leftv  v 
)
static

Definition at line 4719 of file iparith.cc.

4720{
4721 si_link l=(si_link)v->Data();
4722 if (iiOp==OPEN_CMD) return slOpen(l, SI_LINK_OPEN,v);
4723 else { slPrepClose(l); return slClose(l);}
4724}
@ OPEN_CMD
Definition: tok.h:144

◆ jjOPPOSE()

static BOOLEAN jjOPPOSE ( leftv  res,
leftv  a,
leftv  b 
)
static

Definition at line 2960 of file iparith.cc.

2961{
2962 /* number, poly, vector, ideal, module, matrix */
2963 ring r = (ring)a->Data();
2964 if (r == currRing)
2965 {
2966 res->data = b->Data();
2967 res->rtyp = b->rtyp;
2968 return FALSE;
2969 }
2970 if (!rIsLikeOpposite(currRing, r))
2971 {
2972 Werror("%s is not an opposite ring to current ring",a->Fullname());
2973 return TRUE;
2974 }
2975 idhdl w;
2976 if( ((w=r->idroot->get(b->Name(),myynest))!=NULL) && (b->e==NULL))
2977 {
2978 int argtype = IDTYP(w);
2979 switch (argtype)
2980 {
2981 case NUMBER_CMD:
2982 {
2983 /* since basefields are equal, we can apply nCopy */
2984 res->data = nCopy((number)IDDATA(w));
2985 res->rtyp = argtype;
2986 break;
2987 }
2988 case POLY_CMD:
2989 case VECTOR_CMD:
2990 {
2991 poly q = (poly)IDDATA(w);
2992 res->data = pOppose(r,q,currRing);
2993 res->rtyp = argtype;
2994 break;
2995 }
2996 case IDEAL_CMD:
2997 case MODUL_CMD:
2998 {
2999 ideal Q = (ideal)IDDATA(w);
3000 res->data = idOppose(r,Q,currRing);
3001 res->rtyp = argtype;
3002 break;
3003 }
3004 case MATRIX_CMD:
3005 {
3006 ring save = currRing;
3007 rChangeCurrRing(r);
3008 matrix m = (matrix)IDDATA(w);
3010 rChangeCurrRing(save);
3011 ideal S = idOppose(r,Q,currRing);
3012 id_Delete(&Q, r);
3013 res->data = id_Module2Matrix(S,currRing);
3014 res->rtyp = argtype;
3015 break;
3016 }
3017 default:
3018 {
3019 WerrorS("unsupported type in oppose");
3020 return TRUE;
3021 }
3022 }
3023 }
3024 else
3025 {
3026 Werror("identifier %s not found in %s",b->Fullname(),a->Fullname());
3027 return TRUE;
3028 }
3029 return FALSE;
3030}
@ NUMBER_CMD
Definition: grammar.cc:288
ideal idOppose(ring Rop_src, ideal I, const ring Rop_dst)
opposes a module I from Rop to currRing(dst)
Definition: old.gring.cc:3381
poly pOppose(ring Rop_src, poly p, const ring Rop_dst)
opposes a vector p from Rop to currRing (dst!)
Definition: old.gring.cc:3342
BOOLEAN rIsLikeOpposite(ring rBase, ring rCandidate)
checks whether rings rBase and rCandidate could be opposite to each other returns TRUE if it is so
Definition: old.gring.cc:3315
void rChangeCurrRing(ring r)
Definition: polys.cc:15
ideal id_Matrix2Module(matrix mat, const ring R)
converts mat to module, destroys mat

◆ jjOPPOSITE()

static BOOLEAN jjOPPOSITE ( leftv  res,
leftv  a 
)
static

Definition at line 5219 of file iparith.cc.

5220{
5221#ifdef HAVE_PLURAL
5222 ring r = (ring)a->Data();
5223 //if (rIsPluralRing(r))
5224 if (r->OrdSgn==1)
5225 {
5226 res->data = rOpposite(r);
5227 }
5228 else
5229 {
5230 WarnS("opposite only for global orderings");
5231 res->data = rCopy(r);
5232 }
5233 return FALSE;
5234#else
5235 return TRUE;
5236#endif
5237}
ring rOpposite(ring src)
Definition: ring.cc:5382

◆ jjOPTION_PL()

static BOOLEAN jjOPTION_PL ( leftv  res,
leftv  v 
)
static

Definition at line 8101 of file iparith.cc.

8102{
8103 if(v==NULL)
8104 {
8105 res->data=(char *)showOption();
8106 return FALSE;
8107 }
8108 res->rtyp=NONE;
8109 return setOption(res,v);
8110}
char * showOption()
Definition: misc_ip.cc:709
void setOption(int ch)
Definition: shared.cc:1368

◆ jjOR_I()

static BOOLEAN jjOR_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1389 of file iparith.cc.

1390{
1391 res->data = (char *)((long)u->Data() || (long)v->Data());
1392 return FALSE;
1393}

◆ jjORD()

static BOOLEAN jjORD ( leftv  res,
leftv  v 
)
static

Definition at line 4725 of file iparith.cc.

4726{
4727 poly p=(poly)v->Data();
4728 res->data=(char *)( p==NULL ? -1 : currRing->pFDeg(p,currRing) );
4729 return FALSE;
4730}

◆ jjP2BI()

static BOOLEAN jjP2BI ( leftv  res,
leftv  v 
)
static

Definition at line 4771 of file iparith.cc.

4772{
4773 poly p=(poly)v->Data();
4774 if (p==NULL) { res->data=(char *)n_Init(0,coeffs_BIGINT); return FALSE; }
4775 if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
4776 {
4777 WerrorS("poly must be constant");
4778 return TRUE;
4779 }
4780 number i=pGetCoeff(p);
4781 number n;
4783 if (nMap!=NULL)
4784 n=nMap(i,currRing->cf,coeffs_BIGINT);
4785 else goto err;
4786 res->data=(void *)n;
4787 return FALSE;
4788err:
4789 WerrorS("cannot convert to bigint"); return TRUE;
4790}

◆ jjP2I()

static BOOLEAN jjP2I ( leftv  res,
leftv  v 
)
static

Definition at line 4791 of file iparith.cc.

4792{
4793 poly p=(poly)v->Data();
4794 if (p==NULL) { /*res->data=(char *)0;*/ return FALSE; }
4795 if ((pNext(p)!=NULL)|| (!pIsConstant(p)))
4796 {
4797 WerrorS("poly must be constant");
4798 return TRUE;
4799 }
4800 res->data = (char *)(long)iin_Int(pGetCoeff(p),currRing->cf);
4801 return FALSE;
4802}

◆ jjP2N()

static BOOLEAN jjP2N ( leftv  res,
leftv  v 
)
static

Definition at line 4839 of file iparith.cc.

4840{
4841 number n;
4842 poly p;
4843 if (((p=(poly)v->Data())!=NULL)
4844 && (pIsConstant(p)))
4845 {
4846 n=nCopy(pGetCoeff(p));
4847 }
4848 else
4849 {
4850 n=nInit(0);
4851 }
4852 res->data = (char *)n;
4853 return FALSE;
4854}

◆ jjPAR1()

static BOOLEAN jjPAR1 ( leftv  res,
leftv  v 
)
static

Definition at line 4731 of file iparith.cc.

4732{
4733 int i=(int)(long)v->Data();
4734 int p=0;
4735 p=rPar(currRing);
4736 if ((0<i) && (i<=p))
4737 {
4738 res->data=(char *)n_Param(i,currRing);
4739 }
4740 else
4741 {
4742 Werror("par number %d out of range 1..%d",i,p);
4743 return TRUE;
4744 }
4745 return FALSE;
4746}
static FORCE_INLINE number n_Param(const int iParameter, const coeffs r)
return the (iParameter^th) parameter as a NEW number NOTE: parameter numbering: 1....
Definition: coeffs.h:783

◆ jjPARDEG()

static BOOLEAN jjPARDEG ( leftv  res,
leftv  v 
)
static

Definition at line 4747 of file iparith.cc.

4748{
4749 number nn=(number)v->Data();
4750 res->data = (char *)(long)n_ParDeg(nn, currRing->cf);
4751 return FALSE;
4752}
static FORCE_INLINE int n_ParDeg(number n, const coeffs r)
Definition: coeffs.h:770

◆ jjPARSTR1()

static BOOLEAN jjPARSTR1 ( leftv  res,
leftv  v 
)
static

Definition at line 4753 of file iparith.cc.

4754{
4755 if (currRing==NULL)
4756 {
4757 WerrorS("no ring active (1)");
4758 return TRUE;
4759 }
4760 int i=(int)(long)v->Data();
4761 int p=0;
4762 if ((0<i) && (rParameter(currRing)!=NULL) && (i<=(p=rPar(currRing))))
4763 res->data=omStrDup(rParameter(currRing)[i-1]);
4764 else
4765 {
4766 Werror("par number %d out of range 1..%d",i,p);
4767 return TRUE;
4768 }
4769 return FALSE;
4770}

◆ jjPARSTR2()

static BOOLEAN jjPARSTR2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 2795 of file iparith.cc.

2796{
2797 idhdl h=(idhdl)u->data;
2798 int i=(int)(long)v->Data();
2799 int p=0;
2800 if ((0<i)
2801 && (rParameter(IDRING(h))!=NULL)
2802 && (i<=(p=rPar(IDRING(h)))))
2803 res->data=omStrDup(rParameter(IDRING(h))[i-1]);
2804 else
2805 {
2806 Werror("par number %d out of range 1..%d",i,p);
2807 return TRUE;
2808 }
2809 return FALSE;
2810}
#define IDRING(a)
Definition: ipid.h:127

◆ jjPFAC1()

static BOOLEAN jjPFAC1 ( leftv  res,
leftv  v 
)
static

Definition at line 4561 of file iparith.cc.

4562{
4563 /* call method jjPFAC2 with second argument = 0 (meaning that no
4564 valid bound for the prime factors has been given) */
4565 sleftv tmp;
4566 tmp.Init();
4567 tmp.rtyp = INT_CMD;
4568 return jjPFAC2(res, v, &tmp);
4569}
static BOOLEAN jjPFAC2(leftv res, leftv u, leftv v)
Definition: iparith.cc:3219

◆ jjPFAC2()

static BOOLEAN jjPFAC2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3219 of file iparith.cc.

3220{
3221 number n1; int i;
3222
3223 if ((u->Typ() == BIGINT_CMD) ||
3224 ((u->Typ() == NUMBER_CMD) && rField_is_Q(currRing)))
3225 {
3226 n1 = (number)u->CopyD();
3227 }
3228 else if (u->Typ() == INT_CMD)
3229 {
3230 i = (int)(long)u->Data();
3231 n1 = n_Init(i, coeffs_BIGINT);
3232 }
3233 else
3234 {
3235 return TRUE;
3236 }
3237
3238 i = (int)(long)v->Data();
3239
3240 lists l = primeFactorisation(n1, i);
3241 n_Delete(&n1, coeffs_BIGINT);
3242 res->data = (char*)l;
3243 return FALSE;
3244}
lists primeFactorisation(const number n, const int pBound)
Factorises a given bigint number n into its prime factors less than or equal to a given bound,...
Definition: misc_ip.cc:357

◆ jjpHead()

static BOOLEAN jjpHead ( leftv  res,
leftv  v 
)
static

Definition at line 5614 of file iparith.cc.

5615{
5616 res->data = (char *)pHead((poly)v->Data());
5617 return FALSE;
5618}

◆ jjpLength()

static BOOLEAN jjpLength ( leftv  res,
leftv  v 
)
static

Definition at line 5589 of file iparith.cc.

5590{
5591 res->data = (char *)(long)pLength((poly)v->Data());
5592 return FALSE;
5593}

◆ jjPlural_mat_mat()

static BOOLEAN jjPlural_mat_mat ( leftv  res,
leftv  a,
leftv  b 
)
static

Definition at line 2872 of file iparith.cc.

2873{
2874 if( currRing->qideal != NULL )
2875 {
2876 WerrorS("basering must NOT be a qring!");
2877 return TRUE;
2878 }
2879
2880 if (iiOp==NCALGEBRA_CMD)
2881 {
2882 return nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,currRing,false,true,false,currRing);
2883 }
2884 else
2885 {
2886 ring r=rCopy(currRing);
2887 BOOLEAN result=nc_CallPlural((matrix)a->Data(),(matrix)b->Data(),NULL,NULL,r,false,true,false,currRing);
2888 res->data=r;
2889 return result;
2890 }
2891}
BOOLEAN nc_CallPlural(matrix cc, matrix dd, poly cn, poly dn, ring r, bool bSetupQuotient, bool bCopyInput, bool bBeQuiet, ring curr, bool dummy_ring=false)
returns TRUE if there were errors analyze inputs, check them for consistency detects nc_type,...
Definition: old.gring.cc:2682
@ NCALGEBRA_CMD
Definition: tok.h:137

◆ jjPlural_mat_poly()

static BOOLEAN jjPlural_mat_poly ( leftv  res,
leftv  a,
leftv  b 
)
static

Definition at line 2852 of file iparith.cc.

2853{
2854 if( currRing->qideal != NULL )
2855 {
2856 WerrorS("basering must NOT be a qring!");
2857 return TRUE;
2858 }
2859
2860 if (iiOp==NCALGEBRA_CMD)
2861 {
2862 return nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),currRing,false,true,false,currRing);
2863 }
2864 else
2865 {
2866 ring r=rCopy(currRing);
2867 BOOLEAN result=nc_CallPlural((matrix)a->Data(),NULL,NULL,(poly)b->Data(),r,false,true,false,currRing);
2868 res->data=r;
2869 return result;
2870 }
2871}

◆ jjPlural_num_mat()

static BOOLEAN jjPlural_num_mat ( leftv  res,
leftv  a,
leftv  b 
)
static

Definition at line 2832 of file iparith.cc.

2833{
2834 if( currRing->qideal != NULL )
2835 {
2836 WerrorS("basering must NOT be a qring!");
2837 return TRUE;
2838 }
2839
2840 if (iiOp==NCALGEBRA_CMD)
2841 {
2842 return nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,currRing,false,true,false,currRing);
2843 }
2844 else
2845 {
2846 ring r=rCopy(currRing);
2847 BOOLEAN result=nc_CallPlural(NULL,(matrix)b->Data(),(poly)a->Data(),NULL,r,false,true,false,currRing);
2848 res->data=r;
2849 return result;
2850 }
2851}

◆ jjPlural_num_poly()

static BOOLEAN jjPlural_num_poly ( leftv  res,
leftv  a,
leftv  b 
)
static

Definition at line 2812 of file iparith.cc.

2813{
2814 if( currRing->qideal != NULL )
2815 {
2816 WerrorS("basering must NOT be a qring!");
2817 return TRUE;
2818 }
2819
2820 if (iiOp==NCALGEBRA_CMD)
2821 {
2822 return nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),currRing,false,true,false,currRing);
2823 }
2824 else
2825 {
2826 ring r=rCopy(currRing);
2827 BOOLEAN result=nc_CallPlural(NULL,NULL,(poly)a->Data(),(poly)b->Data(),r,false,true,false,currRing);
2828 res->data=r;
2829 return result;
2830 }
2831}

◆ jjPLUS_B()

static BOOLEAN jjPLUS_B ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 787 of file iparith.cc.

788{
789 //res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
791 poly p=(poly)u->CopyD(POLY_CMD);
792 int l=pLength(p);
794 p= (poly)v->CopyD(POLY_CMD);
795 l=pLength(p);
797 res->data=(void*)b;
798 return jjPLUSMINUS_Gen(res,u,v);
799}

◆ jjPLUS_B_P()

static BOOLEAN jjPLUS_B_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 800 of file iparith.cc.

801{
803 poly p= (poly)v->CopyD(POLY_CMD);
804 int l=pLength(p);
806 res->data=(void*)b;
807 return jjPLUSMINUS_Gen(res,u,v);
808}

◆ jjPLUS_BI()

static BOOLEAN jjPLUS_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 772 of file iparith.cc.

773{
774 res->data = (char *)(n_Add((number)u->Data(), (number)v->Data(),coeffs_BIGINT));
775 return jjPLUSMINUS_Gen(res,u,v);
776}
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
Definition: coeffs.h:650

◆ jjPLUS_BIM()

static BOOLEAN jjPLUS_BIM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 819 of file iparith.cc.

820{
821 res->data = (char *)bimAdd((bigintmat*)(u->Data()), (bigintmat*)(v->Data()));
822 if (res->data==NULL)
823 {
824 WerrorS("bigintmat/cmatrix not compatible");
825 return TRUE;
826 }
827 return jjPLUSMINUS_Gen(res,u,v);
828}

◆ jjPLUS_I()

static BOOLEAN jjPLUS_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 760 of file iparith.cc.

761{
762 unsigned long a=(unsigned long)u->Data();
763 unsigned long b=(unsigned long)v->Data();
764 unsigned long c=a+b;
765 res->data = (char *)((long)c);
766 if (((Sy_bitL(bit31)&a)==(Sy_bitL(bit31)&b))&&((Sy_bitL(bit31)&a)!=(Sy_bitL(bit31)&c)))
767 {
768 WarnS("int overflow(+), result may be wrong");
769 }
770 return jjPLUSMINUS_Gen(res,u,v);
771}

◆ jjPLUS_ID()

static BOOLEAN jjPLUS_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 878 of file iparith.cc.

879{
880 res->data = (char *)idAdd((ideal)u->Data(),(ideal)v->Data());
881 return jjPLUSMINUS_Gen(res,u,v);
882}
ideal idAdd(ideal h1, ideal h2)
h1 + h2
Definition: ideals.h:68

◆ jjPLUS_IV()

static BOOLEAN jjPLUS_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 809 of file iparith.cc.

810{
811 res->data = (char *)ivAdd((intvec*)(u->Data()), (intvec*)(v->Data()));
812 if (res->data==NULL)
813 {
814 WerrorS("intmat size not compatible");
815 return TRUE;
816 }
817 return jjPLUSMINUS_Gen(res,u,v);
818}
intvec * ivAdd(intvec *a, intvec *b)
Definition: intvec.cc:249

◆ jjPLUS_MA()

static BOOLEAN jjPLUS_MA ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 829 of file iparith.cc.

830{
831 matrix A=(matrix)u->Data(); matrix B=(matrix)v->Data();
832 res->data = (char *)(mp_Add(A , B, currRing));
833 if (res->data==NULL)
834 {
835 Werror("matrix size not compatible(%dx%d, %dx%d)",
837 return TRUE;
838 }
839 return jjPLUSMINUS_Gen(res,u,v);
840}
matrix mp_Add(matrix a, matrix b, const ring R)
Definition: matpol.cc:179

◆ jjPLUS_MA_P()

static BOOLEAN jjPLUS_MA_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 853 of file iparith.cc.

854{
855 matrix m=(matrix)u->Data();
856 matrix p= mp_InitP(m->nrows,m->ncols,(poly)(v->CopyD(POLY_CMD)),currRing);
857 if (iiOp=='+')
858 res->data = (char *)mp_Add(m , p,currRing);
859 else
860 res->data = (char *)mp_Sub(m , p,currRing);
861 idDelete((ideal *)&p);
862 return jjPLUSMINUS_Gen(res,u,v);
863}
matrix mp_InitP(int r, int c, poly p, const ring R)
make it a p * unit matrix
Definition: matpol.cc:113

◆ jjPLUS_N()

static BOOLEAN jjPLUS_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 777 of file iparith.cc.

778{
779 res->data = (char *)(nAdd((number)u->Data(), (number)v->Data()));
780 return jjPLUSMINUS_Gen(res,u,v);
781}
#define nAdd(n1, n2)
Definition: numbers.h:18

◆ jjPLUS_P_MA()

static BOOLEAN jjPLUS_P_MA ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 864 of file iparith.cc.

865{
866 return jjPLUS_MA_P(res,v,u);
867}
static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
Definition: iparith.cc:853

◆ jjPLUS_S()

static BOOLEAN jjPLUS_S ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 868 of file iparith.cc.

869{
870 char* a = (char * )(u->Data());
871 char* b = (char * )(v->Data());
872 char* r = (char * )omAlloc(strlen(a) + strlen(b) + 1);
873 strcpy(r,a);
874 strcat(r,b);
875 res->data=r;
876 return jjPLUSMINUS_Gen(res,u,v);
877}

◆ jjPLUS_SM()

static BOOLEAN jjPLUS_SM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 841 of file iparith.cc.

842{
843 ideal A=(ideal)u->Data(); ideal B=(ideal)v->Data();
844 res->data = (char *)(sm_Add(A , B, currRing));
845 if (res->data==NULL)
846 {
847 Werror("matrix size not compatible(%dx%d, %dx%d)",
848 (int)A->rank,IDELEMS(A),(int)B->rank,IDELEMS(B));
849 return TRUE;
850 }
851 return jjPLUSMINUS_Gen(res,u,v);
852}
ideal sm_Add(ideal a, ideal b, const ring R)
Definition: matpol.cc:1871

◆ jjPLUS_V()

static BOOLEAN jjPLUS_V ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 782 of file iparith.cc.

783{
784 res->data = (char *)(pAdd((poly)u->CopyD(POLY_CMD) , (poly)v->CopyD(POLY_CMD)));
785 return jjPLUSMINUS_Gen(res,u,v);
786}

◆ jjPLUSMINUS_Gen()

static BOOLEAN jjPLUSMINUS_Gen ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 636 of file iparith.cc.

637{
638 u=u->next;
639 v=v->next;
640 if (u==NULL)
641 {
642 if (v==NULL) return FALSE; /* u==NULL, v==NULL */
643 if (iiOp=='-') /* u==NULL, v<>NULL, iiOp=='-'*/
644 {
645 do
646 {
647 if (res->next==NULL)
649 leftv tmp_v=v->next;
650 v->next=NULL;
651 BOOLEAN b=iiExprArith1(res->next,v,'-');
652 v->next=tmp_v;
653 if (b)
654 return TRUE;
655 v=tmp_v;
656 res=res->next;
657 } while (v!=NULL);
658 return FALSE;
659 }
660 loop /* u==NULL, v<>NULL, iiOp=='+' */
661 {
663 res=res->next;
664 res->data = v->CopyD();
665 res->rtyp = v->Typ();
666 v=v->next;
667 if (v==NULL) return FALSE;
668 }
669 }
670 if (v!=NULL) /* u<>NULL, v<>NULL */
671 {
672 do
673 {
675 leftv tmp_u=u->next; u->next=NULL;
676 leftv tmp_v=v->next; v->next=NULL;
677 BOOLEAN b=iiExprArith2(res->next,u,iiOp,v);
678 u->next=tmp_u;
679 v->next=tmp_v;
680 if (b)
681 return TRUE;
682 u=tmp_u;
683 v=tmp_v;
684 res=res->next;
685 } while ((u!=NULL) && (v!=NULL));
686 return FALSE;
687 }
688 loop /* u<>NULL, v==NULL */
689 {
691 res=res->next;
692 res->data = u->CopyD();
693 res->rtyp = u->Typ();
694 u=u->next;
695 if (u==NULL) return FALSE;
696 }
697}

◆ jjPLUSPLUS()

static BOOLEAN jjPLUSPLUS ( leftv  ,
leftv  u 
)
static

Definition at line 3710 of file iparith.cc.

3711{
3712 if (IDTYP((idhdl)u->data)==INT_CMD)
3713 {
3714 int i=IDINT((idhdl)u->data);
3715 if (iiOp==PLUSPLUS) i++;
3716 else i--;
3717 IDDATA((idhdl)u->data)=(char *)(long)i;
3718 return FALSE;
3719 }
3720 return TRUE;
3721}
@ PLUSPLUS
Definition: grammar.cc:274
#define IDINT(a)
Definition: ipid.h:125

◆ jjpMaxComp()

static BOOLEAN jjpMaxComp ( leftv  res,
leftv  v 
)
static

Definition at line 5637 of file iparith.cc.

5638{
5639 res->data = (char *)pMaxComp((poly)v->Data());
5640 return FALSE;
5641}

◆ jjPOWER_BI()

static BOOLEAN jjPOWER_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 573 of file iparith.cc.

574{
575 int e=(int)(long)v->Data();
576 number n=(number)u->Data();
577 if (e>=0)
578 {
579 n_Power(n,e,(number*)&res->data,coeffs_BIGINT);
580 }
581 else
582 {
583 WerrorS("exponent must be non-negative");
584 return TRUE;
585 }
586 if (u!=NULL) return jjOP_REST(res,u,v);
587 return FALSE;
588}
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
Definition: coeffs.h:632
static BOOLEAN jjOP_REST(leftv res, leftv u, leftv v)
Definition: iparith.cc:511

◆ jjPOWER_I()

static BOOLEAN jjPOWER_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 527 of file iparith.cc.

528{
529 long b=(long)u->Data();
530 long e=(long)v->Data();
531 long rc = 1;
532 BOOLEAN overflow=FALSE;
533 if (e >= 0)
534 {
535 if (b==0)
536 {
537 rc=(e==0);
538 }
539 else if ((e==0)||(b==1))
540 {
541 rc= 1;
542 }
543 else if (b== -1)
544 {
545 if (e&1) rc= -1;
546 else rc= 1;
547 }
548 else
549 {
550 long oldrc;
551 while ((e--)!=0)
552 {
553 oldrc=rc;
554 rc *= b;
555 if (!overflow)
556 {
557 if(rc/b!=oldrc) overflow=TRUE;
558 }
559 }
560 if (overflow)
561 WarnS("int overflow(^), result may be wrong");
562 }
563 res->data = (char *)rc;
564 if (u!=NULL) return jjOP_REST(res,u,v);
565 return FALSE;
566 }
567 else
568 {
569 WerrorS("exponent must be non-negative");
570 return TRUE;
571 }
572}

◆ jjPOWER_ID()

static BOOLEAN jjPOWER_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 630 of file iparith.cc.

631{
632 res->data = (char *)id_Power((ideal)(u->Data()),(int)(long)(v->Data()), currRing);
633 if (u!=NULL) return jjOP_REST(res,u,v);
634 return FALSE;
635}
ideal id_Power(ideal given, int exp, const ring r)

◆ jjPOWER_N()

static BOOLEAN jjPOWER_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 589 of file iparith.cc.

590{
591 int e=(int)(long)v->Data();
592 number n=(number)u->Data();
593 int d=0;
594 if (e<0)
595 {
596 n=nInvers(n);
597 e=-e;
598 d=1;
599 }
600 number r;
601 nPower(n,e,(number*)&r);
602 res->data=(char*)r;
603 if (d) nDelete(&n);
604 if (u!=NULL) return jjOP_REST(res,u,v);
605 return FALSE;
606}
#define nInvers(a)
Definition: numbers.h:33
#define nPower(a, b, res)
Definition: numbers.h:38

◆ jjPOWER_P()

static BOOLEAN jjPOWER_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 607 of file iparith.cc.

608{
609 int v_i=(int)(long)v->Data();
610 if (v_i<0)
611 {
612 WerrorS("exponent must be non-negative");
613 return TRUE;
614 }
615 poly u_p=(poly)u->CopyD(POLY_CMD);
616 if ((u_p!=NULL)
617 && (!rIsLPRing(currRing))
618 && ((v_i!=0) &&
619 ((long)pTotaldegree(u_p) > (signed long)currRing->bitmask / (signed long)v_i/2)))
620 {
621 Werror("OVERFLOW in power(d=%ld, e=%d, max=%ld)",
622 pTotaldegree(u_p),v_i,currRing->bitmask/2);
623 pDelete(&u_p);
624 return TRUE;
625 }
626 res->data = (char *)pPower(u_p,v_i);
627 if (u!=NULL) return jjOP_REST(res,u,v);
628 return errorreported; /* pPower may set errorreported via Werror */
629}
static long pTotaldegree(poly p)
Definition: polys.h:282

◆ jjPREIMAGE()

static BOOLEAN jjPREIMAGE ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6477 of file iparith.cc.

6478{
6479 // handles preimage(r,phi,i) and kernel(r,phi)
6480 idhdl h;
6481 ring rr;
6482 map mapping;
6483 BOOLEAN kernel_cmd= (iiOp==KERNEL_CMD);
6484
6485 if ((v->name==NULL) || (!kernel_cmd && (w->name==NULL)))
6486 {
6487 WerrorS("2nd/3rd arguments must have names");
6488 return TRUE;
6489 }
6490 rr=(ring)u->Data();
6491 const char *ring_name=u->Name();
6492 if ((h=rr->idroot->get(v->name,myynest))!=NULL)
6493 {
6494 if (h->typ==MAP_CMD)
6495 {
6496 mapping=IDMAP(h);
6497 idhdl preim_ring=IDROOT->get(mapping->preimage,myynest);
6498 if ((preim_ring==NULL)
6499 || (IDRING(preim_ring)!=currRing))
6500 {
6501 Werror("preimage ring `%s` is not the basering",mapping->preimage);
6502 return TRUE;
6503 }
6504 }
6505 else if (h->typ==IDEAL_CMD)
6506 {
6507 mapping=IDMAP(h);
6508 }
6509 else
6510 {
6511 Werror("`%s` is no map nor ideal",IDID(h));
6512 return TRUE;
6513 }
6514 }
6515 else
6516 {
6517 Werror("`%s` is not defined in `%s`",v->name,ring_name);
6518 return TRUE;
6519 }
6520 ideal image;
6521 if (kernel_cmd) image=idInit(1,1);
6522 else
6523 {
6524 if ((h=rr->idroot->get(w->name,myynest))!=NULL)
6525 {
6526 if (h->typ==IDEAL_CMD)
6527 {
6528 image=IDIDEAL(h);
6529 }
6530 else
6531 {
6532 Werror("`%s` is no ideal",IDID(h));
6533 return TRUE;
6534 }
6535 }
6536 else
6537 {
6538 Werror("`%s` is not defined in `%s`",w->name,ring_name);
6539 return TRUE;
6540 }
6541 }
6542 if (((currRing->qideal!=NULL) && (rHasLocalOrMixedOrdering(currRing)))
6543 || ((rr->qideal!=NULL) && (rHasLocalOrMixedOrdering(rr))))
6544 {
6545 WarnS("preimage in local qring may be wrong: use Ring::preimageLoc instead");
6546 }
6547 res->data=(char *)maGetPreimage(rr,mapping,image,currRing);
6548 if (kernel_cmd) idDelete(&image);
6549 return (res->data==NULL/* is of type ideal, should not be NULL*/);
6550}
#define IDMAP(a)
Definition: ipid.h:135
#define IDIDEAL(a)
Definition: ipid.h:133
#define IDID(a)
Definition: ipid.h:122
ideal maGetPreimage(ring theImageRing, map theMap, ideal id, const ring dst_r)
Definition: preimage.cc:57
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
Definition: ring.h:761
@ KERNEL_CMD
Definition: tok.h:107

◆ jjPREIMAGE_R()

static BOOLEAN jjPREIMAGE_R ( leftv  res,
leftv  v 
)
static

Definition at line 4803 of file iparith.cc.

4804{
4805 map mapping=(map)v->Data();
4806 syMake(res,omStrDup(mapping->preimage));
4807 return FALSE;
4808}

◆ jjPRIME()

static BOOLEAN jjPRIME ( leftv  res,
leftv  v 
)
static

Definition at line 4809 of file iparith.cc.

4810{
4811 int i = IsPrime((int)(long)(v->Data()));
4812 res->data = (char *)(long)(i > 1 ? i : 2);
4813 return FALSE;
4814}
int IsPrime(int p)
Definition: prime.cc:61

◆ jjPROC()

BOOLEAN jjPROC ( leftv  res,
leftv  u,
leftv  v 
)

Definition at line 1621 of file iparith.cc.

1622{
1623 void *d;
1624 Subexpr e;
1625 int typ;
1626 BOOLEAN t=FALSE;
1627 idhdl tmp_proc=NULL;
1628 if ((u->rtyp!=IDHDL)||(u->e!=NULL))
1629 {
1630 tmp_proc=(idhdl)omAlloc0(sizeof(idrec));
1631 tmp_proc->id="_auto";
1632 tmp_proc->typ=PROC_CMD;
1633 tmp_proc->data.pinf=(procinfo *)u->Data();
1634 tmp_proc->ref=1;
1635 d=u->data; u->data=(void *)tmp_proc;
1636 e=u->e; u->e=NULL;
1637 t=TRUE;
1638 typ=u->rtyp; u->rtyp=IDHDL;
1639 }
1640 BOOLEAN sl;
1641 if (u->req_packhdl==currPack)
1642 sl = iiMake_proc((idhdl)u->data,NULL,v);
1643 else
1644 sl = iiMake_proc((idhdl)u->data,u->req_packhdl,v);
1645 if (t)
1646 {
1647 u->rtyp=typ;
1648 u->data=d;
1649 u->e=e;
1650 omFreeSize(tmp_proc,sizeof(idrec));
1651 }
1652 if (sl) return TRUE;
1653 memcpy(res,&iiRETURNEXPR,sizeof(sleftv));
1655 return FALSE;
1656}
int typ
Definition: idrec.h:43
short ref
Definition: idrec.h:46
const char * id
Definition: idrec.h:39
package req_packhdl
Definition: subexpr.h:106
BOOLEAN iiMake_proc(idhdl pn, package pack, leftv args)
Definition: iplib.cc:504
INST_VAR sleftv iiRETURNEXPR
Definition: iplib.cc:474

◆ jjPROC1()

static BOOLEAN jjPROC1 ( leftv  res,
leftv  u 
)
static

Definition at line 3787 of file iparith.cc.

3788{
3789 return jjPROC(res,u,NULL);
3790}
BOOLEAN jjPROC(leftv res, leftv u, leftv v)
Definition: iparith.cc:1621

◆ jjPROC3()

static BOOLEAN jjPROC3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5977 of file iparith.cc.

5978{
5980 memcpy(v->next,w,sizeof(sleftv));
5981 w->Init();
5982 return jjPROC(res,u,v);
5983}

◆ jjPRUNE()

static BOOLEAN jjPRUNE ( leftv  res,
leftv  v 
)
static

Definition at line 4815 of file iparith.cc.

4816{
4817 intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
4818 ideal v_id=(ideal)v->Data();
4819 if (w!=NULL)
4820 {
4821 if (!idTestHomModule(v_id,currRing->qideal,w))
4822 {
4823 WarnS("wrong weights");
4824 w=NULL;
4825 // and continue at the non-homog case below
4826 }
4827 else
4828 {
4829 w=ivCopy(w);
4830 intvec **ww=&w;
4831 res->data = (char *)idMinEmbedding(v_id,FALSE,ww);
4832 atSet(res,omStrDup("isHomog"),*ww,INTVEC_CMD);
4833 return FALSE;
4834 }
4835 }
4836 res->data = (char *)idMinEmbedding(v_id);
4837 return FALSE;
4838}
ideal idMinEmbedding(ideal arg, BOOLEAN inPlace, intvec **w)
Definition: ideals.cc:2687

◆ jjQRDS()

static BOOLEAN jjQRDS ( leftv  res,
leftv  INPUT 
)
static

Definition at line 8576 of file iparith.cc.

8577{
8578 if ((INPUT->Typ() != MATRIX_CMD) ||
8579 (INPUT->next->Typ() != NUMBER_CMD) ||
8580 (INPUT->next->next->Typ() != NUMBER_CMD) ||
8581 (INPUT->next->next->next->Typ() != NUMBER_CMD))
8582 {
8583 WerrorS("expected (matrix, number, number, number) as arguments");
8584 return TRUE;
8585 }
8586 leftv u = INPUT; leftv v = u->next; leftv w = v->next; leftv x = w->next;
8587 res->data = (char *)qrDoubleShift((matrix)(u->Data()),
8588 (number)(v->Data()),
8589 (number)(w->Data()),
8590 (number)(x->Data()));
8591 return FALSE;
8592}
lists qrDoubleShift(const matrix A, const number tol1, const number tol2, const number tol3, const ring r=currRing)
Computes all eigenvalues of a given real quadratic matrix with multiplicites.

◆ jjQUOT()

static BOOLEAN jjQUOT ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3033 of file iparith.cc.

3034{
3035 res->data = (char *)idQuot((ideal)u->Data(),(ideal)v->Data(),
3036 hasFlag(u,FLAG_STD),u->Typ()==v->Typ());
3038 return FALSE;
3039}
ideal idQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN resultIsIdeal)
Definition: ideals.cc:1494

◆ jjRANDOM()

static BOOLEAN jjRANDOM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3040 of file iparith.cc.

3041{
3042 int i=(int)(long)u->Data();
3043 int j=(int)(long)v->Data();
3044 if (j-i <0) {WerrorS("invalid range for random"); return TRUE;}
3045 res->data =(char *)(long)((i > j) ? i : (siRand() % (j-i+1)) + i);
3046 return FALSE;
3047}
int siRand()
Definition: sirandom.c:42

◆ jjRANDOM_Im()

static BOOLEAN jjRANDOM_Im ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6551 of file iparith.cc.

6552{
6553 int di, k;
6554 int i=(int)(long)u->Data();
6555 int r=(int)(long)v->Data();
6556 int c=(int)(long)w->Data();
6557 if ((r<=0) || (c<=0)) return TRUE;
6558 intvec *iv = new intvec(r, c, 0);
6559 if (iv->rows()==0)
6560 {
6561 delete iv;
6562 return TRUE;
6563 }
6564 if (i!=0)
6565 {
6566 if (i<0) i = -i;
6567 di = 2 * i + 1;
6568 for (k=0; k<iv->length(); k++)
6569 {
6570 (*iv)[k] = ((siRand() % di) - i);
6571 }
6572 }
6573 res->data = (char *)iv;
6574 return FALSE;
6575}

◆ jjRANK1()

static BOOLEAN jjRANK1 ( leftv  res,
leftv  v 
)
static

Definition at line 4877 of file iparith.cc.

4878{
4879 matrix m =(matrix)v->Data();
4880 int rank = luRank(m, 0);
4881 res->data =(char *)(long)rank;
4882 return FALSE;
4883}
int luRank(const matrix aMat, const bool isRowEchelon, const ring R)
Computes the rank of a given (m x n)-matrix.

◆ jjRANK2()

static BOOLEAN jjRANK2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3048 of file iparith.cc.

3049{
3050 matrix m =(matrix)u->Data();
3051 int isRowEchelon = (int)(long)v->Data();
3052 if (isRowEchelon != 1) isRowEchelon = 0;
3053 int rank = luRank(m, isRowEchelon);
3054 res->data =(char *)(long)rank;
3055 return FALSE;
3056}

◆ jjrCharStr()

static BOOLEAN jjrCharStr ( leftv  res,
leftv  v 
)
static

Definition at line 5609 of file iparith.cc.

5610{
5611 res->data = rCharStr((ring)v->Data());
5612 return FALSE;
5613}
char * rCharStr(const ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
Definition: ring.cc:647

◆ jjREAD()

static BOOLEAN jjREAD ( leftv  res,
leftv  v 
)
static

Definition at line 4884 of file iparith.cc.

4885{
4886 return jjREAD2(res,v,NULL);
4887}
static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
Definition: iparith.cc:3057

◆ jjREAD2()

static BOOLEAN jjREAD2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3057 of file iparith.cc.

3058{
3059 si_link l=(si_link)u->Data();
3060 leftv r=slRead(l,v);
3061 if (r==NULL)
3062 {
3063 const char *s;
3064 if ((l!=NULL)&&(l->name!=NULL)) s=l->name;
3065 else s=sNoName_fe;
3066 Werror("cannot read from `%s`",s);
3067 return TRUE;
3068 }
3069 memcpy(res,r,sizeof(sleftv));
3071 return FALSE;
3072}

◆ jjREDUCE3_CID()

static BOOLEAN jjREDUCE3_CID ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6996 of file iparith.cc.

6997{
6999 if (!idIsZeroDim((ideal)v->Data()))
7000 {
7001 Werror("`%s` must be 0-dimensional",v->Name());
7002 return TRUE;
7003 }
7004 res->data = (char *)redNF((ideal)v->CopyD(),(ideal)u->CopyD(),
7005 (matrix)w->CopyD());
7006 return FALSE;
7007}
static BOOLEAN idIsZeroDim(ideal i)
Definition: ideals.h:176
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
Definition: kstd2.cc:2142

◆ jjREDUCE3_CP()

static BOOLEAN jjREDUCE3_CP ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6984 of file iparith.cc.

6985{
6987 if (!idIsZeroDim((ideal)v->Data()))
6988 {
6989 Werror("`%s` must be 0-dimensional",v->Name());
6990 return TRUE;
6991 }
6992 res->data = (char *)redNF((ideal)v->CopyD(),(poly)u->CopyD(),
6993 (poly)w->CopyD());
6994 return FALSE;
6995}

◆ jjREDUCE3_ID()

static BOOLEAN jjREDUCE3_ID ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 7015 of file iparith.cc.

7016{
7018 res->data = (char *)kNF((ideal)v->Data(),currRing->qideal,(ideal)u->Data(),
7019 0,(int)(long)w->Data());
7020 return FALSE;
7021}
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:3167

◆ jjREDUCE3_P()

static BOOLEAN jjREDUCE3_P ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 7008 of file iparith.cc.

7009{
7011 res->data = (char *)kNF((ideal)v->Data(),currRing->qideal,(poly)u->Data(),
7012 0,(int)(long)w->Data());
7013 return FALSE;
7014}

◆ jjREDUCE4()

static BOOLEAN jjREDUCE4 ( leftv  res,
leftv  u 
)
static

Definition at line 8111 of file iparith.cc.

8112{
8113 leftv u1=u;
8114 leftv u2=u1->next;
8115 leftv u3=u2->next;
8116 leftv u4=u3->next;
8117 int u1t=u1->Typ(); if (u1t==BUCKET_CMD) u1t=POLY_CMD;
8118 int u2t=u2->Typ(); if (u2t==BUCKET_CMD) u2t=POLY_CMD;
8119 if((u3->Typ()==INT_CMD)&&(u4->Typ()==INTVEC_CMD))
8120 {
8121 int save_d=Kstd1_deg;
8122 Kstd1_deg=(int)(long)u3->Data();
8123 kModW=(intvec *)u4->Data();
8124 BITSET save2;
8125 SI_SAVE_OPT2(save2);
8127 u2->next=NULL;
8128 BOOLEAN r=jjCALL2ARG(res,u);
8129 kModW=NULL;
8130 Kstd1_deg=save_d;
8131 SI_RESTORE_OPT2(save2);
8132 u->next->next=u3;
8133 return r;
8134 }
8135 else
8136 if((u1t==IDEAL_CMD)&&(u2t==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
8137 (u4->Typ()==INT_CMD))
8138 {
8139 assumeStdFlag(u3);
8140 if(!mp_IsDiagUnit((matrix)u2->Data(), currRing))
8141 {
8142 WerrorS("2nd argument must be a diagonal matrix of units");
8143 return TRUE;
8144 }
8145 res->data=(char*)redNF(
8146 idCopy((ideal)u3->Data()),
8147 idCopy((ideal)u1->Data()),
8148 mp_Copy((matrix)u2->Data(), currRing),
8149 (int)(long)u4->Data()
8150 );
8151 return FALSE;
8152 }
8153 else
8154 if((u1t==POLY_CMD)&&(u2t==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
8155 (u4->Typ()==INT_CMD))
8156 {
8157 poly u1p;
8158 if (u1->Typ()==BUCKET_CMD) u1p=sBucketPeek((sBucket_pt)u1->Data());
8159 else u1p=(poly)u1->Data();
8160 poly u2p;
8161 if (u2->Typ()==BUCKET_CMD) u2p=sBucketPeek((sBucket_pt)u2->Data());
8162 else u2p=(poly)u2->Data();
8163 assumeStdFlag(u3);
8164 if(!pIsUnit(u2p))
8165 {
8166 WerrorS("2nd argument must be a unit");
8167 return TRUE;
8168 }
8169 res->rtyp=POLY_CMD;
8170 res->data=(char*)redNF((ideal)u3->CopyD(),pCopy(u1p),
8171 pCopy(u2p),(int)(long)u4->Data());
8172 return FALSE;
8173 }
8174 else
8175 {
8176 Werror("%s(`poly`,`ideal`,`int`,`intvec`) expected",Tok2Cmdname(iiOp));
8177 Werror("%s(`ideal`,`matrix`,`ideal`,`int`) expected",Tok2Cmdname(iiOp));
8178 Werror("%s(`poly`,`poly`,`ideal`,`int`) expected",Tok2Cmdname(iiOp));
8179 return TRUE;
8180 }
8181}
static BOOLEAN jjCALL2ARG(leftv res, leftv u)
Definition: iparith.cc:7148
EXTERN_VAR int Kstd1_deg
Definition: kstd1.h:49
VAR unsigned si_opt_2
Definition: options.c:6
#define SI_SAVE_OPT2(A)
Definition: options.h:22
#define SI_RESTORE_OPT2(A)
Definition: options.h:25
#define Sy_bit(x)
Definition: options.h:31
#define V_DEG_STOP
Definition: options.h:73
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:455
#define BITSET
Definition: structs.h:16

◆ jjREDUCE5()

static BOOLEAN jjREDUCE5 ( leftv  res,
leftv  u 
)
static

Definition at line 8182 of file iparith.cc.

8183{
8184 leftv u1=u;
8185 leftv u2=u1->next;
8186 leftv u3=u2->next;
8187 leftv u4=u3->next;
8188 leftv u5=u4->next;
8189 if((u1->Typ()==IDEAL_CMD)&&(u2->Typ()==MATRIX_CMD)&&(u3->Typ()==IDEAL_CMD)&&
8190 (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
8191 {
8192 assumeStdFlag(u3);
8193 if(!mp_IsDiagUnit((matrix)u2->Data(), currRing))
8194 {
8195 WerrorS("2nd argument must be a diagonal matrix of units");
8196 return TRUE;
8197 }
8198 res->data=(char*)redNF(
8199 idCopy((ideal)u3->Data()),
8200 idCopy((ideal)u1->Data()),
8201 mp_Copy((matrix)u2->Data(),currRing),
8202 (int)(long)u4->Data(),
8203 (intvec*)u5->Data()
8204 );
8205 return FALSE;
8206 }
8207 else
8208 if((u1->Typ()==POLY_CMD)&&(u2->Typ()==POLY_CMD)&&(u3->Typ()==IDEAL_CMD)&&
8209 (u4->Typ()==INT_CMD)&&(u5->Typ()==INTVEC_CMD))
8210 {
8211 assumeStdFlag(u3);
8212 if(!pIsUnit((poly)u2->Data()))
8213 {
8214 WerrorS("2nd argument must be a unit");
8215 return TRUE;
8216 }
8217 res->rtyp=POLY_CMD;
8218 res->data=(char*)redNF(idCopy((ideal)u3->Data()),pCopy((poly)u1->Data()),
8219 pCopy((poly)u2->Data()),
8220 (int)(long)u4->Data(),(intvec*)u5->Data());
8221 return FALSE;
8222 }
8223 else
8224 {
8225 Werror("%s(`ideal`,`ideal`,`matrix`,`int`,`intvec`) exppected",
8226 Tok2Cmdname(iiOp));
8227 return TRUE;
8228 }
8229}

◆ jjREDUCE_ID()

static BOOLEAN jjREDUCE_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3081 of file iparith.cc.

3082{
3083 ideal ui=(ideal)u->Data();
3084 ideal vi=(ideal)v->Data();
3085 if (currRing->qideal!=NULL || vi->ncols>1 || rIsPluralRing(currRing))
3087 res->data = (char *)kNF(vi,currRing->qideal,ui);
3088 return FALSE;
3089}

◆ jjREDUCE_P()

static BOOLEAN jjREDUCE_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3073 of file iparith.cc.

3074{
3075 ideal vi=(ideal)v->Data();
3076 if (currRing->qideal!=NULL || vi->ncols>1 || rIsPluralRing(currRing))
3078 res->data = (char *)kNF(vi,currRing->qideal,(poly)u->Data());
3079 return FALSE;
3080}

◆ jjREGULARITY()

static BOOLEAN jjREGULARITY ( leftv  res,
leftv  v 
)
static

Definition at line 4888 of file iparith.cc.

4889{
4890 res->data = (char *)(long)iiRegularity((lists)v->Data());
4891 return FALSE;
4892}
int iiRegularity(lists L)
Definition: ipshell.cc:1037

◆ jjREPART()

static BOOLEAN jjREPART ( leftv  res,
leftv  v 
)
static

Definition at line 4893 of file iparith.cc.

4894{
4895 res->data = (char *)n_RePart((number)v->Data(),currRing->cf);
4896 return FALSE;
4897}
static FORCE_INLINE number n_RePart(number i, const coeffs cf)
Definition: coeffs.h:790

◆ jjRES()

static BOOLEAN jjRES ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3090 of file iparith.cc.

3091{
3092 int maxl=(int)(long)v->Data();
3093 if (maxl<0)
3094 {
3095 WerrorS("length for res must not be negative");
3096 return TRUE;
3097 }
3098 syStrategy r;
3099 intvec *weights=NULL;
3100 int wmaxl=maxl;
3101 ideal u_id=(ideal)u->Data();
3102
3103 maxl--;
3104 if (/*(*/ maxl==-1 /*)*/) /*&& (iiOp!=MRES_CMD)*/
3105 {
3106 maxl = currRing->N-1+2*(iiOp==MRES_CMD);
3107 if (currRing->qideal!=NULL)
3108 {
3109 Warn(
3110 "full resolution in a qring may be infinite, setting max length to %d",
3111 maxl+1);
3112 }
3113 }
3114 weights=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
3115 if (weights!=NULL)
3116 {
3117 if (!idTestHomModule(u_id,currRing->qideal,weights))
3118 {
3119 WarnS("wrong weights given:");weights->show();PrintLn();
3120 weights=NULL;
3121 }
3122 }
3123 intvec *ww=NULL;
3124 int add_row_shift=0;
3125 if (weights!=NULL)
3126 {
3127 ww=ivCopy(weights);
3128 add_row_shift = ww->min_in();
3129 (*ww) -= add_row_shift;
3130 }
3131 unsigned save_opt=si_opt_1;
3133 if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
3134 {
3135 r=syResolution(u_id,maxl, ww, iiOp==MRES_CMD);
3136 }
3137 else if (iiOp==SRES_CMD)
3138 // r=sySchreyerResolvente(u_id,maxl+1,&l);
3139 r=sySchreyer(u_id,maxl+1);
3140 else if (iiOp == LRES_CMD)
3141 {
3142 int dummy;
3143 if((currRing->qideal!=NULL)||
3144 (!idHomIdeal (u_id,NULL)))
3145 {
3146 WerrorS
3147 ("`lres` not implemented for inhomogeneous input or qring");
3148 return TRUE;
3149 }
3150 if(currRing->N == 1)
3151 WarnS("the current implementation of `lres` may not work in the case of a single variable");
3152 r=syLaScala3(u_id,&dummy);
3153 }
3154 else if (iiOp == KRES_CMD)
3155 {
3156 int dummy;
3157 if((currRing->qideal!=NULL)||
3158 (!idHomIdeal (u_id,NULL)))
3159 {
3160 WerrorS
3161 ("`kres` not implemented for inhomogeneous input or qring");
3162 return TRUE;
3163 }
3164 r=syKosz(u_id,&dummy);
3165 }
3166 else
3167 {
3168 int dummy;
3169 if((currRing->qideal!=NULL)||
3170 (!idHomIdeal (u_id,NULL)))
3171 {
3172 WerrorS
3173 ("`hres` not implemented for inhomogeneous input or qring");
3174 return TRUE;
3175 }
3176 ideal u_id_copy=idCopy(u_id);
3177 idSkipZeroes(u_id_copy);
3178 r=syHilb(u_id_copy,&dummy);
3179 idDelete(&u_id_copy);
3180 }
3181 if (r==NULL) return TRUE;
3182 if (r->list_length>wmaxl)
3183 {
3184 for(int i=wmaxl-1;i>=r->list_length;i--)
3185 {
3186 if (r->fullres[i]!=NULL) id_Delete(&r->fullres[i],currRing);
3187 if (r->minres[i]!=NULL) id_Delete(&r->minres[i],currRing);
3188 }
3189 }
3190 r->list_length=wmaxl;
3191 res->data=(void *)r;
3192 if ((weights!=NULL) && (ww!=NULL)) { delete ww; ww=NULL; }
3193 if ((r->weights!=NULL) && (r->weights[0]!=NULL))
3194 {
3195 ww=ivCopy(r->weights[0]);
3196 if (weights!=NULL) (*ww) += add_row_shift;
3197 atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
3198 }
3199 else
3200 {
3201 if (weights!=NULL)
3202 {
3203 atSet(res,omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
3204 }
3205 }
3206
3207 // test the La Scala case' output
3208 assume( ((iiOp == LRES_CMD) || (iiOp == HRES_CMD)) == (r->syRing != NULL) );
3209 assume( (r->syRing != NULL) == (r->resPairs != NULL) );
3210
3211 if(iiOp != HRES_CMD)
3212 assume( (r->minres != NULL) || (r->fullres != NULL) ); // is wrong for HRES_CMD...
3213 else
3214 assume( (r->orderedRes != NULL) || (r->res != NULL) ); // analog for hres...
3215
3216 si_opt_1=save_opt;
3217 return FALSE;
3218}
void show(int mat=0, int spaces=0) const
Definition: intvec.cc:149
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
Definition: ideals.h:91
VAR unsigned si_opt_1
Definition: options.c:5
#define OPT_REDTAIL_SYZ
Definition: options.h:88
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
syStrategy syResolution(ideal arg, int maxlength, intvec *w, BOOLEAN minim)
Definition: syz.cc:613
syStrategy syHilb(ideal arg, int *length)
Definition: syz2.cc:950
syStrategy sySchreyer(ideal arg, int maxlength)
Definition: syz0.cc:1018
ring syRing
Definition: syz.h:56
resolvente minres
Definition: syz.h:58
syStrategy syKosz(ideal arg, int *length)
Definition: syz3.cc:1763
short list_length
Definition: syz.h:62
resolvente res
Definition: syz.h:47
intvec ** weights
Definition: syz.h:45
resolvente orderedRes
Definition: syz.h:48
SRes resPairs
Definition: syz.h:49
syStrategy syLaScala3(ideal arg, int *length)
Definition: syz1.cc:2432
@ LRES_CMD
Definition: tok.h:120
@ HRES_CMD
Definition: tok.h:91
@ KRES_CMD
Definition: tok.h:109
@ MRES_CMD
Definition: tok.h:131
@ SRES_CMD
Definition: tok.h:182
@ RES_CMD
Definition: tok.h:167

◆ jjRES3()

static BOOLEAN jjRES3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 7023 of file iparith.cc.

7024{
7025 int maxl=(int)v->Data();
7026 ideal u_id=(ideal)u->Data();
7027 int l=0;
7028 resolvente r;
7029 intvec **weights=NULL;
7030 int wmaxl=maxl;
7031 maxl--;
7032 unsigned save_opt=si_opt_1;
7034 if ((maxl==-1) && (iiOp!=MRES_CMD))
7035 maxl = currRing->N-1;
7036 if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
7037 {
7038 intvec * iv=(intvec*)atGet(u,"isHomog",INTVEC_CMD);
7039 if (iv!=NULL)
7040 {
7041 l=1;
7042 if (!idTestHomModule(u_id,currRing->qideal,iv))
7043 {
7044 WarnS("wrong weights");
7045 iv=NULL;
7046 }
7047 else
7048 {
7049 weights = (intvec**)omAlloc0Bin(char_ptr_bin);
7050 weights[0] = ivCopy(iv);
7051 }
7052 }
7053 r=syResolvente(u_id,maxl,&l, &weights, iiOp==MRES_CMD);
7054 }
7055 else
7056 r=sySchreyerResolvente((ideal)u->Data(),maxl+1,&l);
7057 if (r==NULL) return TRUE;
7058 int t3=u->Typ();
7059 iiMakeResolv(r,l,wmaxl,w->name,t3,weights);
7060 si_opt_1=save_opt;
7061 return FALSE;
7062}
void iiMakeResolv(resolvente r, int length, int rlen, char *name, int typ0, intvec **weights)
Definition: ipshell.cc:847
EXTERN_VAR omBin char_ptr_bin
Definition: structs.h:77
resolvente syResolvente(ideal arg, int maxlength, int *length, intvec ***weights, BOOLEAN minim)
Definition: syz.cc:389
resolvente sySchreyerResolvente(ideal arg, int maxlength, int *length, BOOLEAN isMonomial=FALSE, BOOLEAN notReplace=FALSE)
Definition: syz0.cc:855

◆ jjRESERVED0()

static BOOLEAN jjRESERVED0 ( leftv  ,
leftv   
)
static

Definition at line 8230 of file iparith.cc.

8231{
8232 unsigned i=1;
8233 unsigned nCount = (sArithBase.nCmdUsed-1)/3;
8234 if((3*nCount)<sArithBase.nCmdUsed) nCount++;
8235 //Print("CMDS: %d/%d\n", sArithBase.nCmdUsed,
8236 // sArithBase.nCmdAllocated);
8237 for(i=0; i<nCount; i++)
8238 {
8239 Print("%-20s",sArithBase.sCmds[i+1].name);
8240 if(i+1+nCount<sArithBase.nCmdUsed)
8241 Print("%-20s",sArithBase.sCmds[i+1+nCount].name);
8242 if(i+1+2*nCount<sArithBase.nCmdUsed)
8243 Print("%-20s",sArithBase.sCmds[i+1+2*nCount].name);
8244 //if ((i%3)==1) PrintLn();
8245 PrintLn();
8246 }
8247 PrintLn();
8249 return FALSE;
8250}
void printBlackboxTypes()
list all defined type (for debugging)
Definition: blackbox.cc:235

◆ jjRESERVEDLIST0()

static BOOLEAN jjRESERVEDLIST0 ( leftv  res,
leftv   
)
static

Definition at line 8252 of file iparith.cc.

8253{
8254 int i=1;
8255 int l = 0;
8256 int k = 0;
8258 struct blackbox_list *bb_list = NULL;
8259 unsigned nCount = (sArithBase.nCmdUsed-1) / 3;
8260
8261 if ((3*nCount) < sArithBase.nCmdUsed)
8262 {
8263 nCount++;
8264 }
8265 bb_list = getBlackboxTypes();
8266 // count the number of entries;
8267 for (i=0; i<nCount; i++)
8268 {
8269 l++;
8270 if (i + 1 + nCount < sArithBase.nCmdUsed)
8271 {
8272 l++;
8273 }
8274 if(i+1+2*nCount<sArithBase.nCmdUsed)
8275 {
8276 l++;
8277 }
8278 }
8279 for (i = 0; i < bb_list->count; i++)
8280 {
8281 if (bb_list->list[i] != NULL)
8282 {
8283 l++;
8284 }
8285 }
8286 // initiate list
8287 L->Init(l);
8288 k = 0;
8289 for (i=0; i<nCount; i++)
8290 {
8291 L->m[k].rtyp = STRING_CMD;
8292 L->m[k].data = omStrDup(sArithBase.sCmds[i+1].name);
8293 k++;
8294 // Print("%-20s", sArithBase.sCmds[i+1].name);
8295 if (i + 1 + nCount < sArithBase.nCmdUsed)
8296 {
8297 L->m[k].rtyp = STRING_CMD;
8298 L->m[k].data = omStrDup(sArithBase.sCmds[i+1+nCount].name);
8299 k++;
8300 // Print("%-20s", sArithBase.sCmds[i+1 + nCount].name);
8301 }
8302 if(i+1+2*nCount<sArithBase.nCmdUsed)
8303 {
8304 L->m[k].rtyp = STRING_CMD;
8305 L->m[k].data = omStrDup(sArithBase.sCmds[i+1+2*nCount].name);
8306 k++;
8307 // Print("%-20s", sArithBase.sCmds[i+1+2*nCount].name);
8308 }
8309 // PrintLn();
8310 }
8311
8312 // assign blackbox types
8313 for (i = 0; i < bb_list->count; i++)
8314 {
8315 if (bb_list->list[i] != NULL)
8316 {
8317 L->m[k].rtyp = STRING_CMD;
8318 // already used strdup in getBlackBoxTypes
8319 L->m[k].data = bb_list->list[i];
8320 k++;
8321 }
8322 }
8323 // free the struct (not the list entries itself, which were allocated
8324 // by strdup)
8325 omfree(bb_list->list);
8326 omfree(bb_list);
8327
8328 // pass the resultant list to the res datastructure
8329 res->data=(void *)L;
8330
8331 return FALSE;
8332}
struct blackbox_list * getBlackboxTypes()
return array of all define types.
Definition: blackbox.cc:244
void ** list
Definition: blackbox.h:86
struct for containing list of blackbox names and the number of them.
Definition: blackbox.h:84
#define omfree(addr)
Definition: omAllocDecl.h:237

◆ jjRESERVEDNAME()

static BOOLEAN jjRESERVEDNAME ( leftv  res,
leftv  v 
)
static

Definition at line 4855 of file iparith.cc.

4856{
4857 char *s= (char *)v->Data();
4858 // try system keywords
4859 for(unsigned i=0; i<sArithBase.nCmdUsed; i++)
4860 {
4861 //Print("test %d, >>%s<<, tab:>>%s<<\n",i,s,sArithBase.sCmds[i].name);
4862 if (strcmp(s, sArithBase.sCmds[i].name) == 0)
4863 {
4864 res->data = (char *)1;
4865 return FALSE;
4866 }
4867 }
4868 // try blackbox names
4869 int id;
4870 blackboxIsCmd(s,id);
4871 if (id>0)
4872 {
4873 res->data = (char *)1;
4874 }
4875 return FALSE;
4876}

◆ jjRESTART()

static BOOLEAN jjRESTART ( leftv  ,
leftv  u 
)
static

Definition at line 8705 of file iparith.cc.

8706{
8707 int c=(int)(long)u->Data();
8708 switch(c)
8709 {
8710 case 0:{
8711 PrintS("delete all variables\n");
8712 killlocals(0);
8713 WerrorS("restarting...");
8714 break;
8715 };
8716 default: WerrorS("not implemented");
8717 }
8718 return FALSE;
8719}
void killlocals(int v)
Definition: ipshell.cc:386

◆ jjRIGHTSTD()

static BOOLEAN jjRIGHTSTD ( leftv  res,
leftv  v 
)
static

Definition at line 5272 of file iparith.cc.

5273{
5274#if defined(HAVE_SHIFTBBA) || defined(HAVE_PLURAL)// do not place above jjSTD in this file because we need to reference it
5275 if (rIsLPRing(currRing))
5276 {
5278 WarnS("groebner base computations with inexact coefficients can not be trusted due to rounding errors");
5279 ideal result;
5280 ideal v_id=(ideal)v->Data();
5281 /* intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD); */
5282 /* tHomog hom=testHomog; */
5283 /* if (w!=NULL) */
5284 /* { */
5285 /* if (!idTestHomModule(v_id,currRing->qideal,w)) */
5286 /* { */
5287 /* WarnS("wrong weights"); */
5288 /* w=NULL; */
5289 /* } */
5290 /* else */
5291 /* { */
5292 /* hom=isHomog; */
5293 /* w=ivCopy(w); */
5294 /* } */
5295 /* } */
5296 /* result=kStd(v_id,currRing->qideal,hom,&w); */
5297 result = rightgb(v_id, currRing->qideal);
5299 res->data = (char *)result;
5301 /* if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD); */
5302 return FALSE;
5303 }
5304 else if (rIsPluralRing(currRing))
5305 {
5306 ideal I=(ideal)v->Data();
5307
5308 ring A = currRing;
5309 ring Aopp = rOpposite(A);
5310 currRing = Aopp;
5311 ideal Iopp = idOppose(A, I, Aopp);
5312 ideal Jopp = kStd(Iopp,currRing->qideal,testHomog,NULL);
5313 currRing = A;
5314 ideal J = idOppose(Aopp, Jopp, A);
5315
5316 id_Delete(&Iopp, Aopp);
5317 id_Delete(&Jopp, Aopp);
5318 rDelete(Aopp);
5319
5320 idSkipZeroes(J);
5321 res->data = (char *)J;
5323 return FALSE;
5324 }
5325 else
5326 {
5327 return jjSTD(res, v);
5328 }
5329#else
5330 return TRUE;
5331#endif
5332}
static BOOLEAN jjSTD(leftv res, leftv v)
Definition: iparith.cc:5073
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
Definition: kstd1.cc:2433
ideal rightgb(ideal F, ideal Q)
Definition: kstd2.cc:4722
#define TEST_OPT_DEGBOUND
Definition: options.h:114
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:450
static BOOLEAN rField_is_numeric(const ring r)
Definition: ring.h:516

◆ jjRING3()

static BOOLEAN jjRING3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 7064 of file iparith.cc.

7065{
7066 res->data=(void *)rInit(u,v,w);
7067 return (res->data==NULL);
7068}
ring rInit(leftv pn, leftv rv, leftv ord)
Definition: ipshell.cc:5624

◆ jjRING_1()

static BOOLEAN jjRING_1 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1677 of file iparith.cc.

1678{
1679 u->next=(leftv)omAlloc(sizeof(sleftv));
1680 memcpy(u->next,v,sizeof(sleftv));
1681 v->Init();
1682 BOOLEAN bo=iiExprArithM(res,u,'[');
1683 u->next=NULL;
1684 return bo;
1685}

◆ jjRING_2()

static BOOLEAN jjRING_2 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 5984 of file iparith.cc.

5985{
5986 u->next=(leftv)omAlloc(sizeof(sleftv));
5987 memcpy(u->next,v,sizeof(sleftv));
5988 v->Init();
5989 u->next->next=(leftv)omAlloc(sizeof(sleftv));
5990 memcpy(u->next->next,w,sizeof(sleftv));
5991 w->Init();
5992 BOOLEAN bo=iiExprArithM(res,u,'[');
5993 u->next=NULL;
5994 return bo;
5995}

◆ jjRING_LIST()

static BOOLEAN jjRING_LIST ( leftv  res,
leftv  v 
)
static

Definition at line 4920 of file iparith.cc.

4921{
4922 ring r=(ring)v->Data();
4923 if (r!=NULL)
4924 res->data = (char *)rDecompose_list_cf((ring)v->Data());
4925 return (r==NULL)||(res->data==NULL);
4926}
lists rDecompose_list_cf(const ring r)
Definition: ipshell.cc:2122

◆ jjRING_PL()

static BOOLEAN jjRING_PL ( leftv  res,
leftv  a 
)
static

Definition at line 8676 of file iparith.cc.

8677{
8678 //Print("construct ring\n");
8679 if (a->Typ()!=CRING_CMD)
8680 {
8681 WerrorS("expected `cring` [ `id` ... ]");
8682 return TRUE;
8683 }
8684 assume(a->next!=NULL);
8685 leftv names=a->next;
8686 int N=names->listLength();
8687 char **n=(char**)omAlloc0(N*sizeof(char*));
8688 for(int i=0; i<N;i++,names=names->next)
8689 {
8690 n[i]=(char *)names->Name();
8691 }
8692 coeffs cf=(coeffs)a->CopyD();
8693 res->data=rDefault(cf,N,n, ringorder_dp);
8694 omFreeSize(n,N*sizeof(char*));
8695 return FALSE;
8696}
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
Definition: ring.cc:102
@ ringorder_dp
Definition: ring.h:78
@ CRING_CMD
Definition: tok.h:56

◆ jjRINGLIST()

static BOOLEAN jjRINGLIST ( leftv  res,
leftv  v 
)
static

Definition at line 4898 of file iparith.cc.

4899{
4900 ring r=(ring)v->Data();
4901 if (r!=NULL)
4902 {
4903 res->data = (char *)rDecompose((ring)v->Data());
4904 if (res->data!=NULL)
4905 {
4906 long mm=r->wanted_maxExp;
4907 if (mm!=0) atSet(res,omStrDup("maxExp"),(void*)mm,INT_CMD);
4908 return FALSE;
4909 }
4910 }
4911 return TRUE;
4912}
lists rDecompose(const ring r)
Definition: ipshell.cc:2161

◆ jjRINGLIST_C()

static BOOLEAN jjRINGLIST_C ( leftv  res,
leftv  v 
)
static

Definition at line 4913 of file iparith.cc.

4914{
4915 coeffs r=(coeffs)v->Data();
4916 if (r!=NULL)
4917 return rDecompose_CF(res,r);
4918 return TRUE;
4919}
BOOLEAN rDecompose_CF(leftv res, const coeffs C)
Definition: ipshell.cc:1949

◆ jjRMINUS()

static BOOLEAN jjRMINUS ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3245 of file iparith.cc.

3246{
3247 ring r=rMinusVar((ring)u->Data(),(char*)v->Data());
3248 res->data = (char *)r;
3249 return r==NULL;
3250}
ring rMinusVar(const ring r, char *v)
undo rPlusVar
Definition: ring.cc:6000

◆ jjrOrdStr()

static BOOLEAN jjrOrdStr ( leftv  res,
leftv  v 
)
static

Definition at line 5652 of file iparith.cc.

5653{
5654 res->data = rOrdStr((ring)v->Data());
5655 return FALSE;
5656}
char * rOrdStr(ring r)
Definition: ring.cc:521

◆ jjROWS()

static BOOLEAN jjROWS ( leftv  res,
leftv  v 
)
static

Definition at line 4927 of file iparith.cc.

4928{
4929 ideal i = (ideal)v->Data();
4930 res->data = (char *)i->rank;
4931 return FALSE;
4932}

◆ jjROWS_BIM()

static BOOLEAN jjROWS_BIM ( leftv  res,
leftv  v 
)
static

Definition at line 4933 of file iparith.cc.

4934{
4935 res->data = (char *)(long)((bigintmat*)(v->Data()))->rows();
4936 return FALSE;
4937}

◆ jjROWS_IV()

static BOOLEAN jjROWS_IV ( leftv  res,
leftv  v 
)
static

Definition at line 4938 of file iparith.cc.

4939{
4940 res->data = (char *)(long)((intvec*)(v->Data()))->rows();
4941 return FALSE;
4942}

◆ jjRPAR()

static BOOLEAN jjRPAR ( leftv  res,
leftv  v 
)
static

Definition at line 4943 of file iparith.cc.

4944{
4945 res->data = (char *)(long)rPar(((ring)v->Data()));
4946 return FALSE;
4947}

◆ jjrParStr()

static BOOLEAN jjrParStr ( leftv  res,
leftv  v 
)
static

Definition at line 5662 of file iparith.cc.

5663{
5664 res->data = rParStr((ring)v->Data());
5665 return FALSE;
5666}
char * rParStr(ring r)
Definition: ring.cc:649

◆ jjRPLUS()

static BOOLEAN jjRPLUS ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3251 of file iparith.cc.

3252{
3253 int left;
3254 if (u->Typ()==RING_CMD) left=0;
3255 else
3256 {
3257 leftv h=u;u=v;v=h;
3258 left=1;
3259 }
3260 ring r=rPlusVar((ring)u->Data(),(char*)v->Data(),left);
3261 res->data = (char *)r;
3262 return r==NULL;
3263}
ring rPlusVar(const ring r, char *v, int left)
K[x],"y" -> K[x,y] resp. K[y,x].
Definition: ring.cc:5918

◆ jjRSUM()

static BOOLEAN jjRSUM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3264 of file iparith.cc.

3265{
3266 ring r;
3267 int i=rSum((ring)u->Data(),(ring)v->Data(),r);
3268 res->data = (char *)r;
3269 return (i==-1);
3270}
int rSum(ring r1, ring r2, ring &sum)
Definition: ring.cc:1402

◆ jjrVarStr()

static BOOLEAN jjrVarStr ( leftv  res,
leftv  v 
)
static

Definition at line 5657 of file iparith.cc.

5658{
5659 res->data = rVarStr((ring)v->Data());
5660 return FALSE;
5661}
char * rVarStr(ring r)
Definition: ring.cc:623

◆ jjS2I()

static BOOLEAN jjS2I ( leftv  res,
leftv  v 
)
static

Definition at line 4948 of file iparith.cc.

4949{
4950 res->data = (char *)(long)atoi((char*)v->Data());
4951 return FALSE;
4952}

◆ jjSBA()

static BOOLEAN jjSBA ( leftv  res,
leftv  v 
)
static

Definition at line 4995 of file iparith.cc.

4996{
4997 ideal result;
4998 ideal v_id=(ideal)v->Data();
4999 intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
5000 tHomog hom=testHomog;
5001 if (w!=NULL)
5002 {
5003 if (!idTestHomModule(v_id,currRing->qideal,w))
5004 {
5005 WarnS("wrong weights");
5006 w=NULL;
5007 }
5008 else
5009 {
5010 hom=isHomog;
5011 w=ivCopy(w);
5012 }
5013 }
5014 result=kSba(v_id,currRing->qideal,hom,&w,1,0);
5016 res->data = (char *)result;
5018 if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
5019 return FALSE;
5020}
ideal kSba(ideal F, ideal Q, tHomog h, intvec **w, int sbaOrder, int arri, intvec *hilb, int syzComp, int newIdeal, intvec *vw)
Definition: kstd1.cc:2617

◆ jjSBA_1()

static BOOLEAN jjSBA_1 ( leftv  res,
leftv  v,
leftv  u 
)
static

Definition at line 5021 of file iparith.cc.

5022{
5023 ideal result;
5024 ideal v_id=(ideal)v->Data();
5025 intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
5026 tHomog hom=testHomog;
5027 if (w!=NULL)
5028 {
5029 if (!idTestHomModule(v_id,currRing->qideal,w))
5030 {
5031 WarnS("wrong weights");
5032 w=NULL;
5033 }
5034 else
5035 {
5036 hom=isHomog;
5037 w=ivCopy(w);
5038 }
5039 }
5040 result=kSba(v_id,currRing->qideal,hom,&w,(int)(long)u->Data(),0);
5042 res->data = (char *)result;
5044 if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
5045 return FALSE;
5046}

◆ jjSBA_2()

static BOOLEAN jjSBA_2 ( leftv  res,
leftv  v,
leftv  u,
leftv  t 
)
static

Definition at line 5047 of file iparith.cc.

5048{
5049 ideal result;
5050 ideal v_id=(ideal)v->Data();
5051 intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
5052 tHomog hom=testHomog;
5053 if (w!=NULL)
5054 {
5055 if (!idTestHomModule(v_id,currRing->qideal,w))
5056 {
5057 WarnS("wrong weights");
5058 w=NULL;
5059 }
5060 else
5061 {
5062 hom=isHomog;
5063 w=ivCopy(w);
5064 }
5065 }
5066 result=kSba(v_id,currRing->qideal,hom,&w,(int)(long)u->Data(),(int)(long)t->Data());
5068 res->data = (char *)result;
5070 if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
5071 return FALSE;
5072}

◆ jjSetRing()

static BOOLEAN jjSetRing ( leftv  ,
leftv  u 
)
static

Definition at line 3767 of file iparith.cc.

3768{
3769 if (u->rtyp==IDHDL) rSetHdl((idhdl)u->data);
3770 else
3771 {
3772 ring r=(ring)u->Data();
3773 idhdl h=rFindHdl(r,NULL);
3774 if (h==NULL)
3775 {
3776 char name_buffer[100];
3777 STATIC_VAR int ending=1000000;
3778 ending++;
3779 sprintf(name_buffer, "PYTHON_RING_VAR%d",ending);
3780 h=enterid(name_buffer,0,RING_CMD,&IDROOT);
3781 IDRING(h)=rIncRefCnt(r);
3782 }
3783 rSetHdl(h);
3784 }
3785 return FALSE;
3786}
#define STATIC_VAR
Definition: globaldefs.h:7
idhdl rFindHdl(ring r, idhdl n)
Definition: ipshell.cc:1701
void rSetHdl(idhdl h)
Definition: ipshell.cc:5125

◆ jjSIMPL_ID()

static BOOLEAN jjSIMPL_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3278 of file iparith.cc.

3279{
3280 int sw = (int)(long)v->Data();
3281 // CopyD for IDEAL_CMD and MODUL_CMD are identical:
3282 ideal id = (ideal)u->CopyD(IDEAL_CMD);
3283 if (sw & SIMPL_LMDIV)
3284 {
3285 id_DelDiv(id,currRing);
3286 }
3287 if (sw & SIMPL_LMEQ)
3288 {
3290 }
3291 if (sw & SIMPL_MULT)
3292 {
3294 }
3295 else if(sw & SIMPL_EQU)
3296 {
3298 }
3299 if (sw & SIMPL_NULL)
3300 {
3301 idSkipZeroes(id);
3302 }
3303 if (sw & SIMPL_NORM)
3304 {
3305 id_Norm(id,currRing);
3306 }
3307 if (sw & SIMPL_NORMALIZE)
3308 {
3310 }
3311 res->data = (char * )id;
3312 return FALSE;
3313}
#define SIMPL_EQU
Definition: iparith.cc:3275
#define SIMPL_NORM
Definition: iparith.cc:3277
#define SIMPL_LMEQ
Definition: iparith.cc:3273
#define SIMPL_NULL
Definition: iparith.cc:3276
#define SIMPL_MULT
Definition: iparith.cc:3274
#define SIMPL_NORMALIZE
Definition: iparith.cc:3271
#define SIMPL_LMDIV
Definition: iparith.cc:3272
void id_Norm(ideal id, const ring r)
ideal id = (id[i]), result is leadcoeff(id[i]) = 1
void id_Normalize(ideal I, const ring r)
normialize all polys in id
void id_DelDiv(ideal id, const ring r)
delete id[j], if LT(j) == coeff*mon*LT(i) and vice versa, i.e., delete id[i], if LT(i) == coeff*mon*L...
void id_DelMultiples(ideal id, const ring r)
ideal id = (id[i]), c any unit if id[i] = c*id[j] then id[j] is deleted for j > i
void id_DelEquals(ideal id, const ring r)
ideal id = (id[i]) if id[i] = id[j] then id[j] is deleted for j > i
void id_DelLmEquals(ideal id, const ring r)
Delete id[j], if Lm(j) == Lm(i) and both LC(j), LC(i) are units and j > i.

◆ jjSIMPL_P()

static BOOLEAN jjSIMPL_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3373 of file iparith.cc.

3374{
3375 int sw = (int)(long)v->Data();
3376 // CopyD for POLY_CMD and VECTOR_CMD are identical:
3377 poly p = (poly)u->CopyD(POLY_CMD);
3378 if (sw & SIMPL_NORM)
3379 {
3380 pNorm(p);
3381 }
3382 if (sw & SIMPL_NORMALIZE)
3383 {
3385 }
3386 res->data = (char * )p;
3387 return FALSE;
3388}
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3929
void pNorm(poly p)
Definition: polys.h:363

◆ jjSLIM_GB()

static BOOLEAN jjSLIM_GB ( leftv  res,
leftv  u 
)
static

Definition at line 4953 of file iparith.cc.

4954{
4955 const bool bIsSCA = rIsSCA(currRing);
4956
4957 if ((currRing->qideal!=NULL) && !bIsSCA)
4958 {
4959 WerrorS("qring not supported by slimgb at the moment");
4960 return TRUE;
4961 }
4963 {
4964 WerrorS("ordering must be global for slimgb");
4965 return TRUE;
4966 }
4968 WarnS("groebner base computations with inexact coefficients can not be trusted due to rounding errors");
4969 intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
4970 // tHomog hom=testHomog;
4971 ideal u_id=(ideal)u->Data();
4972 if (w!=NULL)
4973 {
4974 if (!idTestHomModule(u_id,currRing->qideal,w))
4975 {
4976 WarnS("wrong weights");
4977 w=NULL;
4978 }
4979 else
4980 {
4981 w=ivCopy(w);
4982 // hom=isHomog;
4983 }
4984 }
4985
4986 assume(u_id->rank>=id_RankFreeModule(u_id, currRing));
4987 res->data=(char *)t_rep_gb(currRing,
4988 u_id,u_id->rank);
4989 //res->data=(char *)t_rep_gb(currRing, u_id);
4990
4992 if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
4993 return FALSE;
4994}
static bool rIsSCA(const ring r)
Definition: nc.h:190
ideal t_rep_gb(const ring r, ideal arg_I, int syz_comp, BOOLEAN F4_mode)
Definition: tgb.cc:3571

◆ jjSMATRIX_Mo()

static BOOLEAN jjSMATRIX_Mo ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6904 of file iparith.cc.

6905{
6906 int mi=(int)(long)v->Data();
6907 int ni=(int)(long)w->Data();
6908 if ((mi<0)||(ni<1))
6909 {
6910 Werror("converting to smatrix: dimensions must be positive(%dx%d)",mi,ni);
6911 return TRUE;
6912 }
6913 res->data = (char *)id_ResizeModule((ideal)u->CopyD(),
6914 mi,ni,currRing);
6915 return FALSE;
6916}
ideal id_ResizeModule(ideal mod, int rows, int cols, const ring R)

◆ jjSort_Id()

static BOOLEAN jjSort_Id ( leftv  res,
leftv  v 
)
static

Definition at line 5101 of file iparith.cc.

5102{
5103 res->data = (char *)idSort((ideal)v->Data());
5104 return FALSE;
5105}
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
Definition: ideals.h:184

◆ jjSORTLIST()

BOOLEAN jjSORTLIST ( leftv  ,
leftv  arg 
)

Definition at line 10213 of file iparith.cc.

10214{
10215 lists l=(lists)arg->Data();
10216 if (l->nr>0)
10217 {
10218 qsort(l->m,l->nr+1,sizeof(sleftv),jjCOMPARE_ALL);
10219 }
10220 return FALSE;
10221}
static int jjCOMPARE_ALL(const void *aa, const void *bb)
Definition: iparith.cc:10172

◆ jjSQR_FREE()

static BOOLEAN jjSQR_FREE ( leftv  res,
leftv  u 
)
static

Definition at line 5106 of file iparith.cc.

5107{
5109 intvec *v=NULL;
5110 ideal f=singclap_sqrfree((poly)(u->CopyD()), &v, 0, currRing);
5111 if (f==NULL) return TRUE;
5112 ivTest(v);
5114 l->Init(2);
5115 l->m[0].rtyp=IDEAL_CMD;
5116 l->m[0].data=(void *)f;
5117 l->m[1].rtyp=INTVEC_CMD;
5118 l->m[1].data=(void *)v;
5119 res->data=(void *)l;
5120 return FALSE;
5121}
ideal singclap_sqrfree(poly f, intvec **v, int with_exps, const ring r)
Definition: clapsing.cc:1338

◆ jjSQR_FREE2()

static BOOLEAN jjSQR_FREE2 ( leftv  res,
leftv  u,
leftv  dummy 
)
static

Definition at line 3315 of file iparith.cc.

3316{
3317 intvec *v=NULL;
3318 int sw=(int)(long)dummy->Data();
3319 int fac_sw=sw;
3320 if (sw<0) fac_sw=1;
3322 ideal f=singclap_sqrfree((poly)(u->CopyD()), &v, fac_sw, currRing);
3323 if (f==NULL)
3324 return TRUE;
3325 switch(sw)
3326 {
3327 case 0:
3328 case 2:
3329 {
3331 l->Init(2);
3332 l->m[0].rtyp=IDEAL_CMD;
3333 l->m[0].data=(void *)f;
3334 l->m[1].rtyp=INTVEC_CMD;
3335 l->m[1].data=(void *)v;
3336 res->data=(void *)l;
3337 res->rtyp=LIST_CMD;
3338 return FALSE;
3339 }
3340 case 1:
3341 res->data=(void *)f;
3342 return FALSE;
3343 case 3:
3344 {
3345 poly p=f->m[0];
3346 int i=IDELEMS(f);
3347 f->m[0]=NULL;
3348 while(i>1)
3349 {
3350 i--;
3351 p=pMult(p,f->m[i]);
3352 f->m[i]=NULL;
3353 }
3354 res->data=(void *)p;
3355 res->rtyp=POLY_CMD;
3356 }
3357 return FALSE;
3358 }
3359 WerrorS("invalid switch");
3360 return FALSE;
3361}

◆ jjSTATUS2()

static BOOLEAN jjSTATUS2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3362 of file iparith.cc.

3363{
3364 res->data = omStrDup(slStatus((si_link) u->Data(), (char *) v->Data()));
3365 return FALSE;
3366}

◆ jjSTATUS2L()

static BOOLEAN jjSTATUS2L ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3367 of file iparith.cc.

3368{
3369 res->data = (void *)(long)slStatusSsiL((lists) u->Data(), (int)(long) v->Data());
3370 //return (res->data== (void*)(long)-2);
3371 return FALSE;
3372}

◆ jjSTATUS3()

static BOOLEAN jjSTATUS3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 7069 of file iparith.cc.

7070{
7071 int yes;
7072 jjSTATUS2(res, u, v);
7073 yes = (strcmp((char *) res->data, (char *) w->Data()) == 0);
7074 omFreeBinAddr((ADDRESS) res->data);
7075 res->data = (void *)(long)yes;
7076 return FALSE;
7077}
static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
Definition: iparith.cc:3362

◆ jjSTATUS_M()

static BOOLEAN jjSTATUS_M ( leftv  res,
leftv  v 
)
static

Definition at line 8518 of file iparith.cc.

8519{
8520 if ((v->Typ() != LINK_CMD) ||
8521 (v->next->Typ() != STRING_CMD) ||
8522 (v->next->next->Typ() != STRING_CMD) ||
8523 (v->next->next->next->Typ() != INT_CMD))
8524 return TRUE;
8525 jjSTATUS3(res, v, v->next, v->next->next);
8526#if defined(HAVE_USLEEP)
8527 if (((long) res->data) == 0L)
8528 {
8529 int i_s = (int)(long) v->next->next->next->Data();
8530 if (i_s > 0)
8531 {
8532 usleep((int)(long) v->next->next->next->Data());
8533 jjSTATUS3(res, v, v->next, v->next->next);
8534 }
8535 }
8536#elif defined(HAVE_SLEEP)
8537 if (((int) res->data) == 0)
8538 {
8539 int i_s = (int) v->next->next->next->Data();
8540 if (i_s > 0)
8541 {
8542 si_sleep((is - 1)/1000000 + 1);
8543 jjSTATUS3(res, v, v->next, v->next->next);
8544 }
8545 }
8546#endif
8547 return FALSE;
8548}
static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
Definition: iparith.cc:7069
@ LINK_CMD
Definition: tok.h:117

◆ jjSTD()

static BOOLEAN jjSTD ( leftv  res,
leftv  v 
)
static

Definition at line 5073 of file iparith.cc.

5074{
5076 WarnS("groebner base computations with inexact coefficients can not be trusted due to rounding errors");
5077 ideal result;
5078 ideal v_id=(ideal)v->Data();
5079 intvec *w=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
5080 tHomog hom=testHomog;
5081 if (w!=NULL)
5082 {
5083 if (!idTestHomModule(v_id,currRing->qideal,w))
5084 {
5085 WarnS("wrong weights");
5086 w=NULL;
5087 }
5088 else
5089 {
5090 hom=isHomog;
5091 w=ivCopy(w);
5092 }
5093 }
5094 result=kStd(v_id,currRing->qideal,hom,&w);
5096 res->data = (char *)result;
5098 if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
5099 return FALSE;
5100}

◆ jjSTD_1()

static BOOLEAN jjSTD_1 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3415 of file iparith.cc.

3416{
3417 ideal result;
3418 assumeStdFlag(u);
3419 ideal i1=(ideal)(u->Data());
3420 int ii1=idElem(i1); /* size of i1 */
3421 ideal i0;
3422 int r=v->Typ();
3423 if ((/*v->Typ()*/r==POLY_CMD) ||(r==VECTOR_CMD))
3424 {
3425 poly p=(poly)v->Data();
3426 i0=idInit(1,i1->rank);
3427 i0->m[0]=p;
3428 i1=idSimpleAdd(i1,i0); //
3429 memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
3430 idDelete(&i0);
3431 intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3432 tHomog hom=testHomog;
3433
3434 if (w!=NULL)
3435 {
3436 if (!idTestHomModule(i1,currRing->qideal,w))
3437 {
3438 // no warnung: this is legal, if i in std(i,p)
3439 // is homogeneous, but p not
3440 w=NULL;
3441 }
3442 else
3443 {
3444 w=ivCopy(w);
3445 hom=isHomog;
3446 }
3447 }
3448 BITSET save1;
3449 SI_SAVE_OPT1(save1);
3451 /* ii1 appears to be the position of the first element of il that
3452 does not belong to the old SB ideal */
3453 result=kStd(i1,currRing->qideal,hom,&w,NULL,0,ii1);
3454 SI_RESTORE_OPT1(save1);
3455 idDelete(&i1);
3457 if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3458 res->data = (char *)result;
3459 }
3460 else /*IDEAL/MODULE*/
3461 {
3462 i0=(ideal)v->CopyD();
3463 i1=idSimpleAdd(i1,i0); //
3464 memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
3465 idDelete(&i0);
3466 intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3467 tHomog hom=testHomog;
3468
3469 if (w!=NULL)
3470 {
3471 if (!idTestHomModule(i1,currRing->qideal,w))
3472 {
3473 // no warnung: this is legal, if i in std(i,p)
3474 // is homogeneous, but p not
3475 w=NULL;
3476 hom=isNotHomog;
3477 }
3478 else
3479 {
3480 w=ivCopy(w);
3481 hom=isHomog;
3482 }
3483 }
3484 BITSET save1;
3485 SI_SAVE_OPT1(save1);
3487 /* ii1 appears to be the position of the first element of i1 that
3488 does not belong to the old SB ideal */
3489 result=kStd(i1,currRing->qideal,hom,&w,NULL,0,ii1);
3490 SI_RESTORE_OPT1(save1);
3491 idDelete(&i1);
3493 if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3494 res->data = (char *)result;
3495 }
3497 return FALSE;
3498}
#define OPT_SB_1
Definition: options.h:96
#define SI_SAVE_OPT1(A)
Definition: options.h:21
#define SI_RESTORE_OPT1(A)
Definition: options.h:24
@ isNotHomog
Definition: structs.h:36

◆ jjSTD_HILB()

static BOOLEAN jjSTD_HILB ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3389 of file iparith.cc.

3390{
3391 ideal result;
3392 intvec *w=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3393 tHomog hom=testHomog;
3394 ideal u_id=(ideal)(u->Data());
3395 if (w!=NULL)
3396 {
3397 if (!idTestHomModule(u_id,currRing->qideal,w))
3398 {
3399 WarnS("wrong weights:");w->show();PrintLn();
3400 w=NULL;
3401 }
3402 else
3403 {
3404 w=ivCopy(w);
3405 hom=isHomog;
3406 }
3407 }
3408 result=kStd(u_id,currRing->qideal,hom,&w,(intvec *)v->Data());
3410 res->data = (char *)result;
3412 if (w!=NULL) atSet(res,omStrDup("isHomog"),w,INTVEC_CMD);
3413 return FALSE;
3414}

◆ jjSTD_HILB_W()

static BOOLEAN jjSTD_HILB_W ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 7078 of file iparith.cc.

7079{
7080 intvec *vw=(intvec *)w->Data(); // weights of vars
7081 if (vw->length()!=currRing->N)
7082 {
7083 Werror("%d weights for %d variables",vw->length(),currRing->N);
7084 return TRUE;
7085 }
7086 ideal result;
7087 intvec *ww=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
7088 tHomog hom=testHomog;
7089 ideal u_id=(ideal)(u->Data());
7090 if (ww!=NULL)
7091 {
7092 if (!idTestHomModule(u_id,currRing->qideal,ww))
7093 {
7094 WarnS("wrong weights");
7095 ww=NULL;
7096 }
7097 else
7098 {
7099 ww=ivCopy(ww);
7100 hom=isHomog;
7101 }
7102 }
7103 result=kStd(u_id,
7104 currRing->qideal,
7105 hom,
7106 &ww, // module weights
7107 (intvec *)v->Data(), // hilbert series
7108 0,0, // syzComp, newIdeal
7109 vw); // weights of vars
7111 res->data = (char *)result;
7113 if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
7114 return FALSE;
7115}

◆ jjSTD_HILB_WP()

static BOOLEAN jjSTD_HILB_WP ( leftv  res,
leftv  INPUT 
)
static

Definition at line 8593 of file iparith.cc.

8594{ ideal result;
8595 leftv u = INPUT; /* an ideal, weighted homogeneous and standard */
8596 leftv v = u->next; /* one additional polynomial or ideal */
8597 leftv h = v->next; /* Hilbert vector */
8598 leftv w = h->next; /* weight vector */
8599 assumeStdFlag(u);
8600 ideal i1=(ideal)(u->Data());
8601 ideal i0;
8602 if (((u->Typ()!=IDEAL_CMD)&&(u->Typ()!=MODUL_CMD))
8603 || (h->Typ()!=INTVEC_CMD)
8604 || (w->Typ()!=INTVEC_CMD))
8605 {
8606 WerrorS("expected `std(`ideal/module`,`poly/vector`,`intvec`,`intvec`)");
8607 return TRUE;
8608 }
8609 intvec *vw=(intvec *)w->Data(); // weights of vars
8610 /* merging std_hilb_w and std_1 */
8611 if (vw->length()!=currRing->N)
8612 {
8613 Werror("%d weights for %d variables",vw->length(),currRing->N);
8614 return TRUE;
8615 }
8616 int r=v->Typ();
8617 BOOLEAN cleanup_i0=FALSE;
8618 if ((r==POLY_CMD) ||(r==VECTOR_CMD))
8619 {
8620 i0=idInit(1,i1->rank);
8621 i0->m[0]=(poly)v->Data();
8622 cleanup_i0=TRUE;
8623 }
8624 else if (r==IDEAL_CMD)/* IDEAL */
8625 {
8626 i0=(ideal)v->Data();
8627 }
8628 else
8629 {
8630 WerrorS("expected `std(`ideal/module`,`poly/vector`,`intvec`,`intvec`)");
8631 return TRUE;
8632 }
8633 int ii0=idElem(i0);
8634 i1 = idSimpleAdd(i1,i0);
8635 if (cleanup_i0)
8636 {
8637 memset(i0->m,0,sizeof(poly)*IDELEMS(i0));
8638 idDelete(&i0);
8639 }
8640 intvec *ww=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
8641 tHomog hom=testHomog;
8642 /* u_id from jjSTD_W is now i1 as in jjSTD_1 */
8643 if (ww!=NULL)
8644 {
8645 if (!idTestHomModule(i1,currRing->qideal,ww))
8646 {
8647 WarnS("wrong weights");
8648 ww=NULL;
8649 }
8650 else
8651 {
8652 ww=ivCopy(ww);
8653 hom=isHomog;
8654 }
8655 }
8656 BITSET save1;
8657 SI_SAVE_OPT1(save1);
8659 result=kStd(i1,
8660 currRing->qideal,
8661 hom,
8662 &ww, // module weights
8663 (intvec *)h->Data(), // hilbert series
8664 0, // syzComp, whatever it is...
8665 IDELEMS(i1)-ii0, // new ideal
8666 vw); // weights of vars
8667 SI_RESTORE_OPT1(save1);
8668 idDelete(&i1);
8670 res->data = (char *)result;
8672 if (ww!=NULL) atSet(res,omStrDup("isHomog"),ww,INTVEC_CMD);
8673 return FALSE;
8674}

◆ jjSTRING_PL()

static BOOLEAN jjSTRING_PL ( leftv  res,
leftv  v 
)
static

Definition at line 8333 of file iparith.cc.

8334{
8335 if (v == NULL)
8336 {
8337 res->data = omStrDup("");
8338 return FALSE;
8339 }
8340 int n = v->listLength();
8341 if (n == 1)
8342 {
8343 res->data = v->String();
8344 return FALSE;
8345 }
8346
8347 char** slist = (char**) omAlloc(n*sizeof(char*));
8348 int i, j;
8349
8350 for (i=0, j=0; i<n; i++, v = v ->next)
8351 {
8352 slist[i] = v->String();
8353 assume(slist[i] != NULL);
8354 j+=strlen(slist[i]);
8355 }
8356 char* s = (char*) omAlloc((j+1)*sizeof(char));
8357 *s='\0';
8358 for (i=0;i<n;i++)
8359 {
8360 strcat(s, slist[i]);
8361 omFree(slist[i]);
8362 }
8363 omFreeSize(slist, n*sizeof(char*));
8364 res->data = s;
8365 return FALSE;
8366}

◆ jjstrlen()

static BOOLEAN jjstrlen ( leftv  res,
leftv  v 
)
static

Definition at line 5584 of file iparith.cc.

5585{
5586 res->data = (char *)strlen((char *)v->Data());
5587 return FALSE;
5588}

◆ jjSUBST_Bu()

static BOOLEAN jjSUBST_Bu ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6626 of file iparith.cc.

6627{
6628 // generic conversion from polyBucket to poly:
6629 // force this to be the first try everytime
6630 poly p; int l;
6631 sBucket_pt bu=(sBucket_pt)w->CopyD();
6632 sBucketDestroyAdd(bu,&p,&l);
6633 sleftv tmpw;
6634 tmpw.Init();
6635 tmpw.rtyp=POLY_CMD;
6636 tmpw.data=p;
6637 return iiExprArith3(res, iiOp, u, v, &tmpw);
6638}

◆ jjSUBST_Id()

static BOOLEAN jjSUBST_Id ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6672 of file iparith.cc.

6673{
6674 int ringvar;
6675 poly monomexpr;
6676 BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
6677 if (nok) return TRUE;
6678 ideal id=(ideal)u->Data();
6679 if (ringvar>0)
6680 {
6681 BOOLEAN overflow=FALSE;
6682 if (!rIsLPRing(currRing) && (monomexpr!=NULL))
6683 {
6684 long deg_monexp=pTotaldegree(monomexpr);
6685 for(int i=IDELEMS(id)-1;i>=0;i--)
6686 {
6687 poly p=id->m[i];
6688 int mm=p_MaxExpPerVar(p,ringvar,currRing);
6689 if ((p!=NULL) && (mm!=0) &&
6690 ((unsigned long)deg_monexp > (currRing->bitmask / (unsigned long)mm/2)))
6691 {
6692 overflow=TRUE;
6693 break;
6694 }
6695 }
6696 }
6697 if (overflow)
6698 Warn("possible OVERFLOW in subst, max exponent is %ld",currRing->bitmask/2);
6699 if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
6700 {
6701 if (res->rtyp==MATRIX_CMD) id=(ideal)mp_Copy((matrix)id,currRing);
6702 else id=id_Copy(id,currRing);
6703 res->data = id_Subst(id, ringvar, monomexpr, currRing);
6704 }
6705 else
6706 res->data = idSubstPoly(id,ringvar,monomexpr);
6707 }
6708 else
6709 {
6710 if (rIsLPRing(currRing))
6711 {
6712 WerrorS("Substituting parameters not implemented for Letterplace rings.");
6713 return TRUE;
6714 }
6715 res->data = idSubstPar(id,-ringvar,monomexpr);
6716 }
6717 return FALSE;
6718}
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static BOOLEAN jjSUBST_Test(leftv v, leftv w, int &ringvar, poly &monomexpr)
Definition: iparith.cc:6598
ideal idSubstPoly(ideal id, int n, poly e)
Definition: maps_ip.cc:426
ideal idSubstPar(ideal id, int n, poly e)
Definition: maps_ip.cc:387
int p_MaxExpPerVar(poly p, int i, const ring r)
max exponent of variable x_i in p
Definition: p_polys.cc:5119
ideal id_Subst(ideal id, int n, poly e, const ring r)

◆ jjSUBST_Id_I()

static BOOLEAN jjSUBST_Id_I ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6722 of file iparith.cc.

6723{
6724 return jjSUBST_Id_X(res,u,v,w,INT_CMD);
6725}
static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v, leftv w, int input_type)
Definition: iparith.cc:6730

◆ jjSUBST_Id_N()

static BOOLEAN jjSUBST_Id_N ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6726 of file iparith.cc.

6727{
6728 return jjSUBST_Id_X(res,u,v,w,NUMBER_CMD);
6729}

◆ jjSUBST_Id_X()

static BOOLEAN jjSUBST_Id_X ( leftv  res,
leftv  u,
leftv  v,
leftv  w,
int  input_type 
)
static

Definition at line 6730 of file iparith.cc.

6731{
6732 sleftv tmp;
6733 tmp.Init();
6734 // do not check the result, conversion from int/number to poly works always
6735 iiConvert(input_type,POLY_CMD,iiTestConvert(input_type,POLY_CMD),w,&tmp);
6736 BOOLEAN b=jjSUBST_Id(res,u,v,&tmp);
6737 tmp.CleanUp();
6738 return b;
6739}
static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v, leftv w)
Definition: iparith.cc:6672

◆ jjSUBST_M()

static BOOLEAN jjSUBST_M ( leftv  res,
leftv  u 
)
static

Definition at line 8549 of file iparith.cc.

8550{
8551 leftv v = u->next; // number of args > 0
8552 if (v==NULL) return TRUE;
8553 leftv w = v->next;
8554 if (w==NULL) return TRUE;
8555 leftv rest = w->next;
8556
8557 u->next = NULL;
8558 v->next = NULL;
8559 w->next = NULL;
8560 BOOLEAN b = iiExprArith3(res, iiOp, u, v, w);
8561 if ((rest!=NULL) && (!b))
8562 {
8563 leftv tmp_next=res->next;
8564 res->next=rest;
8565 sleftv tmp_res;
8566 tmp_res.Init();
8567 b = iiExprArithM(&tmp_res,res,iiOp);
8568 memcpy(res,&tmp_res,sizeof(tmp_res));
8569 res->next=tmp_next;
8570 }
8571 u->next = v;
8572 v->next = w;
8573 // rest was w->next, but is already cleaned
8574 return b;
8575}

◆ jjSUBST_P()

static BOOLEAN jjSUBST_P ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)
static

Definition at line 6639 of file iparith.cc.

6640{
6641 int ringvar;
6642 poly monomexpr;
6643 BOOLEAN nok=jjSUBST_Test(v,w,ringvar,monomexpr);
6644 if (nok) return TRUE;
6645 poly p=(poly)u->Data();
6646 if (ringvar>0)
6647 {
6648 int mm=p_MaxExpPerVar(p,ringvar,currRing);
6649 if (!rIsLPRing(currRing) &&
6650 (monomexpr!=NULL) && (p!=NULL) && (mm!=0) &&
6651 ((unsigned long)pTotaldegree(monomexpr) > (currRing->bitmask / (unsigned long)mm/2)))
6652 {
6653 Warn("possible OVERFLOW in subst, max exponent is %ld, substituting deg %d by deg %d",currRing->bitmask/2, pTotaldegree(monomexpr), mm);
6654 //return TRUE;
6655 }
6656 if ((monomexpr==NULL)||(pNext(monomexpr)==NULL))
6657 res->data = pSubst((poly)u->CopyD(res->rtyp),ringvar,monomexpr);
6658 else
6659 res->data= pSubstPoly(p,ringvar,monomexpr);
6660 }
6661 else
6662 {
6663 if (rIsLPRing(currRing))
6664 {
6665 WerrorS("Substituting parameters not implemented for Letterplace rings.");
6666 return TRUE;
6667 }
6668 res->data=pSubstPar(p,-ringvar,monomexpr);
6669 }
6670 return FALSE;
6671}
poly pSubstPoly(poly p, int var, poly image)
Definition: maps_ip.cc:404
poly pSubstPar(poly p, int par, poly image)
Definition: maps_ip.cc:267

◆ jjSUBST_Test()

static BOOLEAN jjSUBST_Test ( leftv  v,
leftv  w,
int &  ringvar,
poly &  monomexpr 
)
static

Definition at line 6598 of file iparith.cc.

6600{
6601 monomexpr=(poly)w->Data();
6602 poly p=(poly)v->Data();
6603#if 0
6604 if (pLength(monomexpr)>1)
6605 {
6606 Werror("`%s` substitutes a ringvar only by a term",
6608 return TRUE;
6609 }
6610#endif
6611 if ((ringvar=pVar(p))==0)
6612 {
6613 if ((p!=NULL) && (currRing->cf->extRing!=NULL))
6614 {
6615 number n = pGetCoeff(p);
6616 ringvar= -n_IsParam(n, currRing);
6617 }
6618 if(ringvar==0)
6619 {
6620 WerrorS("ringvar/par expected");
6621 return TRUE;
6622 }
6623 }
6624 return FALSE;
6625}
int n_IsParam(const number m, const ring r)
TODO: rewrite somehow...
Definition: ring.cc:5897
@ SUBST_CMD
Definition: tok.h:186

◆ jjSYZ_2()

static BOOLEAN jjSYZ_2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3499 of file iparith.cc.

3500{
3501 // see jjSYZYGY
3502 intvec *ww=(intvec *)atGet(u,"isHomog",INTVEC_CMD);
3503 intvec *w=NULL;
3504 tHomog hom=testHomog;
3505 ideal I=(ideal)u->Data();
3506 GbVariant alg=syGetAlgorithm((char*)v->Data(),currRing,I);
3507 if (ww!=NULL)
3508 {
3509 if (idTestHomModule(I,currRing->qideal,ww))
3510 {
3511 w=ivCopy(ww);
3512 int add_row_shift=w->min_in();
3513 (*w)-=add_row_shift;
3514 hom=isHomog;
3515 }
3516 else
3517 {
3518 //WarnS("wrong weights");
3519 delete ww; ww=NULL;
3520 hom=testHomog;
3521 }
3522 }
3523 else
3524 {
3525 if (u->Typ()==IDEAL_CMD)
3526 if (idHomIdeal(I,currRing->qideal))
3527 hom=isHomog;
3528 }
3529 ideal S=idSyzygies(I,hom,&w,TRUE,FALSE,NULL,alg);
3530 if (w!=NULL) delete w;
3531 res->data = (char *)S;
3532 if (hom==isHomog)
3533 {
3534 int vl=S->rank;
3535 intvec *vv=new intvec(vl);
3536 if ((u->Typ()==IDEAL_CMD)||(ww==NULL))
3537 {
3538 for(int i=0;i<vl;i++)
3539 {
3540 if (I->m[i]!=NULL)
3541 (*vv)[i]=p_Deg(I->m[i],currRing);
3542 }
3543 }
3544 else
3545 {
3546 p_SetModDeg(ww, currRing);
3547 for(int i=0;i<vl;i++)
3548 {
3549 if (I->m[i]!=NULL)
3550 (*vv)[i]=currRing->pFDeg(I->m[i],currRing);
3551 }
3553 }
3554 if (idTestHomModule(S,currRing->qideal,vv))
3555 atSet(res,omStrDup("isHomog"),vv,INTVEC_CMD);
3556 else
3557 delete vv;
3558 }
3560 return FALSE;
3561}
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
Definition: ideals.cc:830
void p_SetModDeg(intvec *w, ring r)
Definition: p_polys.cc:3789
long p_Deg(poly a, const ring r)
Definition: p_polys.cc:587

◆ jjSYZYGY()

static BOOLEAN jjSYZYGY ( leftv  res,
leftv  v 
)
static

Definition at line 5133 of file iparith.cc.

5134{
5135 ideal v_id=(ideal)v->Data();
5136#ifdef HAVE_SHIFTBBA
5137 if (rIsLPRing(currRing))
5138 {
5139 if (currRing->LPncGenCount < IDELEMS(v_id))
5140 {
5141 Werror("At least %d ncgen variables are needed for this computation.", IDELEMS(v_id));
5142 return TRUE;
5143 }
5144 }
5145#endif
5146 intvec *ww=(intvec *)atGet(v,"isHomog",INTVEC_CMD);
5147 intvec *w=NULL;
5148 tHomog hom=testHomog;
5149 if (ww!=NULL)
5150 {
5151 if (idTestHomModule(v_id,currRing->qideal,ww))
5152 {
5153 w=ivCopy(ww);
5154 int add_row_shift=w->min_in();
5155 (*w)-=add_row_shift;
5156 hom=isHomog;
5157 }
5158 else
5159 {
5160 //WarnS("wrong weights");
5161 delete ww; ww=NULL;
5162 hom=testHomog;
5163 }
5164 }
5165 else
5166 {
5167 if (v->Typ()==IDEAL_CMD)
5168 if (idHomIdeal(v_id,currRing->qideal))
5169 hom=isHomog;
5170 }
5171 ideal S=idSyzygies(v_id,hom,&w);
5172 res->data = (char *)S;
5173 if (hom==isHomog)
5174 {
5175 int vl=S->rank;
5176 intvec *vv=new intvec(vl);
5177 if ((v->Typ()==IDEAL_CMD)||(ww==NULL))
5178 {
5179 for(int i=0;i<vl;i++)
5180 {
5181 if (v_id->m[i]!=NULL)
5182 (*vv)[i]=p_Deg(v_id->m[i],currRing);
5183 }
5184 }
5185 else
5186 {
5187 p_SetModDeg(ww, currRing);
5188 for(int i=0;i<vl;i++)
5189 {
5190 if (v_id->m[i]!=NULL)
5191 (*vv)[i]=currRing->pFDeg(v_id->m[i],currRing);
5192 }
5194 }
5195 if (idTestHomModule(S,currRing->qideal,vv))
5196 atSet(res,omStrDup("isHomog"),vv,INTVEC_CMD);
5197 else
5198 delete vv;
5199 }
5200 if (w!=NULL) delete w;
5201 return FALSE;
5202}

◆ jjTENSOR()

static BOOLEAN jjTENSOR ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3562 of file iparith.cc.

3563{
3564 ideal A=(ideal)u->Data();
3565 ideal B=(ideal)v->Data();
3566 res->data = (char *)sm_Tensor(A,B,currRing);
3567 return FALSE;
3568}
ideal sm_Tensor(ideal A, ideal B, const ring r)
Definition: matpol.cc:1831

◆ jjTENSOR_Ma()

static BOOLEAN jjTENSOR_Ma ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3569 of file iparith.cc.

3570{
3571 sleftv tmp_u,tmp_v,tmp_res;
3575 tmp_res.Init();
3576 tmp_res.rtyp=SMATRIX_CMD;
3577 BOOLEAN bo=jjTENSOR(&tmp_res,&tmp_u,&tmp_v);
3578 if (!bo)
3579 {
3582 }
3583 tmp_u.CleanUp();
3584 tmp_v.CleanUp();
3585 tmp_res.CleanUp();
3586 return bo;
3587}
static BOOLEAN jjTENSOR(leftv res, leftv u, leftv v)
Definition: iparith.cc:3562
static int index(p_Length length, p_Ord ord)
Definition: p_Procs_Impl.h:592

◆ jjTEST()

static BOOLEAN jjTEST ( leftv  ,
leftv  v 
)
static

Definition at line 8367 of file iparith.cc.

8368{
8369 do
8370 {
8371 if (v->Typ()!=INT_CMD)
8372 return TRUE;
8373 test_cmd((int)(long)v->Data());
8374 v=v->next;
8375 }
8376 while (v!=NULL);
8377 return FALSE;
8378}
void test_cmd(int i)
Definition: ipshell.cc:514

◆ jjTIMES_BI()

static BOOLEAN jjTIMES_BI ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 995 of file iparith.cc.

996{
997 res->data = (char *)(n_Mult( (number)u->Data(), (number)v->Data(),coeffs_BIGINT));
998 if ((v->next!=NULL) || (u->next!=NULL))
999 return jjOP_REST(res,u,v);
1000 return FALSE;
1001}
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
Definition: coeffs.h:636

◆ jjTIMES_BIM()

static BOOLEAN jjTIMES_BIM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1078 of file iparith.cc.

1079{
1080 res->data = (char *)bimMult((bigintmat*)(u->Data()), (bigintmat*)(v->Data()));
1081 if (res->data==NULL)
1082 {
1083 WerrorS("bigintmat/cmatrix not compatible");
1084 return TRUE;
1085 }
1086 if ((v->next!=NULL) || (u->next!=NULL))
1087 return jjOP_REST(res,u,v);
1088 return FALSE;
1089}

◆ jjTIMES_I()

static BOOLEAN jjTIMES_I ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 983 of file iparith.cc.

984{
985 long a=(long)u->Data();
986 long b=(long)v->Data();
987 long c=a * b;
988 if ((a!=0)&&(c/a!=b))
989 WarnS("int overflow(*), result may be wrong");
990 res->data = (char *)c;
991 if ((u->Next()!=NULL) || (v->Next()!=NULL))
992 return jjOP_REST(res,u,v);
993 return FALSE;
994}

◆ jjTIMES_ID()

static BOOLEAN jjTIMES_ID ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1059 of file iparith.cc.

1060{
1061 res->data = (char *)idMult((ideal)u->Data(),(ideal)v->Data());
1062 if ((v->next!=NULL) || (u->next!=NULL))
1063 return jjOP_REST(res,u,v);
1064 return FALSE;
1065}
static ideal idMult(ideal h1, ideal h2)
hh := h1 * h2
Definition: ideals.h:84

◆ jjTIMES_IV()

static BOOLEAN jjTIMES_IV ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1066 of file iparith.cc.

1067{
1068 res->data = (char *)ivMult((intvec*)(u->Data()), (intvec*)(v->Data()));
1069 if (res->data==NULL)
1070 {
1071 WerrorS("intmat size not compatible");
1072 return TRUE;
1073 }
1074 if ((v->next!=NULL) || (u->next!=NULL))
1075 return jjOP_REST(res,u,v);
1076 return FALSE;
1077}
intvec * ivMult(intvec *a, intvec *b)
Definition: intvec.cc:349

◆ jjTIMES_MA()

static BOOLEAN jjTIMES_MA ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1142 of file iparith.cc.

1143{
1144 matrix A=(matrix)u->Data(); matrix B=(matrix)v->Data();
1145 res->data = (char *)mp_Mult(A,B,currRing);
1146 if (res->data==NULL)
1147 {
1148 Werror("matrix size not compatible(%dx%d, %dx%d) in *",
1150 return TRUE;
1151 }
1152 if ((v->next!=NULL) || (u->next!=NULL))
1153 return jjOP_REST(res,u,v);
1154 return FALSE;
1155}
matrix mp_Mult(matrix a, matrix b, const ring R)
Definition: matpol.cc:213

◆ jjTIMES_MA_BI1()

static BOOLEAN jjTIMES_MA_BI1 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1090 of file iparith.cc.

1091{
1093 if (nMap==NULL) return TRUE;
1094 number n=nMap((number)v->Data(),coeffs_BIGINT,currRing->cf);
1095 poly p=pNSet(n);
1096 ideal I= (ideal)mp_MultP((matrix)u->CopyD(MATRIX_CMD),p,currRing);
1097 res->data = (char *)I;
1098 return FALSE;
1099}
matrix mp_MultP(matrix a, poly p, const ring R)
multiply a matrix 'a' by a poly 'p', destroy the args
Definition: matpol.cc:148

◆ jjTIMES_MA_BI2()

static BOOLEAN jjTIMES_MA_BI2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1100 of file iparith.cc.

1101{
1102 return jjTIMES_MA_BI1(res,v,u);
1103}
static BOOLEAN jjTIMES_MA_BI1(leftv res, leftv u, leftv v)
Definition: iparith.cc:1090

◆ jjTIMES_MA_I1()

static BOOLEAN jjTIMES_MA_I1 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1133 of file iparith.cc.

1134{
1135 res->data = (char *)mp_MultI((matrix)u->CopyD(MATRIX_CMD),(int)(long)v->Data(),currRing);
1136 return FALSE;
1137}
matrix mp_MultI(matrix a, int f, const ring R)
c = f*a
Definition: matpol.cc:135

◆ jjTIMES_MA_I2()

static BOOLEAN jjTIMES_MA_I2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1138 of file iparith.cc.

1139{
1140 return jjTIMES_MA_I1(res,v,u);
1141}
static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
Definition: iparith.cc:1133

◆ jjTIMES_MA_N1()

static BOOLEAN jjTIMES_MA_N1 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1122 of file iparith.cc.

1123{
1124 number n=(number)v->CopyD(NUMBER_CMD);
1125 poly p=pNSet(n);
1126 res->data = (char *)mp_MultP((matrix)u->CopyD(MATRIX_CMD),p,currRing);
1127 return FALSE;
1128}

◆ jjTIMES_MA_N2()

static BOOLEAN jjTIMES_MA_N2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1129 of file iparith.cc.

1130{
1131 return jjTIMES_MA_N1(res,v,u);
1132}
static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
Definition: iparith.cc:1122

◆ jjTIMES_MA_P1()

static BOOLEAN jjTIMES_MA_P1 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1104 of file iparith.cc.

1105{
1106 poly p=(poly)v->CopyD(POLY_CMD);
1107 int r=pMaxComp(p);/* recompute the rank for the case ideal*vector*/
1108 ideal I= (ideal)mp_MultP((matrix)u->CopyD(MATRIX_CMD),p,currRing);
1109 if (r>0) I->rank=r;
1110 res->data = (char *)I;
1111 return FALSE;
1112}
long rank
Definition: matpol.h:19

◆ jjTIMES_MA_P2()

static BOOLEAN jjTIMES_MA_P2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1113 of file iparith.cc.

1114{
1115 poly p=(poly)u->CopyD(POLY_CMD);
1116 int r=pMaxComp(p);/* recompute the rank for the case ideal*vector*/
1117 ideal I= (ideal)pMultMp(p,(matrix)v->CopyD(MATRIX_CMD),currRing);
1118 if (r>0) I->rank=r;
1119 res->data = (char *)I;
1120 return FALSE;
1121}
matrix pMultMp(poly p, matrix a, const ring R)
Definition: matpol.cc:165

◆ jjTIMES_N()

static BOOLEAN jjTIMES_N ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1002 of file iparith.cc.

1003{
1004 res->data = (char *)(nMult( (number)u->Data(), (number)v->Data()));
1005 number n=(number)res->data;
1006 nNormalize(n);
1007 res->data=(char *)n;
1008 if ((v->next!=NULL) || (u->next!=NULL))
1009 return jjOP_REST(res,u,v);
1010 return FALSE;
1011}
#define nMult(n1, n2)
Definition: numbers.h:17

◆ jjTIMES_P()

static BOOLEAN jjTIMES_P ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1012 of file iparith.cc.

1013{
1014 poly a;
1015 poly b;
1016 if (v->next==NULL)
1017 {
1018 if (u->next==NULL)
1019 {
1020 a=(poly)u->Data(); // works also for VECTOR_CMD
1021 b=(poly)v->Data(); // works also for VECTOR_CMD
1022 if (!rIsLPRing(currRing)
1023 && (a!=NULL) && (b!=NULL)
1024 && ((long)pTotaldegree(a)>si_max((long)rVar(currRing),(long)currRing->bitmask/2)-(long)pTotaldegree(b)))
1025 {
1026 Warn("possible OVERFLOW in mult(d=%ld, d=%ld, max=%ld)",
1027 pTotaldegree(a),pTotaldegree(b),currRing->bitmask/2);
1028 }
1029 res->data = (char *)(pp_Mult_qq( a, b, currRing));
1030 return FALSE;
1031 }
1032 // u->next exists: copy v
1033 a=(poly)u->CopyD(POLY_CMD); // works also for VECTOR_CMD
1034 b=pCopy((poly)v->Data());
1035 if (!rIsLPRing(currRing)
1036 && (a!=NULL) && (b!=NULL)
1037 && (pTotaldegree(a)+pTotaldegree(b)>si_max((long)rVar(currRing),(long)currRing->bitmask/2)))
1038 {
1039 Warn("possible OVERFLOW in mult(d=%ld, d=%ld, max=%ld)",
1040 pTotaldegree(a),pTotaldegree(b),currRing->bitmask/2);
1041 }
1042 res->data = (char *)(pMult( a, b));
1043 return jjOP_REST(res,u,v);
1044 }
1045 // v->next exists: copy u
1046 a=pCopy((poly)u->Data());
1047 b=(poly)v->CopyD(POLY_CMD); // works also for VECTOR_CMD
1048 if ((a!=NULL) && (b!=NULL)
1049 && ((unsigned long)(pTotaldegree(a)+pTotaldegree(b))>=currRing->bitmask/2))
1050 {
1051 pDelete(&a);
1052 pDelete(&b);
1053 WerrorS("OVERFLOW");
1054 return TRUE;
1055 }
1056 res->data = (char *)(pMult( a, b));
1057 return jjOP_REST(res,u,v);
1058}
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1153

◆ jjTIMES_SM()

static BOOLEAN jjTIMES_SM ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 1156 of file iparith.cc.

1157{
1158 ideal A=(ideal)u->Data(); ideal B=(ideal)v->Data();
1159 res->data = (char *)sm_Mult(A,B,currRing);
1160 if (res->data==NULL)
1161 {
1162 Werror("matrix size not compatible(%dx%d, %dx%d) in *",
1163 (int)A->rank,IDELEMS(A),(int)B->rank,IDELEMS(B));
1164 return TRUE;
1165 }
1166 if ((v->next!=NULL) || (u->next!=NULL))
1167 return jjOP_REST(res,u,v);
1168 return FALSE;
1169}
ideal sm_Mult(ideal a, ideal b, const ring R)
Definition: matpol.cc:1891

◆ jjTRACE_IV()

static BOOLEAN jjTRACE_IV ( leftv  res,
leftv  v 
)
static

Definition at line 5204 of file iparith.cc.

5205{
5206 res->data = (char *)(long)ivTrace((intvec*)(v->Data()));
5207 return FALSE;
5208}
int ivTrace(intvec *o)
Definition: intvec.cc:339

◆ jjTRANSP_BIM()

static BOOLEAN jjTRANSP_BIM ( leftv  res,
leftv  v 
)
static

Definition at line 5209 of file iparith.cc.

5210{
5211 res->data = (char *)(((bigintmat*)(v->Data()))->transpose());
5212 return FALSE;
5213}

◆ jjTRANSP_IV()

static BOOLEAN jjTRANSP_IV ( leftv  res,
leftv  v 
)
static

Definition at line 5214 of file iparith.cc.

5215{
5216 res->data = (char *)ivTranp((intvec*)(v->Data()));
5217 return FALSE;
5218}
intvec * ivTranp(intvec *o)
Definition: intvec.cc:327

◆ jjTWOSTD()

static BOOLEAN jjTWOSTD ( leftv  res,
leftv  a 
)
static

Definition at line 5253 of file iparith.cc.

5254{
5255#ifdef HAVE_PLURAL
5256 ideal result;
5257 ideal v_id=(ideal)a->Data();
5259 result=(ideal)twostd(v_id);
5260 else /*commutative or shiftalgebra*/
5261 {
5262 return jjSTD(res,a);
5263 }
5264 res->data = (char *)result;
5267 return FALSE;
5268#else
5269 return TRUE;
5270#endif
5271}
#define FLAG_TWOSTD
Definition: ipid.h:107
ideal twostd(ideal I)
Compute two-sided GB:
Definition: nc.cc:18

◆ jjTYPEOF()

static BOOLEAN jjTYPEOF ( leftv  res,
leftv  v 
)
static

Definition at line 5333 of file iparith.cc.

5334{
5335 int t=(int)(long)v->data;
5336 switch (t)
5337 {
5338 case CRING_CMD:
5339 case INT_CMD:
5340 case POLY_CMD:
5341 case VECTOR_CMD:
5342 case STRING_CMD:
5343 case INTVEC_CMD:
5344 case IDEAL_CMD:
5345 case MATRIX_CMD:
5346 case MODUL_CMD:
5347 case MAP_CMD:
5348 case PROC_CMD:
5349 case RING_CMD:
5350 case SMATRIX_CMD:
5351 //case QRING_CMD:
5352 case INTMAT_CMD:
5353 case BIGINTMAT_CMD:
5354 case NUMBER_CMD:
5355 #ifdef SINGULAR_4_2
5356 case CNUMBER_CMD:
5357 #endif
5358 case BIGINT_CMD:
5359 case BUCKET_CMD:
5360 case LIST_CMD:
5361 case PACKAGE_CMD:
5362 case LINK_CMD:
5363 case RESOLUTION_CMD:
5364 res->data=omStrDup(Tok2Cmdname(t)); break;
5365 case DEF_CMD:
5366 case NONE: res->data=omStrDup("none"); break;
5367 default:
5368 {
5369 if (t>MAX_TOK)
5370 res->data=omStrDup(getBlackboxName(t));
5371 else
5372 res->data=omStrDup("?unknown type?");
5373 break;
5374 }
5375 }
5376 return FALSE;
5377}
const char * getBlackboxName(const int t)
return the name to the type given by t (r/o)
Definition: blackbox.cc:212
@ CNUMBER_CMD
Definition: tok.h:47

◆ jjUMINUS_BI()

static BOOLEAN jjUMINUS_BI ( leftv  res,
leftv  u 
)
static

Definition at line 3722 of file iparith.cc.

3723{
3724 number n=(number)u->CopyD(BIGINT_CMD);
3726 res->data = (char *)n;
3727 return FALSE;
3728}
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:557

◆ jjUMINUS_BIM()

static BOOLEAN jjUMINUS_BIM ( leftv  res,
leftv  u 
)
static

Definition at line 3759 of file iparith.cc.

3760{
3762 (*bim)*=(-1);
3763 res->data = (char *)bim;
3764 return FALSE;
3765}

◆ jjUMINUS_I()

static BOOLEAN jjUMINUS_I ( leftv  res,
leftv  u 
)
static

Definition at line 3729 of file iparith.cc.

3730{
3731 res->data = (char *)(-(long)u->Data());
3732 return FALSE;
3733}

◆ jjUMINUS_IV()

static BOOLEAN jjUMINUS_IV ( leftv  res,
leftv  u 
)
static

Definition at line 3752 of file iparith.cc.

3753{
3754 intvec *iv=(intvec *)u->CopyD(INTVEC_CMD);
3755 (*iv)*=(-1);
3756 res->data = (char *)iv;
3757 return FALSE;
3758}

◆ jjUMINUS_MA()

static BOOLEAN jjUMINUS_MA ( leftv  res,
leftv  u 
)
static

Definition at line 3746 of file iparith.cc.

3747{
3748 poly m1=pISet(-1);
3749 res->data = (char *)mp_MultP((matrix)u->CopyD(MATRIX_CMD),m1,currRing);
3750 return FALSE;
3751}
#define pISet(i)
Definition: polys.h:312

◆ jjUMINUS_N()

static BOOLEAN jjUMINUS_N ( leftv  res,
leftv  u 
)
static

Definition at line 3734 of file iparith.cc.

3735{
3736 number n=(number)u->CopyD(NUMBER_CMD);
3737 n=nInpNeg(n);
3738 res->data = (char *)n;
3739 return FALSE;
3740}
#define nInpNeg(n)
Definition: numbers.h:21

◆ jjUMINUS_P()

static BOOLEAN jjUMINUS_P ( leftv  res,
leftv  u 
)
static

Definition at line 3741 of file iparith.cc.

3742{
3743 res->data = (char *)pNeg((poly)u->CopyD(POLY_CMD));
3744 return FALSE;
3745}

◆ jjUNIQLIST()

BOOLEAN jjUNIQLIST ( leftv  ,
leftv  arg 
)

Definition at line 10222 of file iparith.cc.

10223{
10224 lists l=(lists)arg->Data();
10225 if (l->nr>0)
10226 {
10227 qsort(l->m,l->nr+1,sizeof(sleftv),jjCOMPARE_ALL);
10228 int i, j, len;
10229 len=l->nr;
10230 i=0;
10231 while(i<len)
10232 {
10233 if(jjCOMPARE_ALL(&(l->m[i]),&(l->m[i+1]))==0)
10234 {
10235 l->m[i].CleanUp();
10236 for(j=i; j<len;j++) l->m[j]=l->m[j+1];
10237 memset(&(l->m[len]),0,sizeof(sleftv));
10238 l->m[len].rtyp=DEF_CMD;
10239 len--;
10240 }
10241 else
10242 i++;
10243 }
10244 //Print("new len:%d\n",len);
10245 }
10246 return FALSE;
10247}

◆ jjUNIVARIATE()

static BOOLEAN jjUNIVARIATE ( leftv  res,
leftv  v 
)
static

Definition at line 5378 of file iparith.cc.

5379{
5380 res->data=(char *)(long)pIsUnivariate((poly)v->Data());
5381 return FALSE;
5382}
#define pIsUnivariate(p)
Definition: polys.h:249

◆ jjVAR1()

static BOOLEAN jjVAR1 ( leftv  res,
leftv  v 
)
static

Definition at line 5383 of file iparith.cc.

5384{
5385 int i=(int)(long)v->Data();
5386 if ((0<i) && (i<=currRing->N))
5387 {
5388 poly p=pOne();
5389 pSetExp(p,i,1);
5390 pSetm(p);
5391 res->data=(char *)p;
5392 }
5393 else
5394 {
5395 Werror("var number %d out of range 1..%d",i,currRing->N);
5396 return TRUE;
5397 }
5398 return FALSE;
5399}

◆ jjVARSTR1()

static BOOLEAN jjVARSTR1 ( leftv  res,
leftv  v 
)
static

Definition at line 5400 of file iparith.cc.

5401{
5402 if (currRing==NULL)
5403 {
5404 WerrorS("no ring active (2)");
5405 return TRUE;
5406 }
5407 int i=(int)(long)v->Data();
5408 if ((0<i) && (i<=currRing->N))
5409 res->data=omStrDup(currRing->names[i-1]);
5410 else
5411 {
5412 Werror("var number %d out of range 1..%d",i,currRing->N);
5413 return TRUE;
5414 }
5415 return FALSE;
5416}

◆ jjVARSTR2()

static BOOLEAN jjVARSTR2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3588 of file iparith.cc.

3589{
3590 idhdl h=(idhdl)u->data;
3591 int i=(int)(long)v->Data();
3592 if ((0<i) && (i<=IDRING(h)->N))
3593 res->data=omStrDup(IDRING(h)->names[i-1]);
3594 else
3595 {
3596 Werror("var number %d out of range 1..%d",i,IDRING(h)->N);
3597 return TRUE;
3598 }
3599 return FALSE;
3600}

◆ jjVDIM()

static BOOLEAN jjVDIM ( leftv  res,
leftv  v 
)
static

Definition at line 5417 of file iparith.cc.

5418{
5420#ifdef HAVE_SHIFTBBA
5421 if (rIsLPRing(currRing))
5422 {
5423#ifdef HAVE_RINGS
5425 {
5426 WerrorS("`vdim` is not implemented for letterplace rings over rings");
5427 return TRUE;
5428 }
5429#endif
5430 if (currRing->qideal != NULL)
5431 {
5432 WerrorS("qring not supported by `vdim` for letterplace rings at the moment");
5433 return TRUE;
5434 }
5435 int kDim = lp_kDim((ideal)(v->Data()));
5436 res->data = (char *)(long)kDim;
5437 return (kDim == -2);
5438 }
5439#endif
5440 long l=scMult0Int((ideal)v->Data(),currRing->qideal);
5441 if (l<-1L)
5442 WerrorS("int overflow in vdim");
5443 res->data = (char *)l;
5444 return FALSE;
5445}
long scMult0Int(ideal S, ideal Q)
Definition: hdegree.cc:950
int lp_kDim(const ideal _G)
Definition: hdegree.cc:2112

◆ jjWAIT1ST1()

BOOLEAN jjWAIT1ST1 ( leftv  res,
leftv  u 
)

Definition at line 5446 of file iparith.cc.

5447{
5448// input: u: a list with links of type
5449// ssi-fork, ssi-tcp, MPtcp-fork or MPtcp-launch
5450// returns: -1: the read state of all links is eof
5451// i>0: (at least) u[i] is ready
5452 lists Lforks = (lists)u->Data();
5453 int i = slStatusSsiL(Lforks, -1);
5454 if(i == -2) /* error */
5455 {
5456 return TRUE;
5457 }
5458 res->data = (void*)(long)i;
5459 return FALSE;
5460}

◆ jjWAIT1ST2()

static BOOLEAN jjWAIT1ST2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3601 of file iparith.cc.

3602{
3603// input: u: a list with links of type
3604// ssi-fork, ssi-tcp, MPtcp-fork or MPtcp-launch
3605// v: timeout for select in milliseconds
3606// or 0 for polling
3607// returns: ERROR (via Werror): timeout negative
3608// -1: the read state of all links is eof
3609// 0: timeout (or polling): none ready
3610// i>0: (at least) L[i] is ready
3611 lists Lforks = (lists)u->Data();
3612 int t = (int)(long)v->Data();
3613 if(t < 0)
3614 {
3615 WerrorS("negative timeout"); return TRUE;
3616 }
3617 int i = slStatusSsiL(Lforks, t*1000);
3618 if(i == -2) /* error */
3619 {
3620 return TRUE;
3621 }
3622 res->data = (void*)(long)i;
3623 return FALSE;
3624}

◆ jjWAITALL1()

BOOLEAN jjWAITALL1 ( leftv  res,
leftv  u 
)

Definition at line 5461 of file iparith.cc.

5462{
5463// input: u: a list with links of type
5464// ssi-fork, ssi-tcp, MPtcp-fork or MPtcp-launch
5465// returns: -1: the read state of all links is eof
5466// 1: all links are ready
5467// (caution: at least one is ready, but some maybe dead)
5468 lists Lforks = (lists)u->CopyD();
5469 int i;
5470 int j = -1;
5471 for(int nfinished = 0; nfinished < Lforks->nr+1; nfinished++)
5472 {
5473 i = slStatusSsiL(Lforks, -1);
5474 if(i == -2) /* error */
5475 {
5476 return TRUE;
5477 }
5478 if(i == -1)
5479 {
5480 break;
5481 }
5482 j = 1;
5483 Lforks->m[i-1].CleanUp();
5484 Lforks->m[i-1].rtyp=DEF_CMD;
5485 Lforks->m[i-1].data=NULL;
5486 }
5487 res->data = (void*)(long)j;
5488 Lforks->Clean();
5489 return FALSE;
5490}

◆ jjWAITALL2()

static BOOLEAN jjWAITALL2 ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3625 of file iparith.cc.

3626{
3627// input: u: a list with links of type
3628// ssi-fork, ssi-tcp, MPtcp-fork or MPtcp-launch
3629// v: timeout for select in milliseconds
3630// or 0 for polling
3631// returns: ERROR (via Werror): timeout negative
3632// -1: the read state of all links is eof
3633// 0: timeout (or polling): none ready
3634// 1: all links are ready
3635// (caution: at least one is ready, but some maybe dead)
3636 lists Lforks = (lists)u->CopyD();
3637 int timeout = 1000*(int)(long)v->Data();
3638 if(timeout < 0)
3639 {
3640 WerrorS("negative timeout"); return TRUE;
3641 }
3642 int t = getRTimer()/TIMER_RESOLUTION; // in seconds
3643 int i;
3644 int ret = -1;
3645 for(unsigned nfinished = 0; nfinished < ((unsigned)Lforks->nr)+1; nfinished++)
3646 {
3647 i = slStatusSsiL(Lforks, timeout);
3648 if(i > 0) /* Lforks[i] is ready */
3649 {
3650 ret = 1;
3651 Lforks->m[i-1].CleanUp();
3652 Lforks->m[i-1].rtyp=DEF_CMD;
3653 Lforks->m[i-1].data=NULL;
3654 timeout = si_max(0,timeout - 1000*(getRTimer()/TIMER_RESOLUTION - t));
3655 }
3656 else /* terminate the for loop */
3657 {
3658 if(i == -2) /* error */
3659 {
3660 return TRUE;
3661 }
3662 if(i == 0) /* timeout */
3663 {
3664 ret = 0;
3665 }
3666 break;
3667 }
3668 }
3669 Lforks->Clean();
3670 res->data = (void*)(long)ret;
3671 return FALSE;
3672}
#define TIMER_RESOLUTION
Definition: mod2.h:34
int getRTimer()
Definition: timer.cc:170

◆ jjWEDGE()

static BOOLEAN jjWEDGE ( leftv  res,
leftv  u,
leftv  v 
)
static

Definition at line 3673 of file iparith.cc.

3674{
3675 res->data = (char *)mp_Wedge((matrix)u->Data(),(int)(long)v->Data(),currRing);
3676 return FALSE;
3677}
matrix mp_Wedge(matrix a, int ar, const ring R)
Definition: matpol.cc:1751

◆ jjWRONG()

static BOOLEAN jjWRONG ( leftv  ,
leftv   
)
static

Definition at line 3680 of file iparith.cc.

3681{
3682 return TRUE;
3683}

◆ pHeadProc()

poly pHeadProc ( poly  p)

Definition at line 232 of file iparith.cc.

233{
234 return pHead(p);
235}

◆ Tok2Cmdname()

const char * Tok2Cmdname ( int  tok)

Definition at line 9627 of file iparith.cc.

9628{
9629 if (tok <= 0)
9630 {
9631 return sArithBase.sCmds[0].name;
9632 }
9633 if (tok==ANY_TYPE) return "any_type";
9634 if (tok==COMMAND) return "command";
9635 if (tok==NONE) return "nothing";
9636 if (tok < 128)
9637 {
9638 Tok2Cmdname_buf[0]=(char)tok;
9639 return Tok2Cmdname_buf;
9640 }
9641 //if (tok==IFBREAK) return "if_break";
9642 //if (tok==VECTOR_FROM_POLYS) return "vector_from_polys";
9643 //if (tok==ORDER_VECTOR) return "ordering";
9644 //if (tok==REF_VAR) return "ref";
9645 //if (tok==OBJECT) return "object";
9646 //if (tok==PRINT_EXPR) return "print_expr";
9647 if (tok==IDHDL) return "identifier";
9648 if (tok>MAX_TOK) return getBlackboxName(tok);
9649 unsigned i;
9650 for(i=0; i<sArithBase.nCmdUsed; i++)
9651 //while (sArithBase.sCmds[i].tokval!=0)
9652 {
9653 if ((sArithBase.sCmds[i].tokval == tok)&&
9654 (sArithBase.sCmds[i].alias==0))
9655 {
9656 return sArithBase.sCmds[i].name;
9657 }
9658 }
9659 // try gain for alias/old names:
9660 for(i=0; i<sArithBase.nCmdUsed; i++)
9661 {
9662 if (sArithBase.sCmds[i].tokval == tok)
9663 {
9664 return sArithBase.sCmds[i].name;
9665 }
9666 }
9667 return sArithBase.sCmds[0].name;
9668}
STATIC_VAR si_char_2 Tok2Cmdname_buf
Definition: iparith.cc:9626
#define ANY_TYPE
Definition: tok.h:30

◆ WerrorS_dummy()

static void WerrorS_dummy ( const char *  )
static

Definition at line 5564 of file iparith.cc.

5565{
5567}

Variable Documentation

◆ all_farey

long all_farey =0L

Definition at line 8 of file iparith.cc.

◆ cmdtok

EXTERN_VAR int cmdtok

Definition at line 217 of file iparith.cc.

◆ expected_parms

EXTERN_VAR BOOLEAN expected_parms

Definition at line 218 of file iparith.cc.

◆ farey_cnt

long farey_cnt =0L

Definition at line 9 of file iparith.cc.

◆ iiOp

VAR int iiOp

Definition at line 222 of file iparith.cc.

◆ sArithBase

STATIC_VAR SArithBase sArithBase

Base entry for arithmetic.

Definition at line 201 of file iparith.cc.

◆ singclap_factorize_retry

EXTERN_VAR int singclap_factorize_retry

Definition at line 2048 of file iparith.cc.

◆ Tok2Cmdname_buf

STATIC_VAR si_char_2 Tok2Cmdname_buf =" "

Definition at line 9626 of file iparith.cc.

◆ WerrorS_dummy_cnt

STATIC_VAR int WerrorS_dummy_cnt =0

Definition at line 5563 of file iparith.cc.