 |
My Project
debian-1:4.1.2-p1+ds-2
|
Go to the source code of this file.
|
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 | 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 NOTE: the input number is normalized as a side effect. More...
|
|
static BOOLEAN | jjNUMERATOR (leftv res, leftv v) |
| Return the numerator of the input number NOTE: the input number is normalized as a side effect. 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 | 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 | 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 | 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 | 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 | jjSMATRIX_Mo (leftv res, leftv u, leftv v, leftv w) |
|
static BOOLEAN | jjLIFT3 (leftv res, leftv u, leftv v, leftv w) |
|
static BOOLEAN | jjLIFTSTD3 (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_4 (leftv res, leftv U) |
|
BOOLEAN | jjLIST_PL (leftv res, leftv v) |
|
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 | 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) |
|
◆ sValCmdTab
Definition at line 121 of file iparith.cc.
Data Fields |
short |
cmd |
|
short |
start |
|
◆ _scmdnames
Definition at line 58 of file gentable.cc.
Data Fields |
short |
alias |
|
const char * |
name |
|
char * |
name |
|
short |
toktype |
|
short |
tokval |
|
◆ sValCmd1
Definition at line 77 of file gentable.cc.
Data Fields |
short |
arg |
|
short |
cmd |
|
int |
p |
|
proc1 |
p |
|
short |
res |
|
short |
valid_for |
|
◆ sValCmd2
Definition at line 68 of file gentable.cc.
Data Fields |
short |
arg1 |
|
short |
arg2 |
|
short |
cmd |
|
int |
p |
|
proc2 |
p |
|
short |
res |
|
short |
valid_for |
|
◆ sValCmd3
Definition at line 85 of file gentable.cc.
Data Fields |
short |
arg1 |
|
short |
arg2 |
|
short |
arg3 |
|
short |
cmd |
|
int |
p |
|
proc3 |
p |
|
short |
res |
|
short |
valid_for |
|
◆ sValCmdM
Definition at line 95 of file gentable.cc.
Data Fields |
short |
cmd |
|
short |
number_of_args |
|
int |
p |
|
proc1 |
p |
|
short |
res |
|
short |
valid_for |
|
◆ SArithBase
Definition at line 178 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 |
◆ ALLOW_LP
◆ ALLOW_NC
◆ ALLOW_PLURAL
◆ ALLOW_RING
◆ ALLOW_ZERODIVISOR
#define ALLOW_ZERODIVISOR 0 |
◆ ALLOW_ZZ
◆ COMM_PLURAL
◆ ii_div_by_0
#define ii_div_by_0 "div. by 0" |
◆ IPARITH
◆ jjWRONG2
◆ jjWRONG3
◆ NC_MASK
◆ NO_CONVERSION
◆ NO_NC
◆ NO_RING
◆ NO_ZERODIVISOR
◆ NULL_VAL
◆ RING_MASK
◆ SIMPL_EQU
◆ SIMPL_LMDIV
◆ SIMPL_LMEQ
◆ SIMPL_MULT
◆ SIMPL_NORM
◆ SIMPL_NORMALIZE
#define SIMPL_NORMALIZE 64 |
◆ SIMPL_NULL
◆ WARN_RING
◆ ZERODIVISOR_MASK
#define ZERODIVISOR_MASK 8 |
◆ jjValCmdTab
◆ proc2
◆ proc3
◆ si_char_2
typedef char si_char_2[2] |
◆ _gentable_sort_cmds()
static int _gentable_sort_cmds |
( |
const void * |
a, |
|
|
const void * |
b |
|
) |
| |
|
static |
compares to entry of cmdsname-list
- Parameters
-
- Returns
- <ReturnValue>
Definition at line 9185 of file iparith.cc.
9187 cmdnames *pCmdL = (cmdnames*)a;
9188 cmdnames *pCmdR = (cmdnames*)
b;
9193 if(pCmdL->name==
NULL)
return 1;
9194 if(pCmdR->name==
NULL)
return -1;
9197 if(strcmp(pCmdL->name,
"$INVALID$")==0)
return -1;
9198 if(strcmp(pCmdR->name,
"$INVALID$")==0)
return 1;
9201 if (pCmdL->tokval==-1)
9203 if (pCmdR->tokval==-1)
9204 return strcmp(pCmdL->name, pCmdR->name);
9209 if(pCmdR->tokval==-1)
return -1;
9211 return strcmp(pCmdL->name, pCmdR->name);
◆ check_valid()
Definition at line 9411 of file iparith.cc.
9418 WerrorS(
"not implemented for non-commutative rings");
9428 #ifdef HAVE_SHIFTBBA
9444 WerrorS(
"not implemented for rings with rings as coeffients");
9451 WerrorS(
"domain required as coeffients");
9457 WarnS(
"considering the image in Q[...]");
◆ iiArithAddCmd()
int iiArithAddCmd |
( |
const char * |
szName, |
|
|
short |
nAlias, |
|
|
short |
nTokval, |
|
|
short |
nToktype, |
|
|
short |
nPos = -1 |
|
) |
| |
Definition at line 9352 of file iparith.cc.
9376 if(szName==
NULL)
return -1;
9380 Print(
"'%s' already exists at %d\n", szName, nIndex);
◆ iiArithFindCmd()
int iiArithFindCmd |
( |
const char * |
szName | ) |
|
◆ iiArithGetCmd()
char* iiArithGetCmd |
( |
int |
nPos | ) |
|
◆ iiArithRemoveCmd() [1/2]
int iiArithRemoveCmd |
( |
char * |
szName | ) |
|
◆ iiArithRemoveCmd() [2/2]
int iiArithRemoveCmd |
( |
const char * |
szName | ) |
|
Definition at line 9325 of file iparith.cc.
9328 if(szName==
NULL)
return -1;
9333 Print(
"'%s' not found (%d)\n", szName, nIndex);
◆ iiExprArith1()
Definition at line 8595 of file iparith.cc.
8606 memcpy(&d->arg1,a,
sizeof(
sleftv));
8610 res->data=(
char *)d;
8623 res->data=bb->blackbox_Init(bb);
8624 if(!bb->blackbox_Assign(
res,a))
return FALSE;
8634 if(!bb->blackbox_Op1(op,
res,a))
return FALSE;
◆ iiExprArith1Tab()
apply an operation 'op' to an argument a return TRUE on failure
- Parameters
-
[out] | res | pre-allocated result |
[in] | a | argument |
[in] | op | operation |
[in] | dA1 | table of possible proc assumes dArith1[0].cmd==op |
[in] | at | a->Typ() |
[in] | dConvertTypes | table of type conversions |
Definition at line 8465 of file iparith.cc.
8475 while (dA1[
i].cmd==op)
8494 if ((call_failed=dA1[
i].
p(
res,a)))
8514 while (dA1[
i].cmd==op)
8538 || (call_failed=dA1[
i].
p(
res,an)));
8579 while (dA1[
i].cmd==op)
8583 Werror(
"expected %s(`%s`)"
◆ iiExprArith2()
Definition at line 8406 of file iparith.cc.
8417 memcpy(&d->arg1,a,
sizeof(
sleftv));
8419 memcpy(&d->arg2,
b,
sizeof(
sleftv));
8423 res->data=(
char *)d;
8436 if (!bb->blackbox_Op2(op,
res,a,
b))
return FALSE;
8442 else if ((bt>
MAX_TOK)&&(op!=
'('))
8447 if(!bb->blackbox_Op2(op,
res,a,
b))
return FALSE;
◆ iiExprArith2Tab()
apply an operation 'op' to arguments a and a->next return TRUE on failure
- Parameters
-
[out] | res | pre-allocated result |
[in] | a | 2 arguments |
[in] | op | operation |
[in] | dA2 | table of possible proc assumes dA2[0].cmd==op |
[in] | at | a->Typ() |
[in] | dConvertTypes | table of type conversions |
Definition at line 8393 of file iparith.cc.
◆ iiExprArith2TabIntern()
Definition at line 8233 of file iparith.cc.
8246 while (dA2[
i].cmd==op)
8248 if ((at==dA2[
i].arg1)
8249 && (bt==dA2[
i].arg2))
8266 if ((call_failed=dA2[
i].
p(
res,a,
b)))
8286 while (dA2[
i].cmd==op)
8313 || (call_failed=dA2[
i].
p(
res,an,bn)));
8352 Werror(
"`%s` is not defined",
s);
8359 Werror(
"%s(`%s`,`%s`) failed"
8364 Werror(
"`%s` %s `%s` failed"
8369 while (dA2[
i].cmd==op)
8371 if(((at==dA2[
i].arg1)||(bt==dA2[
i].arg2))
8376 Werror(
"expected %s(`%s`,`%s`)"
8379 Werror(
"expected `%s` %s `%s`"
◆ iiExprArith3()
Definition at line 8808 of file iparith.cc.
8819 memcpy(&d->arg1,a,
sizeof(
sleftv));
8821 memcpy(&d->arg2,
b,
sizeof(
sleftv));
8823 memcpy(&d->arg3,c,
sizeof(
sleftv));
8827 res->data=(
char *)d;
8839 if(!bb->blackbox_Op3(op,
res,a,
b,c))
return FALSE;
◆ iiExprArith3Tab()
apply an operation 'op' to arguments a, a->next and a->next->next return TRUE on failure
- Parameters
-
[out] | res | pre-allocated result |
[in] | a | 3 arguments |
[in] | op | operation |
[in] | dA3 | table of possible proc assumes dA3[0].cmd==op |
[in] | at | a->Typ() |
[in] | dConvertTypes | table of type conversions |
Definition at line 8860 of file iparith.cc.
◆ iiExprArith3TabIntern()
Definition at line 8654 of file iparith.cc.
8667 while (dA3[
i].cmd==op)
8669 if ((at==dA3[
i].arg1)
8670 && (bt==dA3[
i].arg2)
8671 && (ct==dA3[
i].arg3))
8679 Print(
"call %s(%s,%s,%s)\n",
8681 if ((call_failed=dA3[
i].
p(
res,a,
b,c)))
8702 while (dA3[
i].cmd==op)
8718 Print(
"call %s(%s,%s,%s)\n",
8724 || (call_failed=dA3[
i].
p(
res,an,bn,cn)));
8773 Werror(
"`%s` is not defined",
s);
8779 Werror(
"%s(`%s`,`%s`,`%s`) failed"
8783 while (dA3[
i].cmd==op)
8785 if(((at==dA3[
i].arg1)
8787 ||(ct==dA3[
i].arg3))
8790 Werror(
"expected %s(`%s`,`%s`,`%s`)"
◆ iiExprArithM()
Definition at line 8898 of file iparith.cc.
8910 res->data=(
char *)d;
8915 memcpy(&d->arg1,a,
sizeof(
sleftv));
8950 if(!bb->blackbox_OpM(op,
res,a))
return FALSE;
8965 if ((args==
dArithM[
i].number_of_args)
8967 || ((
dArithM[
i].number_of_args==-2)&&(args>0)))
◆ iiInitArithmetic()
initialisation of arithmetic structured data
- Return values
-
Definition at line 9222 of file iparith.cc.
◆ iin_Int()
static int iin_Int |
( |
number & |
n, |
|
|
coeffs |
cf |
|
) |
| |
|
static |
◆ iiTabIndex()
Definition at line 9106 of file iparith.cc.
9116 if (op==dArithTab[
p].cmd)
return dArithTab[
p].start;
9117 if (op<dArithTab[
p].cmd) e=
p-1;
◆ iiTokType()
◆ IsCmd()
int IsCmd |
( |
const char * |
n, |
|
|
int & |
tok |
|
) |
| |
Definition at line 9007 of file iparith.cc.
9065 Warn(
"outdated identifier `%s` used - please change your code",
◆ jjALIGN_M()
◆ jjALIGN_V()
◆ jjAND_I()
◆ jjBAREISS()
Definition at line 3717 of file iparith.cc.
3728 l->m[0].data=(
void *)
m;
3729 l->m[1].data=(
void *)iv;
3730 res->data = (
char *)
l;
◆ jjBAREISS3()
Definition at line 5867 of file iparith.cc.
5872 int k=(int)(
long)
w->Data();
5879 l->m[0].data=(
void *)
m;
5880 l->m[1].data=(
void *)iv;
5887 l->m[0].data=(
void *)
m;
5889 res->data = (
char *)
l;
◆ jjBAREISS_BIM()
◆ jjBI2IM()
◆ jjBI2N()
◆ jjBI2P()
◆ jjBRACK_Bim()
Definition at line 5611 of file iparith.cc.
5614 int r = (int)(
long)
v->Data();
5615 int c = (int)(
long)
w->Data();
5616 if ((r<1)||(r>bim->
rows())||(c<1)||(c>bim->
cols()))
5618 Werror(
"wrong range[%d,%d] in bigintmat %s(%d x %d)",
5632 while (
h->next!=
NULL)
h=
h->next;
◆ jjBRACK_Im()
Definition at line 5584 of file iparith.cc.
5587 int r = (int)(
long)
v->Data();
5588 int c = (int)(
long)
w->Data();
5589 if ((r<1)||(r>iv->
rows())||(c<1)||(c>iv->
cols()))
5591 Werror(
"wrong range[%d,%d] in intmat %s(%d x %d)",
5604 while (
h->next!=
NULL)
h=
h->next;
◆ jjBRACK_Ma()
Definition at line 5639 of file iparith.cc.
5642 int r = (int)(
long)
v->Data();
5643 int c = (int)(
long)
w->Data();
5647 Werror(
"wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->
Fullname(),
5661 while (
h->next!=
NULL)
h=
h->next;
◆ jjBRACK_Ma_I_IV()
Definition at line 5697 of file iparith.cc.
5708 WerrorS(
"cannot build expression lists from unnamed objects");
5711 memcpy(&ut,u,
sizeof(ut));
5712 memset(&t,0,
sizeof(t));
5716 t.
data=(
char *)(
long)((*iv)[
l]);
5726 memcpy(u,&ut,
sizeof(ut));
◆ jjBRACK_Ma_IV_I()
Definition at line 5747 of file iparith.cc.
5758 WerrorS(
"cannot build expression lists from unnamed objects");
5761 memcpy(&ut,u,
sizeof(ut));
5762 memset(&t,0,
sizeof(t));
5766 t.
data=(
char *)(
long)((*iv)[
l]);
5776 memcpy(u,&ut,
sizeof(ut));
◆ jjBRACK_Ma_IV_IV()
Definition at line 5797 of file iparith.cc.
5809 WerrorS(
"cannot build expression lists from unnamed objects");
5812 memcpy(&ut,u,
sizeof(ut));
5813 memset(&t1,0,
sizeof(
sleftv));
5814 memset(&t2,0,
sizeof(
sleftv));
5817 for (vl=0;vl< vv->
length(); vl++)
5819 t1.
data=(
char *)(
long)((*vv)[vl]);
5820 for (wl=0;wl< wv->
length(); wl++)
5822 t2.
data=(
char *)(
long)((*wv)[wl]);
5832 memcpy(u,&ut,
sizeof(ut));
◆ jjBRACK_S()
Definition at line 5568 of file iparith.cc.
5570 char *
s= (
char *)u->
Data();
5571 int r = (int)(
long)
v->Data();
5572 int c = (int)(
long)
w->Data();
5575 if ( (r<1) || (r>
l) || (c<0) )
5581 sprintf((
char *)
res->data,
"%-*.*s",c,c,
s+r-1);
◆ jjBRACK_SM()
Definition at line 5668 of file iparith.cc.
5670 ideal
m= (ideal)u->
Data();
5671 int r = (int)(
long)
v->Data();
5672 int c = (int)(
long)
w->Data();
5674 if ((r<1)||(r>
m->rank)||(c<1)||(c>
IDELEMS(
m)))
5676 Werror(
"wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->
Fullname(),
5690 while (
h->next!=
NULL)
h=
h->next;
◆ jjBRACKET()
Definition at line 2873 of file iparith.cc.
2879 const poly q = (poly)
b->Data();
2892 const poly
p = (poly)a->
Data();
◆ jjBRACKET_REC()
Definition at line 2900 of file iparith.cc.
2906 const poly q = (poly)
b->Data();
2911 const poly
p = (poly)a->
Data();
2912 int k=(int)(
long)c->
Data();
2916 for (
int i = 0;
i <
k;
i++)
2928 if (qq ==
NULL)
break;
2934 Werror(
"invalid number of iterations");
◆ jjBREAK0()
◆ jjBREAK1()
◆ jjCALL1ARG()
◆ jjCALL1MANY()
◆ jjCALL2ARG()
◆ jjCALL3ARG()
◆ jjCHAR()
◆ jjCHINREM_BI()
Definition at line 1682 of file iparith.cc.
1687 number *
x=(number *)
omAlloc(rl*
sizeof(number));
1688 number *q=(number *)
omAlloc(rl*
sizeof(number));
1690 for(
i=rl-1;
i>=0;
i--)
1697 for(
i=rl-1;
i>=0;
i--)
1703 res->data=(
char *)n;
◆ jjCHINREM_ID()
Definition at line 9464 of file iparith.cc.
9470 WerrorS(
"not implemented for rings with rings as coeffients (except ZZ)");
9476 int return_type=c->
m[0].
Typ();
9492 for (
unsigned i=0;
i<=(unsigned)c->
nr;
i++)
9497 if (bo) {
Werror(
"chinrem failed for list entry %d",
i+1);
break;}
9507 WerrorS(
"poly/ideal/module/matrix/list expected");
9524 ideal *
x=(ideal *)
omAlloc(rl*
sizeof(ideal));
9530 for(
i=rl-1;
i>=0;
i--)
9532 if (c->
m[
i].
Typ()!=return_type)
9557 xx=(number *)
omAlloc(rl*
sizeof(number));
9558 for(
i=rl-1;
i>=0;
i--)
9570 Werror(
"bigint expected at pos %d",
i+1);
9577 number *q=(number *)
omAlloc(rl*
sizeof(number));
9580 for(
i=rl-1;
i>=0;
i--)
9587 for(
i=rl-1;
i>=0;
i--)
9599 Werror(
"bigint expected at pos %d",
i+1);
9615 res->data=(
char *)n;
9630 for(
i=rl-1;
i>=0;
i--)
9635 res->rtyp=return_type;
◆ jjCOEF()
◆ jjCOEF_Id()
◆ jjCOEF_M()
◆ jjCOEFFS2_KB()
◆ jjCOEFFS3_Id()
Definition at line 5892 of file iparith.cc.
5896 WerrorS(
"3rd argument must be a name of a matrix");
5899 ideal
i=(ideal)u->
Data();
5900 int rank=(int)
i->rank;
◆ jjCOEFFS3_KB()
Definition at line 5906 of file iparith.cc.
5909 (ideal)(
v->Data()),(poly)(
w->Data()));
◆ jjCOEFFS3_P()
Definition at line 5912 of file iparith.cc.
5916 WerrorS(
"3rd argument must be a name of a matrix");
5924 memset(&t,0,
sizeof(t));
◆ jjCOEFFS_Id()
◆ jjCOLCOL()
Definition at line 694 of file iparith.cc.
701 if(isupper(u->
name[0]))
703 const char *c=u->
name+1;
704 while((*c!=
'\0')&&(islower(*c)||(isdigit(*c))||(*c==
'_'))) c++;
709 Print(
"%s of type 'ANY'. Trying load.\n", u->
name);
725 package pa=(package)u->Data();
739 WerrorS(
"reserved name with ::");
751 WerrorS(
"<package>::<id> expected");
◆ jjCOLON()
Definition at line 321 of file iparith.cc.
323 int l=(int)(
long)
v->Data();
326 int d=(int)(
long)u->
Data();
329 for(
i=
l-1;
i>=0;
i--) { (*vv)[
i]=d; }
330 res->data=(
char *)vv;
◆ jjCOLS()
◆ jjCOLS_BIM()
◆ jjCOLS_IV()
◆ jjCOMPARE_ALL()
static int jjCOMPARE_ALL |
( |
const void * |
aa, |
|
|
const void * |
bb |
|
) |
| |
|
static |
Definition at line 9657 of file iparith.cc.
9663 if (at < bt)
return -1;
9664 if (at > bt)
return 1;
9665 int tab_pos=
iiTabIndex(dArithTab2,JJTAB2LEN,
'<');
9667 memset(&tmp,0,
sizeof(
sleftv));
9673 unsigned long ad=(
unsigned long)a->
Data();
9674 unsigned long bd=(
unsigned long)
b->Data();
9675 if (ad<bd)
return -1;
9676 else if (ad==bd)
return 0;
9687 unsigned long ad=(
unsigned long)a->
Data();
9688 unsigned long bd=(
unsigned long)
b->Data();
9689 if (ad<bd)
return -1;
9690 else if (ad==bd)
return 0;
◆ jjCOMPARE_BIM()
Definition at line 368 of file iparith.cc.
376 res->data = (
char *) (r<0);
379 res->data = (
char *) (r>0);
382 res->data = (
char *) (r<=0);
385 res->data = (
char *) (r>=0);
389 res->data = (
char *) (r==0);
393 if(r==-2) {
WerrorS(
"size incompatible");
return TRUE; }
◆ jjCOMPARE_IV()
Definition at line 340 of file iparith.cc.
348 res->data = (
char *) (r<0);
351 res->data = (
char *) (r>0);
354 res->data = (
char *) (r<=0);
357 res->data = (
char *) (r>=0);
361 res->data = (
char *) (r==0);
365 if(r==-2) {
WerrorS(
"size incompatible");
return TRUE; }
◆ jjCOMPARE_IV_I()
Definition at line 396 of file iparith.cc.
399 int b = (int)(
long)(
v->Data());
404 res->data = (
char *) (r<0);
407 res->data = (
char *) (r>0);
410 res->data = (
char *) (r<=0);
413 res->data = (
char *) (r>=0);
417 res->data = (
char *) (r==0);
◆ jjCOMPARE_MA()
Definition at line 423 of file iparith.cc.
432 res->data = (
char *) (
long)(r < 0);
435 res->data = (
char *) (
long)(r > 0);
438 res->data = (
char *) (
long)(r <= 0);
441 res->data = (
char *) (
long)(r >= 0);
445 res->data = (
char *)(
long) (r == 0);
◆ jjCOMPARE_P()
Definition at line 451 of file iparith.cc.
453 poly
p=(poly)u->
Data();
454 poly q=(poly)
v->Data();
459 res->data = (
char *) (r < 0);
462 res->data = (
char *) (r > 0);
465 res->data = (
char *) (r <= 0);
468 res->data = (
char *) (r >= 0);
◆ jjCOMPARE_S()
Definition at line 478 of file iparith.cc.
480 char* a = (
char * )(u->
Data());
481 char*
b = (
char * )(
v->Data());
◆ jjCONTENT()
◆ jjCONTRACT()
◆ jjCOUNT_BI()
◆ jjCOUNT_BIM()
◆ jjCOUNT_IV()
◆ jjCOUNT_L()
◆ jjCOUNT_M()
◆ jjCOUNT_N()
◆ jjCOUNT_RES()
◆ jjCOUNT_RG()
Definition at line 3848 of file iparith.cc.
3850 ring r=(ring)
v->Data();
3856 extern int ipower (
int b,
int n );
3857 elems=
ipower(r->cf->ch,r->cf->extRing->pFDeg(r->cf->extRing->qideal->m[0],r->cf->extRing));
3859 res->data = (
char *)(
long)elems;
◆ jjDEFINED()
Definition at line 3900 of file iparith.cc.
3907 else if (
v->rtyp!=0)
res->data=(
void *)(-1);
◆ jjDEG()
Definition at line 3862 of file iparith.cc.
3865 poly
p=(poly)
v->Data();
3867 else res->data=(
char *)-1;
◆ jjDEG_IV()
Definition at line 1848 of file iparith.cc.
1850 poly
p=(poly)u->
Data();
1856 res->data = (
char *)(d);
1859 res->data=(
char *)(
long)(-1);
◆ jjDEG_M()
Definition at line 3870 of file iparith.cc.
3872 ideal I=(ideal)u->
Data();
3878 res->data = (
char *)(
long)d;
◆ jjDEG_M_IV()
Definition at line 1837 of file iparith.cc.
1840 ideal I=(ideal)u->
Data();
1845 res->data = (
char *)((
long)d);
◆ jjDEGREE()
Definition at line 3881 of file iparith.cc.
3887 PrintS(
"// NOTE: computation of degree is being performed for\n");
3888 PrintS(
"// generic fibre, that is, over Q\n");
◆ jjDelete_ID()
Definition at line 1869 of file iparith.cc.
1871 int pos=(int)(
long)
v->Data();
1872 ideal I=(ideal)u->
Data();
◆ jjDelete_IV()
Definition at line 1862 of file iparith.cc.
1864 int pos=(int)(
long)
v->Data();
◆ jjDENOMINATOR()
Return the denominator of the input number NOTE: the input number is normalized as a side effect.
Definition at line 3913 of file iparith.cc.
3915 number n = reinterpret_cast<number>(
v->Data());
◆ jjDET()
◆ jjDET2()
◆ jjDET2_S()
◆ jjDET_BI()
◆ jjDET_I()
◆ jjDET_S()
◆ jjDIFF_COEF()
Definition at line 4404 of file iparith.cc.
4408 WerrorS(
"differentiation not defined in the coefficient ring");
4411 number n = (number) u->
Data();
4412 number
k = (number)
v->Data();
◆ jjDIFF_ID()
◆ jjDIFF_ID_ID()
◆ jjDIFF_P()
◆ jjDIM()
Definition at line 3991 of file iparith.cc.
3996 Warn(
"dim(%s) may be wrong because the mixed monomial ordering",
v->Name());
4001 ideal vid = (ideal)
v->Data();
4005 res->data = (
char *)-1L;
4027 for(
unsigned ii=0;ii<(unsigned)
IDELEMS(vv);ii++)
4036 for(
unsigned jj = 0;jj<(unsigned)
IDELEMS(vc)-1;jj++)
4038 if((vc->m[jj]!=
NULL)
4059 res->data = (
char *)d;
◆ jjDIM2()
Definition at line 1917 of file iparith.cc.
1922 Warn(
"dim(%s,...) may be wrong because the mixed monomial ordering",
v->Name());
1927 ideal vid = (ideal)
v->Data();
1931 res->data = (
char *)-1;
1940 res->data = (
char *)d;
1946 res->data = (
char *)((
long)
scDimInt((ideal)(
v->Data()),(ideal)
w->Data()));
1950 res->data = (
char *)((
long)
scDimInt((ideal)(
v->Data()),q));
◆ jjDIM_R()
◆ jjDIV_BI()
Definition at line 1257 of file iparith.cc.
1259 number q=(number)
v->Data();
1267 res->data = (
char *)q;
◆ jjDIV_Ma()
Definition at line 1292 of file iparith.cc.
1294 poly q=(poly)
v->Data();
1319 res->data=(
char *)mm;
◆ jjDIV_N()
Definition at line 1270 of file iparith.cc.
1272 number q=(number)
v->Data();
1280 res->data = (
char *)q;
◆ jjDIV_P()
Definition at line 1283 of file iparith.cc.
1285 poly q=(poly)
v->CopyD();
1286 poly
p=(poly)(u->
CopyD());
◆ jjDIVISION()
Definition at line 1955 of file iparith.cc.
1957 ideal vi=(ideal)
v->Data();
1959 ideal ui=(ideal)u->
Data();
1993 res->data=(
char *)L;
◆ jjDIVISION4()
Definition at line 6891 of file iparith.cc.
6905 WarnS(
"<module>,<module>,<int>[,<intvec>] expected!");
6912 ideal P=(ideal)w1.
Data();
6913 ideal
Q=(ideal)w2.
Data();
6915 int n=(int)(
long)v3->
Data();
6922 while( (
i > 0) && ((*w0) > 0) )
6928 WarnS(
"not all weights are positive!");
6942 L->
m[1].
rtyp=v1->Typ();
6947 L->
m[1].
data=(
void *)
R->m[0];
◆ jjDIVMOD_I()
Definition at line 1234 of file iparith.cc.
1237 int a= (int)(
long)u->
Data();
1238 int b= (int)(
long)
v->Data();
1252 r=((a-c) /
b);
break;
1254 res->data=(
void *)((
long)r);
◆ jjDOTDOT()
◆ jjDUMMY()
◆ jjDUMP()
◆ jjE()
Definition at line 4081 of file iparith.cc.
4084 int co=(int)(
long)
v->Data();
4090 else WerrorS(
"argument of gen must be positive");
◆ jjELIMIN()
◆ jjELIMIN_ALG()
◆ jjELIMIN_HILB()
◆ jjELIMIN_IV()
◆ jjENVELOPE()
◆ jjEQUAL_BI()
◆ jjEQUAL_I()
Definition at line 1328 of file iparith.cc.
1330 res->data = (
char *)((
int)((long)u->
Data()) == (
int)((long)
v->Data()));
◆ jjEQUAL_Ma()
◆ jjEQUAL_N()
◆ jjEQUAL_P()
Definition at line 1358 of file iparith.cc.
1360 poly
p=(poly)u->
Data();
1361 poly q=(poly)
v->Data();
◆ jjEQUAL_R()
◆ jjEQUAL_REST()
◆ jjEQUAL_SM()
◆ jjERROR()
◆ jjEXECUTE()
Definition at line 4093 of file iparith.cc.
4095 char * d = (
char *)
v->Data();
4096 char *
s = (
char *)
omAlloc(strlen(d) + 13);
4097 strcpy(
s, (
char *)d);
4098 strcat(
s,
"\n;RETURN();\n");
◆ jjEXPORTTO()
◆ jjEXTGCD_BI()
Definition at line 2028 of file iparith.cc.
2030 number uu=(number)u->
Data();number vv=(number)
v->Data();
2039 res->data=(
char *)L;
◆ jjEXTGCD_I()
Definition at line 2042 of file iparith.cc.
2044 int uu=(int)(
long)u->
Data();
int vv=(int)(
long)
v->Data();
2045 int p0=
ABS(uu),p1=
ABS(vv);
2046 int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
2068 res->data=(
char *)L;
◆ jjEXTGCD_P()
◆ jjFAC_P()
Definition at line 4142 of file iparith.cc.
4152 l->m[0].data=(
void *)
f;
4154 l->m[1].data=(
void *)
v;
4155 res->data=(
void *)
l;
◆ jjFAC_P2()
Definition at line 2088 of file iparith.cc.
2091 int sw=(int)(
long)dummy->
Data();
2093 if ((sw<0)||(sw>2)) fac_sw=1;
2106 l->m[0].data=(
void *)
f;
2108 l->m[1].data=(
void *)
v;
2109 res->data=(
void *)
l;
2114 res->data=(
void *)
f;
2127 res->data=(
void *)
p;
◆ jjFACSTD()
Definition at line 4102 of file iparith.cc.
4135 WarnS(
"no factorization implemented");
4139 res->data=(
void *)L;
◆ jjFACSTD2()
◆ jjFactModD_M()
Definition at line 7888 of file iparith.cc.
7914 leftv u =
v;
int factorsGiven = 0;
7917 WerrorS(
"expected arguments (poly, int [, poly, poly] [, int, int])");
7920 else h = (poly)u->
Data();
7924 WerrorS(
"expected arguments (poly, int [, poly, poly] [, int, int])");
7927 else d = (int)(
long)u->
Data();
7933 WerrorS(
"expected arguments (poly, int [, poly, poly] [, int, int])");
7938 f0 = (poly)u->
Data();
7948 WerrorS(
"expected arguments (poly, int [, poly, poly] [, int, int])");
7953 xIndex = (int)(
long)u->
Data();
7954 yIndex = (int)(
long)u->
next->
Data();
7960 WerrorS(
"expected arguments (poly, int [, poly, poly] [, int, int])");
7967 WerrorS(
"expected non-constant polynomial argument(s)");
7971 if ((xIndex < 1) || (n < xIndex))
7973 Werror(
"index for variable x (%d) out of range [1..%d]", xIndex, n);
7976 if ((yIndex < 1) || (n < yIndex))
7978 Werror(
"index for variable y (%d) out of range [1..%d]", yIndex, n);
7981 if (xIndex == yIndex)
7983 WerrorS(
"expected distinct indices for variables x and y");
7988 if (factorsGiven == 0)
8002 WerrorS(
"expected h(0,y) to have exactly two distinct monic factors");
8017 res->data = (
char*)L;
◆ jjFAREY_BI()
Definition at line 2157 of file iparith.cc.
2161 number uu=(number)u->
Data();
2162 number vv=(number)
v->Data();
◆ jjFAREY_ID()
Definition at line 2168 of file iparith.cc.
2170 ideal uu=(ideal)u->
Data();
2171 number vv=(number)
v->Data();
◆ jjFAREY_LI()
Definition at line 9638 of file iparith.cc.
9645 for (
unsigned i=0;
i<=(unsigned)c->
nr;
i++)
9650 if (bo) {
Werror(
"farey failed for list entry %d",
i+1);
break;}
◆ jjFETCH()
Definition at line 2183 of file iparith.cc.
2185 ring r=(ring)u->
Data();
2194 int par_perm_size=0;
2203 par_perm_size=
rPar(r);
2212 perm=(
int *)
omAlloc0((r->N+1)*
sizeof(int));
2213 if (par_perm_size!=0)
2214 par_perm=(
int *)
omAlloc0(par_perm_size*
sizeof(
int));
2219 char ** r_par_names=
NULL;
2220 if (r->cf->extRing!=
NULL)
2222 r_par=r->cf->extRing->N;
2223 r_par_names=r->cf->extRing->names;
2226 char ** c_par_names=
NULL;
2230 c_par_names=
currRing->cf->extRing->names;
2234 maFindPerm(r->names, r->N, r_par_names, r_par,
2236 perm,par_perm,
currRing->cf->type);
2238 #ifdef HAVE_SHIFTBBA
2243 perm,par_perm,
currRing->cf->type,r->isLPring);
2250 if (par_perm_size!=0)
2264 Print(
"// par nr %d: %s -> %s\n",
2270 memset(&tmpW,0,
sizeof(
sleftv));
2274 perm,par_perm,par_perm_size,nMap)))
2292 Werror(
"no identity map from %s (%s -> %s)",u->
Fullname(),s1,s2);
◆ jjFETCH_M()
Definition at line 7035 of file iparith.cc.
7037 ring r=(ring)u->
Data();
7045 WerrorS(
"fetch(<ring>,<name>[,<intvec>[,<intvec>])");
7050 if (perm_par_l!=
NULL)
7059 int par_perm_size=0;
7068 par_perm_size=
rPar(r);
7076 par_perm_size=
rPar(r);
7078 if (par_perm_size!=0)
7079 par_perm=(
int *)
omAlloc0(par_perm_size*
sizeof(
int));
7081 if (perm_par_l==
NULL)
7083 if (par_perm_size!=0)
7088 if (par_perm_size==0)
WarnS(
"source ring has no parameters");
7093 if (i<perm_par_v->
length()) par_perm[
i]=(*perm_par_v)[
i];
7097 Warn(
"invalid entry for par %d: %d\n",
i,par_perm[
i]);
7105 if (i<perm_var_v->
length()) perm[
i+1]=(*perm_var_v)[
i];
7109 Warn(
"invalid entry for var %d: %d\n",
i,perm[
i]);
7118 Print(
"// var nr %d: %s -> var %s\n",
i,r->names[
i-1],
currRing->names[perm[
i]-1]);
7124 if (par_perm[
i-1]<0)
7125 Print(
"// par nr %d: %s -> par %s\n",
7127 else if (par_perm[
i-1]>0)
7128 Print(
"// par nr %d: %s -> var %s\n",
7134 memset(&tmpW,0,
sizeof(
sleftv));
7138 perm,par_perm,par_perm_size,nMap)))
7156 Werror(
"no identity map from %s (%s -> %s)",u->
Fullname(),s1,s2);
◆ jjFIND2()
Definition at line 2296 of file iparith.cc.
2303 char *where=(
char *)u->
Data();
2304 char *what=(
char *)
v->Data();
2305 char *
found = strstr(where,what);
2308 res->data=(
char *)((
found-where)+1);
◆ jjFIND3()
Definition at line 5954 of file iparith.cc.
5962 int n=(int)(
long)
w->Data();
5963 char *where=(
char *)u->
Data();
5964 char *what=(
char *)
v->Data();
5966 if ((1>n)||(n>(
int)strlen(where)))
5968 Werror(
"start position %d out of range",n);
5971 found = strchr(where+n-1,*what);
5972 if (*(what+1)!=
'\0')
5974 while((
found !=
NULL) && (strncmp(
found+1,what+1,strlen(what+1))!=0))
5981 res->data=(
char *)((
found-where)+1);
◆ jjFRES()
Definition at line 2346 of file iparith.cc.
2350 w->data = (
char *)
"complete";
◆ jjFRES3()
Definition at line 2314 of file iparith.cc.
2317 ideal
id = (ideal)u->
Data();
2318 int max_length = (int)(
long)
v->Data();
2319 if (max_length < 0) {
2320 WerrorS(
"length for fres must not be negative");
2323 if (max_length == 0) {
2326 Warn(
"full resolution in a qring may be infinite, "
2327 "setting max length to %d", max_length);
2330 char *method = (
char *)
w->Data();
2334 if (strcmp(method,
"complete") != 0
2335 && strcmp(method,
"frame") != 0
2336 && strcmp(method,
"extended frame") != 0
2337 && strcmp(method,
"single module") != 0) {
2338 WerrorS(
"wrong optional argument for fres");
2342 res->data = (
void *)r;
◆ jjFWALK()
◆ jjFWALK3()
Definition at line 5985 of file iparith.cc.
5987 if ((
int)(
long)
w->Data()==0)
◆ jjGCD_BI()
Definition at line 2376 of file iparith.cc.
2378 number n1 = (number) u->
Data();
2379 number n2 = (number)
v->Data();
◆ jjGCD_I()
Definition at line 2362 of file iparith.cc.
2364 int uu=(int)(
long)u->
Data();
int vv=(int)(
long)
v->Data();
2365 int p0=
ABS(uu),p1=
ABS(vv);
2373 res->data=(
char *)(
long)p0;
◆ jjGCD_N()
Definition at line 2383 of file iparith.cc.
2385 number a=(number) u->
Data();
2386 number
b=(number)
v->Data();
◆ jjGCD_P()
◆ jjGE_BI()
◆ jjGE_I()
Definition at line 1180 of file iparith.cc.
1182 res->data = (
char *)(
long)((int)((
long)u->
Data()) >= (
int)((long)
v->Data()));
◆ jjGE_N()
◆ jjGETDUMP()
◆ jjGT_BI()
◆ jjGT_I()
Definition at line 1198 of file iparith.cc.
1200 res->data = (
char *)(
long)((int)((
long)u->
Data()) > (
int)((long)
v->Data()));
◆ jjGT_N()
◆ jjHIGHCORNER()
◆ jjHIGHCORNER_M()
Definition at line 4179 of file iparith.cc.
4184 ideal I=(ideal)
v->Data();
4198 WerrorS(
"module must be zero-dimensional");
4199 if (delete_w)
delete w;
4222 if (delete_w)
delete w;
4223 res->data=(
void *)po;
◆ jjHILBERT()
Definition at line 4226 of file iparith.cc.
4231 PrintS(
"// NOTE: computation of Hilbert series etc. is being\n");
4232 PrintS(
"// performed for generic fibre, that is, over Q\n");
◆ jjHILBERT2()
Definition at line 2406 of file iparith.cc.
2411 PrintS(
"// NOTE: computation of Hilbert series etc. is being\n");
2412 PrintS(
"// performed for generic fibre, that is, over Q\n");
2420 switch((
int)(long)
v->Data())
2423 res->data=(
void *)iv;
◆ jjHILBERT3()
Definition at line 5994 of file iparith.cc.
5999 Werror(
"weight vector must have size %d, not %d",
6006 PrintS(
"// NOTE: computation of Hilbert series etc. is being\n");
6007 PrintS(
"// performed for generic fibre, that is, over Q\n");
6015 switch((
int)(long)
v->Data())
6018 res->data=(
void *)iv;
◆ jjHILBERT_IV()
Definition at line 4241 of file iparith.cc.
4246 PrintS(
"// NOTE: computation of Hilbert series etc. is being\n");
4247 PrintS(
"// performed for generic fibre, that is, over Q\n");
◆ jjHOMOG1()
Definition at line 4253 of file iparith.cc.
4256 ideal v_id=(ideal)
v->Data();
4264 char *s_isHomog=
omStrDup(
"isHomog");
4270 else if (
w!=
NULL)
delete w;
◆ jjHOMOG1_W()
Definition at line 2473 of file iparith.cc.
2477 ideal v_id=(ideal)
v->Data();
2486 currRing->pLexOrder=save_pLexOrder;
◆ jjHOMOG_ID()
◆ jjHOMOG_ID_W()
◆ jjHOMOG_P()
◆ jjHOMOG_P_W()
◆ jjIDEAL_Ma()
◆ jjIDEAL_Map()
◆ jjIDEAL_PL()
◆ jjIDEAL_R()
Definition at line 4330 of file iparith.cc.
4334 ring q=(ring)
v->Data();
4337 if (q->qideal==
NULL)
4344 WerrorS(
"can only get ideal from identical qring");
◆ jjidElem()
◆ jjidFreeModule()
◆ jjidHead()
◆ jjidMaxIdeal()
Definition at line 4286 of file iparith.cc.
4288 #ifdef HAVE_SHIFTBBA
4291 int deg = (int)(
long)
v->Data();
4293 WerrorS(
"degree bound of Letterplace ring is to small");
◆ jjidMinBase()
◆ jjidTransp()
◆ jjidVec2Ideal()
◆ jjIm2Iv()
◆ jjIMPART()
◆ jjINDEPSET()
◆ jjINDEPSET2()
◆ jjINDEX_I()
◆ jjINDEX_IV()
Definition at line 1411 of file iparith.cc.
1415 WerrorS(
"indexed object must have a name");
1422 memset(&t,0,
sizeof(t));
1426 t.
data=(
char *)((
long)(*iv)[
i]);
◆ jjINDEX_P()
Definition at line 1447 of file iparith.cc.
1449 poly
p=(poly)u->
Data();
1450 int i=(int)(
long)
v->Data();
◆ jjINDEX_P_IV()
◆ jjINDEX_PBu()
◆ jjINDEX_V()
Definition at line 1516 of file iparith.cc.
1518 poly
p=(poly)u->
Data();
1519 int i=(int)(
long)
v->Data();
◆ jjINDEX_V_IV()
◆ jjINTERPOLATION()
Definition at line 2506 of file iparith.cc.
2509 const int n = L->
nr;
assume (n >= 0);
2510 std::vector<ideal> V(n + 1);
2512 for(
int i = n;
i >= 0;
i--) V[
i] = (ideal)(L->
m[
i].
Data());
◆ jjINTERRED()
Definition at line 4365 of file iparith.cc.
4370 WarnS(
"interred: this command is experimental over the integers");
◆ jjINTERSEC3S()
◆ jjINTERSECT()
◆ jjINTERSECT3()
Definition at line 6079 of file iparith.cc.
6081 ideal I1=(ideal)u->
Data();
6082 ideal I2=(ideal)
v->Data();
6083 ideal I3=(ideal)
w->Data();
◆ jjINTERSECT_PL()
Definition at line 7160 of file iparith.cc.
7163 int l=
v->listLength();
7194 WerrorS(
"cannot convert to ideal or module");
7205 r[
i]=(ideal)
h->Data();
7217 r[
i]=(ideal)tmp.
Data();
◆ jjINTMAT3()
Definition at line 6065 of file iparith.cc.
6067 intvec* im=
new intvec((
int)(
long)
v->Data(),(int)(
long)
w->Data(), 0);
6073 (*im)[
i] = (*arg)[
i];
6076 res->data = (
char *)im;
◆ jjINTVEC_PL()
Definition at line 7396 of file iparith.cc.
7407 (*iv)[
i]=(int)(
long)
h->Data();
7426 res->data=(
char *)iv;
◆ jjIS_RINGVAR0()
◆ jjIS_RINGVAR_P()
◆ jjIS_RINGVAR_S()
◆ jjJACOB_M()
Definition at line 4423 of file iparith.cc.
4425 ideal
id = (ideal)a->
Data();
4435 for(
int i = 0;
i < W;
i++,
p++, q++ )
◆ jjJACOB_P()
Definition at line 4392 of file iparith.cc.
4396 poly
p=(poly)(
v->Data());
4401 res->data = (
char *)
i;
◆ jjJanetBasis()
◆ jjJanetBasis2()
◆ jjJET4()
Definition at line 7429 of file iparith.cc.
7443 WerrorS(
"2nd argument must be a unit");
7456 WerrorS(
"2nd argument must be a diagonal matrix of units");
7461 (
int)(long)u3->
Data(),
7470 Werror(
"%s(`poly`,`poly`,`int`,`intvec`) exppected",
◆ jjJET_ID()
◆ jjJET_ID_IV()
◆ jjJET_ID_M()
Definition at line 6123 of file iparith.cc.
6127 WerrorS(
"2nd argument must be a diagonal matrix of units");
◆ jjJET_P()
◆ jjJET_P_IV()
◆ jjJET_P_P()
◆ jjKBASE()
◆ jjKBASE2()
◆ jjKERNEL()
◆ jjKLAMMER()
Definition at line 1559 of file iparith.cc.
1562 char * nn = (
char *)
omAlloc(strlen(u->
name) + 14);
1563 sprintf(nn,
"%s(%d)",u->
name,(
int)(
long)
v->Data());
◆ jjKLAMMER_IV()
Definition at line 1572 of file iparith.cc.
1577 long slen = strlen(u->
name) + 14;
1578 char *n = (
char*)
omAlloc(slen);
1591 sprintf(n,
"%s(%d)",u->
name,(*iv)[
i]);
◆ jjKLAMMER_PL()
Definition at line 7512 of file iparith.cc.
7515 && ((strcmp(u->
Name(),
"real")==0) || (strcmp(u->
Name(),
"complex")==0)))
7518 memset(u,0,
sizeof(
sleftv));
7536 Werror(
"`int` expected while building `%s(`",u->
name);
7541 sprintf(nn,
"%s(%d",u->
name,(
int)(
long)
v->Data());
7545 while (*
s!=
'\0')
s++;
7549 Werror(
"`int` expected while building `%s`",nn);
7553 sprintf(
s,
",%d",(
int)(
long)
v->Data());
7555 while (*
s!=
'\0')
s++;
◆ jjKLAMMER_rest()
◆ jjKoszul()
◆ jjKoszul_Id()
◆ jjL2R()
◆ jjLE_BI()
◆ jjLE_I()
Definition at line 1212 of file iparith.cc.
1214 res->data = (
char *)(
long)((int)((
long)u->
Data()) <= (
int)((long)
v->Data()));
◆ jjLE_N()
◆ jjLEADCOEF()
◆ jjLEADEXP()
Definition at line 4472 of file iparith.cc.
4474 poly
p=(poly)
v->Data();
4487 res->data=(
char *)iv;
◆ jjLEADMONOM()
Definition at line 4490 of file iparith.cc.
4492 poly
p=(poly)
v->Data();
4501 res->data = (
char*) lm;
◆ jjLIFT()
◆ jjLIFT3()
◆ jjLIFT_4()
Definition at line 7564 of file iparith.cc.
7576 ideal I=(ideal)u->
Data();
7589 Werror(
"%s(`ideal`,`ideal`,`matrix`,`string`)\n"
7590 "or (`module`,`module`,`matrix`,`string`)expected",
◆ jjLIFTSTD()
◆ jjLIFTSTD3()
◆ jjLIFTSTD_4()
Definition at line 7595 of file iparith.cc.
7608 ideal I=(ideal)u->
Data();
7615 &(hw->data.uideal),alg);
7621 Werror(
"%s(`ideal`,`ideal`,`matrix`,`string`)\n"
7622 "or (`module`,`module`,`matrix`,`string`)expected",
◆ jjLIST_PL()
Definition at line 7627 of file iparith.cc.
7630 if (
v!=
NULL) sl =
v->listLength();
7634 int add_row_shift = 0;
7636 if (weights!=
NULL) add_row_shift=weights->
min_in();
7663 Werror(
"`%s` is undefined",
h->Fullname());
7669 ((ring)L->
m[
i].
data)->ref++;
7675 res->data=(
char *)L;
◆ jjLISTRING()
Definition at line 4509 of file iparith.cc.
4513 if (mm==0) mm=0x7fff;
4514 int isLetterplace=(int)(
long)
atGet(
v,
"isLetterplaceRing",
INT_CMD);
4516 res->data=(
char *)r;
◆ jjLOAD()
load lib/module given in v
Definition at line 5362 of file iparith.cc.
5367 #ifdef HAVE_DYNAMIC_LOADING
5374 Werror(
"%s: unknown type",
s);
5392 Werror(
"can not create package `%s`",plib);
5398 package pa=IDPACKAGE(pl);
5402 Werror(
"can not create package `%s` - binaries exists",plib);
5408 package savepack=currPack;
5424 #ifdef HAVE_DYNAMIC_LOADING
5427 WerrorS(
"Dynamic modules are not supported by this version of Singular");
◆ jjLOAD1()
◆ jjLOAD2()
◆ jjLOAD_E()
Definition at line 2592 of file iparith.cc.
2594 char *
s=(
char *)u->
Data();
2595 if(strcmp(
s,
"with")==0)
2597 if (strcmp(
s,
"try")==0)
2599 WerrorS(
"invalid second argument");
2600 WerrorS(
"load(\"libname\" [,option]);");
◆ jjLOAD_TRY()
◆ jjLT_BI()
◆ jjLT_I()
Definition at line 1225 of file iparith.cc.
1227 res->data = (
char *)(
long)((int)((
long)u->
Data()) < (
int)((long)
v->Data()));
◆ jjLT_N()
◆ jjLU_DECOMP()
◆ jjLU_INVERSE()
Definition at line 7234 of file iparith.cc.
7249 matrix iMat;
int invertible;
7255 int rr = aMat->
rows();
7256 int cc = aMat->
cols();
7259 Werror(
"given matrix (%d x %d) is not quadratic, hence not invertible", rr, cc);
7264 WerrorS(
"matrix must be constant");
7274 int rr = uMat->
rows();
7275 int cc = uMat->
cols();
7278 Werror(
"third matrix (%d x %d) is not quadratic, hence not invertible",
7287 WerrorS(
"matricesx must be constant");
7294 Werror(
"expected either one or three matrices");
7312 res->data=(
char*)ll;
◆ jjLU_SOLVE()
Definition at line 7315 of file iparith.cc.
7336 WerrorS(
"expected exactly three matrices and one vector as input");
7346 Werror(
"first matrix (%d x %d) is not quadratic",
7352 Werror(
"second matrix (%d x %d) is not quadratic",
7358 Werror(
"second matrix (%d x %d) and third matrix (%d x %d) do not fit",
7364 Werror(
"third matrix (%d x %d) and vector (%d x 1) do not fit",
7373 WerrorS(
"matrices must be constant");
7393 res->data=(
char*)ll;
◆ jjMakeSub()
static Subexpr jjMakeSub |
( |
leftv |
e | ) |
|
|
static |
◆ jjMAP()
◆ jjMATRIX_Id()
Definition at line 6593 of file iparith.cc.
6595 int mi=(int)(
long)
v->Data();
6596 int ni=(int)(
long)
w->Data();
6599 Werror(
"converting ideal to matrix: dimensions must be positive(%dx%d)",mi,ni);
6610 memcpy(
m->m,I->m,
i*
sizeof(poly));
6611 memset(I->m,0,
i*
sizeof(poly));
6613 res->data = (
char *)
m;
◆ jjMATRIX_Ma()
Definition at line 6629 of file iparith.cc.
6631 int mi=(int)(
long)
v->Data();
6632 int ni=(int)(
long)
w->Data();
6635 Werror(
"converting matrix to matrix: dimensions must be positive(%dx%d)",mi,ni);
6652 res->data = (
char *)
m;
◆ jjMATRIX_Mo()
Definition at line 6616 of file iparith.cc.
6618 int mi=(int)(
long)
v->Data();
6619 int ni=(int)(
long)
w->Data();
6622 Werror(
"converting module to matrix: dimensions must be positive(%dx%d)",mi,ni);
◆ jjMEMORY()
Definition at line 4558 of file iparith.cc.
4565 switch(((
int)(
long)
v->Data()))
4580 res->data = (
char *)0;
4584 res->data = (
char *)0;
◆ jjMINOR_M()
Definition at line 6134 of file iparith.cc.
6174 Werror(
"`%s` is undefined",
v->Fullname());
6190 const int mk = (
const int)(
long)u->
Data();
6191 bool noIdeal =
true;
bool noK =
true;
bool noAlgorithm =
true;
6192 bool noCacheMinors =
true;
bool noCacheMonomials =
true;
6193 ideal IasSB;
int k;
char* algorithm;
int cacheMinors;
int cacheMonomials;
6209 noAlgorithm =
false;
6214 noCacheMinors =
false;
6220 noCacheMonomials =
false;
6234 noAlgorithm =
false;
6239 noCacheMinors =
false;
6244 noCacheMonomials =
false;
6251 algorithm = (
char*)u->
next->
Data();
6252 noAlgorithm =
false;
6256 noCacheMinors =
false;
6261 noCacheMonomials =
false;
6269 if (strcmp(algorithm,
"bareiss") == 0)
6270 algorithm = (
char*)
"Bareiss";
6271 if (strcmp(algorithm,
"laplace") == 0)
6272 algorithm = (
char*)
"Laplace";
6273 if (strcmp(algorithm,
"cache") == 0)
6274 algorithm = (
char*)
"Cache";
6283 if ((!noK) && (
k == 0))
6285 WerrorS(
"Provided number of minors to be computed is zero.");
6288 if ((!noAlgorithm) && (strcmp(algorithm,
"Bareiss") != 0)
6289 && (strcmp(algorithm,
"Laplace") != 0)
6290 && (strcmp(algorithm,
"Cache") != 0))
6292 WerrorS(
"Expected as algorithm one of 'B/bareiss', 'L/laplace', or 'C/cache'.");
6295 if ((!noAlgorithm) && (strcmp(algorithm,
"Bareiss") == 0)
6298 Werror(
"Bareiss algorithm not defined over coefficient rings %s",
6299 "with zero divisors.");
6303 if ((mk < 1) || (mk >
m->rows()) || (mk >
m->cols()))
6312 if ((!noAlgorithm) && (strcmp(algorithm,
"Cache") == 0)
6313 && (noCacheMinors || noCacheMonomials))
6316 cacheMonomials = 100000;
6322 (noIdeal ? 0 : IasSB),
false);
6323 else if (strcmp(algorithm,
"Cache") == 0)
6325 (noIdeal ? 0 : IasSB), 3, cacheMinors,
6326 cacheMonomials,
false);
6329 (noIdeal ? 0 : IasSB),
false);
◆ jjMINRES_R()
◆ jjMINUS_B()
◆ jjMINUS_B_P()
◆ jjMINUS_BI()
◆ jjMINUS_BIM()
◆ jjMINUS_I()
Definition at line 879 of file iparith.cc.
881 void *
ap=u->
Data();
void *bp=
v->Data();
882 int aa=(int)(
long)
ap;
883 int bb=(int)(
long)bp;
885 unsigned int a=(
unsigned int)(
unsigned long)
ap;
886 unsigned int b=(
unsigned int)(
unsigned long)bp;
890 WarnS(
"int overflow(-), result may be wrong");
892 res->data = (
char *)((
long)cc);
◆ jjMINUS_IV()
◆ jjMINUS_MA()
Definition at line 953 of file iparith.cc.
959 Werror(
"matrix size not compatible(%dx%d, %dx%d)",
◆ jjMINUS_N()
◆ jjMINUS_SM()
Definition at line 966 of file iparith.cc.
968 ideal
A=(ideal)u->
Data(); ideal
B=(ideal)
v->Data();
972 Werror(
"matrix size not compatible(%dx%d, %dx%d)",
◆ jjMINUS_V()
◆ jjMOD_BI()
Definition at line 2652 of file iparith.cc.
2654 number q=(number)
v->Data();
◆ jjMOD_N()
Definition at line 2663 of file iparith.cc.
2665 number q=(number)
v->Data();
◆ jjMOD_P()
Definition at line 2674 of file iparith.cc.
2676 poly q=(poly)
v->Data();
2682 poly
p=(poly)(u->
Data());
◆ jjMODULO()
Definition at line 2603 of file iparith.cc.
2622 ideal u_id=(ideal)u->
Data();
2623 ideal v_id=(ideal)
v->Data();
2626 if ((*w_u).compare((w_v))!=0)
2628 WarnS(
"incompatible weights");
2629 delete w_u; w_u=
NULL;
2637 WarnS(
"wrong weights");
2638 delete w_u; w_u=
NULL;
2643 res->data = (
char *)
idModulo(u_id,v_id ,hom,&w_u);
◆ jjMONITOR1()
◆ jjMONITOR2()
Definition at line 2697 of file iparith.cc.
2700 char *opt=(
char *)
v->Data();
2712 if(strcmp(
l->m->type,
"ASCII")!=0)
2714 Werror(
"ASCII link required, not `%s`",
l->m->type);
2719 if (
l->name[0]!=
'\0')
2723 if (
v==
NULL) opt=(
const char*)
"i";
2724 else opt=(
const char *)
v->Data();
◆ jjMONOM()
◆ jjmpTrace()
◆ jjmpTransp()
◆ jjMSTD()
Definition at line 4591 of file iparith.cc.
4599 l->m[0].data=(
char *)r;
4602 l->m[1].data=(
char *)
m;
4603 res->data=(
char *)
l;
◆ jjMULT()
◆ jjN2BI()
Definition at line 4626 of file iparith.cc.
4628 number n,
i;
i=(number)
v->Data();
4633 res->data=(
void *)n;
◆ jjNAMEOF()
◆ jjNAMES()
◆ jjNAMES0()
◆ jjNAMES_I()
◆ jjNEWSTRUCT2()
Definition at line 2762 of file iparith.cc.
2766 const char *
s=(
const char *)u->
Data();
2767 newstruct_desc d=
NULL;
2773 else WerrorS(
"name of newstruct must be longer than 1 character");
◆ jjNEWSTRUCT3()
◆ jjnInt()
◆ jjnlInt()
◆ jjNOT()
Definition at line 4661 of file iparith.cc.
4663 res->data=(
char*)(
long)((long)
v->Data()==0 ? 1 : 0);
◆ jjNULL()
◆ jjNUMERATOR()
Return the numerator of the input number NOTE: the input number is normalized as a side effect.
Definition at line 3922 of file iparith.cc.
3924 number n = reinterpret_cast<number>(
v->Data());
◆ jjNVARS()
Definition at line 4666 of file iparith.cc.
4668 res->data = (
char *)(
long)(((ring)(
v->Data()))->N);
◆ jjOP_BI_BIM()
◆ jjOP_BIM_BI()
Definition at line 264 of file iparith.cc.
267 number bb = (number)(
v->Data());
274 res->data=(
char *)cc;
◆ jjOP_BIM_I()
Definition at line 245 of file iparith.cc.
248 int bb = (int)(
long)(
v->Data());
253 case '+': cc=
bimAdd(aa,bb);
break;
254 case '-': cc=
bimSub(aa,bb);
break;
255 case '*': cc=
bimMult(aa,bb);
break;
257 res->data=(
char *)cc;
◆ jjOP_I_BIM()
◆ jjOP_I_IM()
◆ jjOP_I_IV()
◆ jjOP_IM_I()
Definition at line 302 of file iparith.cc.
305 int bb = (int)(
long)(
v->Data());
314 res->data=(
char *)aa;
◆ jjOP_IV_I()
Definition at line 281 of file iparith.cc.
284 int bb = (int)(
long)(
v->Data());
288 case '+': (*aa) += bb;
break;
289 case '-': (*aa) -= bb;
break;
290 case '*': (*aa) *= bb;
break;
293 case '%': (*aa) %= bb;
break;
295 res->data=(
char *)aa;
◆ jjOP_REST()
◆ jjOpenClose()
◆ jjOPPOSE()
Definition at line 2941 of file iparith.cc.
2944 ring r = (ring)a->
Data();
2947 res->data =
b->Data();
2948 res->rtyp =
b->rtyp;
2953 Werror(
"%s is not an opposite ring to current ring",a->
Fullname());
2966 res->rtyp = argtype;
2974 res->rtyp = argtype;
2982 res->rtyp = argtype;
2995 res->rtyp = argtype;
3000 WerrorS(
"unsupported type in oppose");
◆ jjOPPOSITE()
Definition at line 5125 of file iparith.cc.
5127 ring r = (ring)a->
Data();
5135 WarnS(
"opposite only for global orderings");
◆ jjOPTION_PL()
◆ jjOR_I()
◆ jjORD()
◆ jjP2BI()
Definition at line 4723 of file iparith.cc.
4725 poly
p=(poly)
v->Data();
4729 WerrorS(
"poly must be constant");
4738 res->data=(
void *)n;
◆ jjP2I()
◆ jjP2N()
◆ jjPAR1()
Definition at line 4683 of file iparith.cc.
4685 int i=(int)(
long)
v->Data();
4688 if ((0<
i) && (
i<=
p))
4694 Werror(
"par number %d out of range 1..%d",
i,
p);
◆ jjPARDEG()
Definition at line 4699 of file iparith.cc.
4701 number nn=(number)
v->Data();
◆ jjPARSTR1()
Definition at line 4705 of file iparith.cc.
4712 int i=(int)(
long)
v->Data();
4718 Werror(
"par number %d out of range 1..%d",
i,
p);
◆ jjPARSTR2()
Definition at line 2776 of file iparith.cc.
2779 int i=(
int)(long)
v->Data();
2787 Werror(
"par number %d out of range 1..%d",
i,
p);
◆ jjPFAC1()
Definition at line 4519 of file iparith.cc.
4524 memset(&tmp, 0,
sizeof(tmp));
◆ jjPFAC2()
Definition at line 3198 of file iparith.cc.
3205 n1 = (number)u->
CopyD();
3209 i = (int)(
long)u->
Data();
3217 i = (int)(
long)
v->Data();
3221 res->data = (
char*)
l;
◆ jjpHead()
◆ jjpLength()
◆ jjPlural_mat_mat()
◆ jjPlural_mat_poly()
◆ jjPlural_num_mat()
◆ jjPlural_num_poly()
◆ jjPLUS_B()
◆ jjPLUS_B_P()
◆ jjPLUS_BI()
◆ jjPLUS_BIM()
◆ jjPLUS_I()
Definition at line 756 of file iparith.cc.
758 unsigned int a=(
unsigned int)(
unsigned long)u->
Data();
759 unsigned int b=(
unsigned int)(
unsigned long)
v->Data();
761 res->data = (
char *)((
long)c);
764 WarnS(
"int overflow(+), result may be wrong");
◆ jjPLUS_ID()
◆ jjPLUS_IV()
◆ jjPLUS_MA()
Definition at line 825 of file iparith.cc.
831 Werror(
"matrix size not compatible(%dx%d, %dx%d)",
◆ jjPLUS_MA_P()
◆ jjPLUS_N()
◆ jjPLUS_P_MA()
◆ jjPLUS_S()
Definition at line 864 of file iparith.cc.
866 char* a = (
char * )(u->
Data());
867 char*
b = (
char * )(
v->Data());
868 char* r = (
char * )
omAlloc(strlen(a) + strlen(
b) + 1);
◆ jjPLUS_SM()
Definition at line 837 of file iparith.cc.
839 ideal
A=(ideal)u->
Data(); ideal
B=(ideal)
v->Data();
843 Werror(
"matrix size not compatible(%dx%d, %dx%d)",
◆ jjPLUS_V()
◆ jjPLUSMINUS_Gen()
◆ jjPLUSPLUS()
◆ jjpMaxComp()
◆ jjPOWER_BI()
Definition at line 567 of file iparith.cc.
569 int e=(int)(
long)
v->Data();
570 number n=(number)u->
Data();
577 WerrorS(
"exponent must be non-negative");
◆ jjPOWER_I()
Definition at line 521 of file iparith.cc.
523 int b=(int)(
long)u->
Data();
524 int e=(int)(
long)
v->Data();
533 else if ((e==0)||(
b==1))
551 if(rc/
b!=oldrc) overflow=
TRUE;
555 WarnS(
"int overflow(^), result may be wrong");
557 res->data = (
char *)((
long)rc);
563 WerrorS(
"exponent must be non-negative");
◆ jjPOWER_ID()
◆ jjPOWER_N()
Definition at line 583 of file iparith.cc.
585 int e=(int)(
long)
v->Data();
586 number n=(number)u->
Data();
◆ jjPOWER_P()
Definition at line 601 of file iparith.cc.
603 int v_i=(int)(
long)
v->Data();
606 WerrorS(
"exponent must be non-negative");
617 Werror(
"OVERFLOW in power(d=%ld, e=%d, max=%ld)",
◆ jjPREIMAGE()
Definition at line 6343 of file iparith.cc.
6353 WerrorS(
"2nd/3rd arguments must have names");
6357 const char *ring_name=u->
Name();
6364 if ((preim_ring==
NULL)
6367 Werror(
"preimage ring `%s` is not the basering",mapping->preimage);
6383 Werror(
"`%s` is not defined in `%s`",
v->
name,ring_name);
6387 if (kernel_cmd) image=
idInit(1,1);
6404 Werror(
"`%s` is not defined in `%s`",
w->name,ring_name);
6411 WarnS(
"preimage in local qring may be wrong: use Ring::preimageLoc instead");
◆ jjPREIMAGE_R()
◆ jjPRIME()
◆ jjPROC()
◆ jjPROC1()
◆ jjPROC3()
◆ jjPRUNE()
Definition at line 4767 of file iparith.cc.
4770 ideal v_id=(ideal)
v->Data();
4775 WarnS(
"wrong weights");
◆ jjQRDS()
Definition at line 8078 of file iparith.cc.
8085 WerrorS(
"expected (matrix, number, number, number) as arguments");
8090 (number)(
v->Data()),
8091 (number)(
w->Data()),
8092 (number)(
x->Data()));
◆ jjQUOT()
◆ jjRANDOM()
Definition at line 3022 of file iparith.cc.
3024 int i=(int)(
long)u->
Data();
3025 int j=(int)(
long)
v->Data();
3026 if (
j-
i <0) {
WerrorS(
"invalid range for random");
return TRUE;}
◆ jjRANDOM_Im()
Definition at line 6417 of file iparith.cc.
6420 int i=(int)(
long)u->
Data();
6421 int r=(int)(
long)
v->Data();
6422 int c=(int)(
long)
w->Data();
6423 if ((r<=0) || (c<=0))
return TRUE;
6439 res->data = (
char *)iv;
◆ jjRANK1()
◆ jjRANK2()
Definition at line 3030 of file iparith.cc.
3033 int isRowEchelon = (int)(
long)
v->Data();
3034 if (isRowEchelon != 1) isRowEchelon = 0;
3035 int rank =
luRank(
m, isRowEchelon);
3036 res->data =(
char *)(
long)rank;
◆ jjrCharStr()
◆ jjREAD()
◆ jjREAD2()
◆ jjREDUCE3_CID()
◆ jjREDUCE3_CP()
◆ jjREDUCE3_ID()
◆ jjREDUCE3_P()
◆ jjREDUCE4()
Definition at line 7693 of file iparith.cc.
7724 WerrorS(
"2nd argument must be a diagonal matrix of units");
7732 (
int)(long)u4->
Data()
7742 else u1p=(poly)u1->
Data();
7745 else u2p=(poly)u2->
Data();
7749 WerrorS(
"2nd argument must be a unit");
◆ jjREDUCE5()
Definition at line 7765 of file iparith.cc.
7778 WerrorS(
"2nd argument must be a diagonal matrix of units");
7786 (
int)(long)u4->
Data(),
7798 WerrorS(
"2nd argument must be a unit");
7809 Werror(
"%s(`ideal`,`ideal`,`matrix`,`int`,`intvec`) exppected",
◆ jjREDUCE_ID()
Definition at line 3063 of file iparith.cc.
3065 ideal ui=(ideal)u->
Data();
3066 ideal vi=(ideal)
v->Data();
◆ jjREDUCE_P()
Definition at line 3055 of file iparith.cc.
3057 ideal vi=(ideal)
v->Data();
◆ jjREGULARITY()
◆ jjREPART()
◆ jjRES()
Definition at line 3072 of file iparith.cc.
3074 int maxl=(int)(
long)
v->Data();
3077 WerrorS(
"length for res must not be negative");
3083 ideal u_id=(ideal)u->
Data();
3092 "full resolution in a qring may be infinite, setting max length to %d",
3106 int add_row_shift=0;
3110 add_row_shift = ww->
min_in();
3111 (*ww) -= add_row_shift;
3127 (
"`lres` not implemented for inhomogeneous input or qring");
3131 WarnS(
"the current implementation of `lres` may not work in the case of a single variable");
3141 (
"`kres` not implemented for inhomogeneous input or qring");
3153 (
"`hres` not implemented for inhomogeneous input or qring");
3156 ideal u_id_copy=
idCopy(u_id);
3158 r=
syHilb(u_id_copy,&dummy);
3171 res->data=(
void *)r;
3172 if ((weights!=
NULL) && (ww!=
NULL)) {
delete ww; ww=
NULL; }
3176 if (weights!=
NULL) (*ww) += add_row_shift;
◆ jjRES3()
Definition at line 6732 of file iparith.cc.
6734 int maxl=(int)
v->Data();
6735 ideal u_id=(ideal)u->
Data();
6751 WarnS(
"wrong weights");
◆ jjRESERVED0()
◆ jjRESERVEDNAME()
Definition at line 4807 of file iparith.cc.
4809 char *
s= (
char *)
v->Data();
4816 res->data = (
char *)1;
4825 res->data = (
char *)1;
◆ jjRESTART()
Definition at line 8207 of file iparith.cc.
8209 int c=(int)(
long)u->
Data();
8213 PrintS(
"delete all variables\n");
8218 default:
WerrorS(
"not implemented");
◆ jjRIGHTSTD()
Definition at line 5168 of file iparith.cc.
5173 WarnS(
"groebner base computations with inexact coefficients can not be trusted due to rounding errors");
5175 ideal v_id=(ideal)
v->Data();
5201 ideal I=(ideal)
v->Data();
5216 res->data = (
char *)J;
◆ jjRING3()
◆ jjRING_1()
◆ jjRING_2()
◆ jjRING_LIST()
◆ jjRING_PL()
Definition at line 8178 of file iparith.cc.
8183 WerrorS(
"expected `cring` [ `id` ... ]");
8189 char **n=(
char**)
omAlloc0(
N*
sizeof(
char*));
8190 for(
int i=0;
i<
N;
i++,names=names->
next)
8192 n[
i]=(
char *)names->Name();
◆ jjRINGLIST()
Definition at line 4850 of file iparith.cc.
4852 ring r=(ring)
v->Data();
4858 long mm=r->bitmask/2;
◆ jjRINGLIST_C()
◆ jjRMINUS()
◆ jjrOrdStr()
◆ jjROWS()
Definition at line 4880 of file iparith.cc.
4882 ideal
i = (ideal)
v->Data();
4883 res->data = (
char *)
i->rank;
◆ jjROWS_BIM()
◆ jjROWS_IV()
◆ jjRPAR()
◆ jjrParStr()
◆ jjRPLUS()
◆ jjRSUM()
◆ jjrVarStr()
◆ jjSBA()
Definition at line 4943 of file iparith.cc.
4946 ideal v_id=(ideal)
v->Data();
4953 WarnS(
"wrong weights");
◆ jjSBA_1()
Definition at line 4969 of file iparith.cc.
4972 ideal v_id=(ideal)
v->Data();
4979 WarnS(
"wrong weights");
◆ jjSBA_2()
Definition at line 4995 of file iparith.cc.
4998 ideal v_id=(ideal)
v->Data();
5005 WarnS(
"wrong weights");
◆ jjSetRing()
Definition at line 3692 of file iparith.cc.
3697 ring r=(ring)u->
Data();
3701 char name_buffer[100];
3704 sprintf(name_buffer,
"PYTHON_RING_VAR%d",ending);
◆ jjSIMPL_ID()
Definition at line 3257 of file iparith.cc.
3259 int sw = (int)(
long)
v->Data();
3290 res->data = (
char * )
id;
◆ jjSIMPL_P()
Definition at line 3352 of file iparith.cc.
3354 int sw = (int)(
long)
v->Data();
3365 res->data = (
char * )
p;
◆ jjSLIM_GB()
Definition at line 4901 of file iparith.cc.
4907 WerrorS(
"qring not supported by slimgb at the moment");
4912 WerrorS(
"ordering must be global for slimgb");
4916 WarnS(
"groebner base computations with inexact coefficients can not be trusted due to rounding errors");
4919 ideal u_id=(ideal)u->
Data();
4924 WarnS(
"wrong weights");
◆ jjSMATRIX_Mo()
Definition at line 6655 of file iparith.cc.
6657 int mi=(int)(
long)
v->Data();
6658 int ni=(int)(
long)
w->Data();
6661 Werror(
"converting to smatrix: dimensions must be positive(%dx%d)",mi,ni);
◆ jjSort_Id()
◆ jjSORTLIST()
◆ jjSQR_FREE()
Definition at line 5054 of file iparith.cc.
5064 l->m[0].data=(
void *)
f;
5066 l->m[1].data=(
void *)
v;
5067 res->data=(
void *)
l;
◆ jjSQR_FREE2()
Definition at line 3294 of file iparith.cc.
3297 int sw=(int)(
long)dummy->
Data();
3312 l->m[0].data=(
void *)
f;
3314 l->m[1].data=(
void *)
v;
3315 res->data=(
void *)
l;
3320 res->data=(
void *)
f;
3333 res->data=(
void *)
p;
◆ jjSTATUS2()
◆ jjSTATUS2L()
◆ jjSTATUS3()
Definition at line 6775 of file iparith.cc.
6779 yes = (strcmp((
char *)
res->data, (
char *)
w->Data()) == 0);
6781 res->data = (
void *)(
long)yes;
◆ jjSTATUS_M()
Definition at line 8020 of file iparith.cc.
8028 #if defined(HAVE_USLEEP)
8029 if (((
long)
res->data) == 0L)
8038 #elif defined(HAVE_SLEEP)
8039 if (((
int)
res->data) == 0)
8044 si_sleep((is - 1)/1000000 + 1);
◆ jjSTD()
Definition at line 5021 of file iparith.cc.
5024 WarnS(
"groebner base computations with inexact coefficients can not be trusted due to rounding errors");
5026 ideal v_id=(ideal)
v->Data();
5033 WarnS(
"wrong weights");
◆ jjSTD_1()
Definition at line 3394 of file iparith.cc.
3398 ideal i1=(ideal)(u->
Data());
3404 poly
p=(poly)
v->Data();
3408 memset(i0->m,0,
sizeof(poly)*
IDELEMS(i0));
3441 i0=(ideal)
v->CopyD();
3443 memset(i0->m,0,
sizeof(poly)*
IDELEMS(i0));
◆ jjSTD_HILB()
◆ jjSTD_HILB_W()
◆ jjSTD_HILB_WP()
Definition at line 8095 of file iparith.cc.
8102 ideal i1=(ideal)(u->
Data());
8108 WerrorS(
"expected `std(`ideal/module`,`poly/vector`,`intvec`,`intvec`)");
8123 i0->m[0]=(poly)
v->Data();
8128 i0=(ideal)
v->Data();
8132 WerrorS(
"expected `std(`ideal/module`,`poly/vector`,`intvec`,`intvec`)");
8139 memset(i0->m,0,
sizeof(poly)*
IDELEMS(i0));
8149 WarnS(
"wrong weights");
◆ jjSTRING_PL()
Definition at line 7835 of file iparith.cc.
7842 int n =
v->listLength();
7845 res->data =
v->String();
7849 char** slist = (
char**)
omAlloc(n*
sizeof(
char*));
7854 slist[
i] =
v->String();
7856 j+=strlen(slist[
i]);
7858 char*
s = (
char*)
omAlloc((
j+1)*
sizeof(char));
7862 strcat(
s, slist[
i]);
◆ jjstrlen()
Definition at line 5454 of file iparith.cc.
5456 res->data = (
char *)strlen((
char *)
v->Data());
◆ jjSUBST_Bu()
◆ jjSUBST_Id()
Definition at line 6531 of file iparith.cc.
6536 if (nok)
return TRUE;
6537 ideal
id=(ideal)u->
Data();
6541 if (monomexpr!=
NULL)
6556 Warn(
"possible OVERFLOW in subst, max exponent is %ld",
currRing->bitmask/2);
◆ jjSUBST_Id_I()
◆ jjSUBST_Id_N()
◆ jjSUBST_Id_X()
Definition at line 6583 of file iparith.cc.
6586 memset(&tmp,0,
sizeof(tmp));
◆ jjSUBST_M()
Definition at line 8051 of file iparith.cc.
8063 if ((rest!=
NULL) && (!
b))
8068 memset(&tmp_res,0,
sizeof(tmp_res));
8070 memcpy(
res,&tmp_res,
sizeof(tmp_res));
◆ jjSUBST_P()
◆ jjSUBST_Test()
Definition at line 6464 of file iparith.cc.
6467 monomexpr=(poly)
w->Data();
6468 poly
p=(poly)
v->Data();
6472 Werror(
"`%s` substitutes a ringvar only by a term",
6477 if ((ringvar=
pVar(
p))==0)
6486 WerrorS(
"ringvar/par expected");
◆ jjSYZ_2()
◆ jjSYZYGY()
◆ jjTENSOR()
Definition at line 3489 of file iparith.cc.
3491 ideal
A=(ideal)u->
Data();
3492 ideal
B=(ideal)
v->Data();
◆ jjTENSOR_Ma()
◆ jjTEST()
◆ jjTIMES_BI()
◆ jjTIMES_BIM()
◆ jjTIMES_I()
Definition at line 979 of file iparith.cc.
981 int a=(int)(
long)u->
Data();
982 int b=(int)(
long)
v->Data();
984 if ((c>INT_MAX)||(c<INT_MIN))
985 WarnS(
"int overflow(*), result may be wrong");
986 res->data = (
char *)((
long)((int)c));
◆ jjTIMES_ID()
◆ jjTIMES_IV()
◆ jjTIMES_MA()
Definition at line 1143 of file iparith.cc.
1149 Werror(
"matrix size not compatible(%dx%d, %dx%d) in *",
◆ jjTIMES_MA_BI1()
◆ jjTIMES_MA_BI2()
◆ jjTIMES_MA_I1()
◆ jjTIMES_MA_I2()
◆ jjTIMES_MA_N1()
◆ jjTIMES_MA_N2()
◆ jjTIMES_MA_P1()
◆ jjTIMES_MA_P2()
◆ jjTIMES_N()
Definition at line 998 of file iparith.cc.
1000 res->data = (
char *)(
nMult( (number)u->
Data(), (number)
v->Data()));
1001 number n=(number)
res->data;
1003 res->data=(
char *)n;
◆ jjTIMES_P()
Definition at line 1008 of file iparith.cc.
1021 Warn(
"possible OVERFLOW in mult(d=%ld, d=%ld, max=%ld)",
1033 Warn(
"possible OVERFLOW in mult(d=%ld, d=%ld, max=%ld)",
◆ jjTIMES_SM()
Definition at line 1158 of file iparith.cc.
1160 ideal
A=(ideal)u->
Data(); ideal
B=(ideal)
v->Data();
1164 Werror(
"matrix size not compatible(%dx%d, %dx%d) in *",
◆ jjTRACE_IV()
◆ jjTRANSP_BIM()
◆ jjTRANSP_IV()
◆ jjTWOSTD()
◆ jjTYPEOF()
◆ jjUMINUS_BI()
◆ jjUMINUS_BIM()
◆ jjUMINUS_I()
◆ jjUMINUS_IV()
◆ jjUMINUS_MA()
◆ jjUMINUS_N()
◆ jjUMINUS_P()
◆ jjUNIQLIST()
◆ jjUNIVARIATE()
◆ jjVAR1()
Definition at line 5276 of file iparith.cc.
5278 int i=(int)(
long)
v->Data();
5279 if ((0<
i) && (i<=currRing->
N))
5284 res->data=(
char *)
p;
◆ jjVARSTR1()
Definition at line 5293 of file iparith.cc.
5300 int i=(int)(
long)
v->Data();
5301 if ((0<
i) && (i<=currRing->
N))
◆ jjVARSTR2()
◆ jjVDIM()
◆ jjWAIT1ST1()
◆ jjWAIT1ST2()
Definition at line 3528 of file iparith.cc.
3539 int t = (int)(
long)
v->Data();
3549 res->data = (
void*)(
long)
i;
◆ jjWAITALL1()
Definition at line 5331 of file iparith.cc.
5341 for(
int nfinished = 0; nfinished < Lforks->
nr+1; nfinished++)
5357 res->data = (
void*)(
long)
j;
◆ jjWAITALL2()
Definition at line 3552 of file iparith.cc.
3564 int timeout = 1000*(int)(
long)
v->Data();
3572 for(
unsigned nfinished = 0; nfinished < ((unsigned)Lforks->
nr)+1; nfinished++)
3597 res->data = (
void*)(
long)ret;
◆ jjWEDGE()
◆ jjWRONG()
◆ pHeadProc()
◆ Tok2Cmdname()
const char* Tok2Cmdname |
( |
int |
tok | ) |
|
Definition at line 9131 of file iparith.cc.
9137 if (tok==
ANY_TYPE)
return "any_type";
9138 if (tok==
COMMAND)
return "command";
9139 if (tok==
NONE)
return "nothing";
9151 if (tok==
IDHDL)
return "identifier";
◆ WerrorS_dummy()
static void WerrorS_dummy |
( |
const char * |
| ) |
|
|
static |
◆ cmdtok
◆ expected_parms
◆ iiOp
◆ sArithBase
Base entry for arithmetic.
Definition at line 195 of file iparith.cc.
◆ singclap_factorize_retry
◆ Tok2Cmdname_buf
◆ WerrorS_dummy_cnt
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.
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,...
ideal id_FreeModule(int i, const ring r)
the free module of rank i
BOOLEAN iiConvert(int inputType, int outputType, int index, leftv input, leftv output, const struct sConvertTypes *dConvertTypes)
static int si_min(const int a, const int b)
poly singclap_gcd(poly f, poly g, const ring r)
polynomial gcd via singclap_gcd_r resp. idSyzygies destroys f and g
static BOOLEAN jjKLAMMER_rest(leftv res, leftv u, leftv v)
poly p_Divide(poly p, poly q, const ring r)
polynomial division a/b, ignoring the rest via singclap_pdivide resp. idLift destroyes a,...
poly redNF(poly h, int &max_ind, int nonorm, kStrategy strat)
ideal id_Homogen(ideal h, int varnum, const ring r)
ideal_list kStdfac(ideal F, ideal Q, tHomog h, intvec **w, ideal D)
static BOOLEAN jjOP_BIM_I(leftv res, leftv u, leftv v)
ideal idLift(ideal mod, ideal submod, ideal *rest, BOOLEAN goodShape, BOOLEAN isSB, BOOLEAN divide, matrix *unit, GbVariant alg)
EXTERN_VAR omBin char_ptr_bin
int idElem(const ideal F)
count non-zero elements
void scDegree(ideal S, intvec *modulweight, ideal Q)
long p_DegW(poly p, const short *w, const ring R)
int iiArithFindCmd(const char *szName)
ideal twostd(ideal I)
Compute two-sided GB:
#define pIsConstant(p)
like above, except that Comp must be 0
BOOLEAN jjStdJanetBasis(leftv res, leftv v, int flag)
flag: 0: JB, 1: SB
STATIC_VAR int WerrorS_dummy_cnt
BOOLEAN slGetDump(si_link l)
#define pGetComp(p)
Component.
static FORCE_INLINE int n_ParDeg(number n, const coeffs r)
matrix idDiffOp(ideal I, ideal J, BOOLEAN multiply)
void pNorm(poly p, const ring R=currRing)
FILE * feFopen(const char *path, const char *mode, char *where, short useWerror, short path_only)
static BOOLEAN rIsLPRing(const ring r)
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
ideal rightgb(ideal F, ideal Q)
void p_Normalize(poly p, const ring r)
int iiRegularity(lists L)
void newstruct_setup(const char *n, newstruct_desc d)
poly pSubstPar(poly p, int par, poly image)
ideal id_Matrix2Module(matrix mat, const ring R)
converts mat to module, destroys mat
#define idDelete(H)
delete an ideal
static void pLmFree(poly p)
frees the space of the monomial m, assumes m != NULL coef is not freed, m is not advanced
#define SI_LINK_SET_CLOSE_P(l)
#define nPower(a, b, res)
long(* pLDegProc)(poly p, int *length, ring r)
matrix mp_CoeffProc(poly f, poly vars, const ring R)
ideal idSect(ideal h1, ideal h2, GbVariant alg)
#define MATELEM(mat, i, j)
1-based access to matrix
static BOOLEAN jjTIMES_MA_N1(leftv res, leftv u, leftv v)
static BOOLEAN rField_is_Domain(const ring r)
const char * lastreserved
void rChangeCurrRing(ring r)
#define TEST_OPT_DEGBOUND
poly nc_p_Bracket_qq(poly p, const poly q, const ring r)
returns [p,q], destroys p
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...
static BOOLEAN jjBRACK_Ma(leftv res, leftv u, leftv v, leftv w)
void sBucketDestroyAdd(sBucket_pt bucket, poly *p, int *length)
matrix mp_Coeffs(ideal I, int var, const ring R)
corresponds to Maple's coeffs: var has to be the number of a variable
static BOOLEAN jjSUBST_Test(leftv v, leftv w, int &ringvar, poly &monomexpr)
ideal idMultSect(resolvente arg, int length, GbVariant alg)
ideal kMin_std(ideal F, ideal Q, tHomog h, intvec **w, ideal &M, intvec *hilb, int syzComp, int reduced)
void id_Norm(ideal id, const ring r)
ideal id = (id[i]), result is leadcoeff(id[i]) = 1
BOOLEAN iiMake_proc(idhdl pn, package pack, leftv sl)
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
static BOOLEAN idHomIdeal(ideal id, ideal Q=NULL)
ideal id_ChineseRemainder(ideal *xx, number *q, int rl, const ring r)
#define pGetExp(p, i)
Exponent.
ideal idAdd(ideal h1, ideal h2)
h1 + h2
poly mp_Trace(matrix a, const ring R)
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
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)
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,...
long(* pFDegProc)(poly p, ring r)
static FORCE_INLINE char * nCoeffString(const coeffs cf)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
syStrategy syResolution(ideal arg, int maxlength, intvec *w, BOOLEAN minim)
static BOOLEAN jjCOEFFS_Id(leftv res, leftv u, leftv v)
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
ideal scKBase(int deg, ideal s, ideal Q, intvec *mv)
static poly p_Neg(poly p, const ring r)
static BOOLEAN jjSTATUS2(leftv res, leftv u, leftv v)
BOOLEAN rIsLikeOpposite(ring rBase, ring rCandidate)
checks whether rings rBase and rCandidate could be opposite to each other returns TRUE if it is so
ideal singclap_factorize(poly f, intvec **v, int with_exps, const ring r)
ideal sm_CallSolv(ideal I, const ring R)
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)
matrix mp_InitP(int r, int c, poly p, const ring R)
make it a p * unit matrix
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...
poly p_Homogen(poly p, int varnum, const ring r)
const struct sValCmd2 dArith2[]
BOOLEAN iiExprArithM(leftv res, leftv a, int op)
BOOLEAN idInsertPoly(ideal h1, poly h2)
insert h2 into h1 (if h2 is not the zero polynomial) return TRUE iff h2 was indeed inserted
short * iv2array(intvec *iv, const ring R)
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...
static BOOLEAN length(leftv result, leftv arg)
poly singclap_pdivide(poly f, poly g, const ring r)
ideal idModulo(ideal h2, ideal h1, tHomog hom, intvec **w)
lists ipNameListLev(idhdl root, int lev)
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.
ideal idQuot(ideal h1, ideal h2, BOOLEAN h1IsStb, BOOLEAN resultIsIdeal)
ring rPlusVar(const ring r, char *v, int left)
K[x],"y" -> K[x,y] resp. K[y,x].
ideal walkProc(leftv first, leftv second)
BOOLEAN mpKoszul(leftv res, leftv c, leftv b, leftv id)
leftv slRead(si_link l, leftv a)
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
intvec * ivSub(intvec *a, intvec *b)
void idLiftW(ideal P, ideal Q, int n, matrix &T, ideal &R, short *w)
ideal idMinBase(ideal h1)
const char * slStatus(si_link l, const char *request)
int scMultInt(ideal S, ideal Q)
number ntDiff(number a, number d, const coeffs cf)
const CanonicalForm CFMap CFMap & N
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
void id_Shift(ideal M, int s, const ring r)
BOOLEAN idTestHomModule(ideal m, ideal Q, intvec *w)
static BOOLEAN jjSUBST_Id(leftv res, leftv u, leftv v, leftv w)
static BOOLEAN rField_is_Zp_a(const ring r)
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
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....
BOOLEAN sdb_set_breakpoint(const char *pp, int given_lineno)
void printBlackboxTypes()
list all defined type (for debugging)
Class used for (list of) interpreter objects.
BOOLEAN slOpen(si_link l, short flag, leftv h)
static BOOLEAN jjOP_REST(leftv res, leftv u, leftv v)
static FORCE_INLINE void n_Normalize(number &n, const coeffs r)
inplace-normalization of n; produces some canonical representation of n;
int rSum(ring r1, ring r2, ring &sum)
intvec * ivTranp(intvec *o)
int scDimInt(ideal S, ideal Q)
poly pOppose(ring Rop_src, poly p, const ring Rop_dst)
opposes a vector p from Rop to currRing (dst!)
BOOLEAN maApplyFetch(int what, map theMap, leftv res, leftv w, ring preimage_r, int *perm, int *par_perm, int P, nMapFunc nMap)
SModulFunc_t iiGetBuiltinModInit(const char *libname)
const char * iiTwoOps(int t)
static long pTotaldegree(poly p)
BOOLEAN pb(leftv res, leftv args)
matrix idCoeffOfKBase(ideal arg, ideal kbase, poly how)
ideal sm_Sub(ideal a, ideal b, const ring R)
bigintmat * bimMult(bigintmat *a, bigintmat *b)
bigintmat * bimSub(bigintmat *a, bigintmat *b)
STATIC_VAR SArithBase sArithBase
Base entry for arithmetic.
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static unsigned pLength(poly a)
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)
ideal maGetPreimage(ring theImageRing, map theMap, ideal id, const ring dst_r)
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
EXTERN_VAR BOOLEAN expected_parms
#define omRealloc(addr, size)
int r_IsRingVar(const char *n, char **names, int N)
static BOOLEAN jjFRES3(leftv res, leftv u, leftv v, leftv w)
VAR void(* WerrorS_callback)(const char *s)
EXTERN_VAR omBin sleftv_bin
void sm_CallBareiss(ideal I, int x, int y, ideal &M, intvec **iv, const ring R)
resolvente syResolvente(ideal arg, int maxlength, int *length, intvec ***weights, BOOLEAN minim)
static BOOLEAN check_valid(const int p, const int op)
const struct sValCmdM dArithM[]
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
static short rVar(const ring r)
#define rVar(r) (r->N)
static long p_MinComp(poly p, ring lmRing, ring tailRing)
static BOOLEAN jjGT_N(leftv res, leftv u, leftv v)
intvec * ivCopy(const intvec *o)
BOOLEAN rHasLocalOrMixedOrdering(const ring r)
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
BOOLEAN rDecompose_CF(leftv res, const coeffs C)
matrix mp_Wedge(matrix a, int ar, const ring R)
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
number(* nMapFunc)(number a, const coeffs src, const coeffs dst)
maps "a", which lives in src, into dst
void show(int mat=0, int spaces=0) const
static BOOLEAN idIsZeroDim(ideal i)
BOOLEAN iiLoadLIB(FILE *fp, const char *libnamebuf, const char *newlib, idhdl pl, BOOLEAN autoexport, BOOLEAN tellerror)
int syDim(syStrategy syzstr)
poly sBucketPeek(sBucket_pt b)
int compare(const bigintmat *op) const
void monitor(void *F, int mode)
syStrategy syConvList(lists li)
VAR omBin sip_command_bin
void PrintS(const char *s)
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.
#define omFreeSize(addr, size)
int compare(const intvec *o) const
void sBucket_Add_p(sBucket_pt bucket, poly p, int length)
adds poly p to bucket destroys p!
static BOOLEAN jjKLAMMER(leftv res, leftv u, leftv v)
syStrategy syHilb(ideal arg, int *length)
BOOLEAN iiGetLibStatus(const char *lib)
ideal t_rep_gb(const ring r, ideal arg_I, int syz_comp, BOOLEAN F4_mode)
static BOOLEAN jjTIMES_MA_BI1(leftv res, leftv u, leftv v)
const struct sConvertTypes dConvertTypes[]
void syMake(leftv v, const char *id, package pa)
poly p_Vec2Poly(poly v, int k, const ring r)
const struct sValCmd3 dArith3[]
static FORCE_INLINE number n_RePart(number i, const coeffs cf)
BOOLEAN iiExport(leftv v, int toLev)
EXTERN_VAR int singclap_factorize_retry
matrix mp_Transp(matrix a, const ring R)
poly mp_Det(matrix a, const ring r, DetVariant d)
BOOLEAN slPrepClose(si_link l)
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
BOOLEAN sm_Equal(ideal a, ideal b, const ring R)
static BOOLEAN rField_is_Ring(const ring r)
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,...
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
char * iiConvName(const char *libname)
matrix id_Module2Matrix(ideal mod, const ring R)
matrix mp_MultI(matrix a, int f, const ring R)
c = f*a
sBucket_pt sBucketCreate(const ring r)
BOOLEAN load_modules(const char *newlib, char *fullname, BOOLEAN autoexport)
newstruct_desc newstructChildFromString(const char *parent, const char *s)
ideal idMinEmbedding(ideal arg, BOOLEAN inPlace, intvec **w)
void iiMakeResolv(resolvente r, int length, int rlen, char *name, int typ0, intvec **weights)
bigintmat * bimAdd(bigintmat *a, bigintmat *b)
Matrix-Add/-Sub/-Mult so oder mit operator+/-/* ? @Note: NULL as a result means an error (non-compati...
void sBucketCanonicalize(sBucket_pt bucket)
static int iin_Int(number &n, coeffs cf)
static BOOLEAN jjOP_BIM_BI(leftv res, leftv u, leftv v)
lists rDecompose(const ring r)
ideal idSeries(int n, ideal M, matrix U, intvec *w)
lists ipNameList(idhdl root)
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
int singclap_det_i(intvec *m, const ring)
#define pInit()
allocates a new monomial and initializes everything to 0
void atSet(idhdl root, char *name, void *data, int typ)
ideal idSubstPar(ideal id, int n, poly e)
ideal id_Jet(const ideal i, int d, const ring R)
int(* SModulFunc_t)(SModulFunctions *)
BOOLEAN setOption(leftv res, leftv v)
int blackboxIsCmd(const char *n, int &tok)
used by scanner: returns ROOT_DECL for known types (and the type number in tok)
#define omPrintBinStats(F)
BOOLEAN jjLOAD(const char *s, BOOLEAN autoexport)
load lib/module given in v
unsigned nLastIdentifier
valid indentifieres are slot 1..nLastIdentifier
poly p_Cleardenom(poly p, const ring r)
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
ideal interpolation(const std::vector< ideal > &L, intvec *v)
static void jjEQUAL_REST(leftv res, leftv u, leftv v)
matrix pMultMp(poly p, matrix a, const ring R)
static int rPar(const ring r)
(r->cf->P)
ideal idElimination(ideal h1, poly delVar, intvec *hilb, GbVariant alg)
int p_Compare(const poly a, const poly b, const ring R)
syStrategy syLaScala3(ideal arg, int *length)
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
ideal sm_Tensor(ideal A, ideal B, const ring r)
syStrategy sySchreyer(ideal arg, int maxlength)
static BOOLEAN jjSTD(leftv res, leftv v)
static BOOLEAN jjBRACK_Im(leftv res, leftv u, leftv v, leftv w)
lists scIndIndset(ideal S, BOOLEAN all, ideal Q)
static BOOLEAN jjBI2N(leftv res, leftv u)
static void WerrorS_dummy(const char *)
lib_types type_of_LIB(const char *newlib, char *libnamebuf)
int iiTestConvert(int inputType, int outputType)
ring rCompose(const lists L, const BOOLEAN check_comp, const long bitmask, const int isLetterplace)
syStrategy syKosz(ideal arg, int *length)
BOOLEAN iiExprArith3(leftv res, int op, leftv a, leftv b, leftv c)
int ipower(int b, int m)
int ipower ( int b, int m )
ring rMinusVar(const ring r, char *v)
undo rPlusVar
static BOOLEAN jjGT_BI(leftv res, leftv u, leftv v)
static FORCE_INLINE BOOLEAN nCoeff_is_Extension(const coeffs r)
void CleanUp(ring r=currRing)
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)
intvec * bim2iv(bigintmat *b)
poly p_Series(int n, poly p, poly u, intvec *w, const ring R)
ideal id_Power(ideal given, int exp, const ring r)
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
static FORCE_INLINE BOOLEAN nCoeff_is_transExt(const coeffs r)
TRUE iff r represents a transcendental extension field.
#define TEST_OPT_RETURN_SB
int n_IsParam(const number m, const ring r)
TODO: rewrite somehow...
matrix mpNew(int r, int c)
create a r x c zero-matrix
void p_Shift(poly *p, int i, const ring r)
shifts components of the vector p by i
#define pLmInit(p)
like pInit, except that expvector is initialized to that of p, p must be != NULL
ideal fractalWalkProc(leftv first, leftv second)
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...
const char * Tok2Cmdname(int tok)
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,...
static FORCE_INLINE number n_Farey(number a, number b, const coeffs r)
int exprlist_length(leftv v)
intvec * ivMult(intvec *a, intvec *b)
intvec * hSecondSeries(intvec *hseries1)
ideal id_ResizeModule(ideal mod, int rows, int cols, const ring R)
intvec * scIndIntvec(ideal S, ideal Q)
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
INST_VAR sleftv iiRETURNEXPR
#define pIsUnit(p)
return true if the Lm is a constant <>0
static BOOLEAN jjGE_BI(leftv res, leftv u, leftv v)
cmdnames * sCmds
array of existing commands
BOOLEAN jjPROC(leftv res, leftv u, leftv v)
static BOOLEAN jjPLUS_MA_P(leftv res, leftv u, leftv v)
void rDelete(ring r)
unconditionally deletes fields in r
poly pSubstPoly(poly p, int var, poly image)
static Subexpr jjMakeSub(leftv e)
static BOOLEAN jjSUBST_Id_X(leftv res, leftv u, leftv v, leftv w, int input_type)
matrix mp_Mult(matrix a, matrix b, const ring R)
idhdl rFindHdl(ring r, idhdl n)
static BOOLEAN jjREAD2(leftv res, leftv u, leftv v)
#define IMATELEM(M, I, J)
void hLookSeries(ideal S, intvec *modulweight, ideal Q, intvec *wdegree, ring tailRing)
static void p_Delete(poly *p, const ring r)
number singclap_det_bi(bigintmat *m, const coeffs cf)
static int iiTabIndex(const jjValCmdTab dArithTab, const int len, const int op)
intvec * hFirstSeries(ideal S, intvec *modulweight, ideal Q, intvec *wdegree, ring tailRing)
static BOOLEAN rField_is_numeric(const ring r)
poly sm_Det(ideal a, const ring r, DetVariant d)
static FORCE_INLINE number n_ImPart(number i, const coeffs cf)
static BOOLEAN rField_is_GF(const ring r)
BOOLEAN singclap_extgcd(poly f, poly g, poly &res, poly &pa, poly &pb, const ring r)
static BOOLEAN jjMONITOR2(leftv res, leftv u, leftv v)
ring rInit(leftv pn, leftv rv, leftv ord)
ideal id_Delete_Pos(const ideal I, const int p, const ring r)
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,...
matrix mp_CoeffProcId(ideal I, poly vars, const ring R)
BOOLEAN iiExprArith2(leftv res, leftv a, int op, leftv b, BOOLEAN proccall)
ideal idLiftStd(ideal h1, matrix *ma, tHomog hi, ideal *syz, GbVariant alg)
matrix mp_MultP(matrix a, poly p, const ring R)
multiply a matrix 'a' by a poly 'p', destroy the args
static int si_max(const int a, const int b)
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.
static BOOLEAN jjPREIMAGE(leftv res, leftv u, leftv v, leftv w)
leftv iiMap(map theMap, const char *what)
void pSetDegProcs(ring r, pFDegProc new_FDeg, pLDegProc new_lDeg)
BOOLEAN iiTryLoadLib(leftv v, const char *id)
static BOOLEAN jjCALL2ARG(leftv res, leftv u)
#define SI_RESTORE_OPT2(A)
poly singclap_pmod(poly f, poly g, const ring r)
ideal id_JetW(const ideal i, int d, intvec *iv, const ring R)
ideal id_Vec2Ideal(poly vec, const ring R)
static BOOLEAN jjSTATUS3(leftv res, leftv u, leftv v, leftv w)
STATIC_VAR si_char_2 Tok2Cmdname_buf
int sySize(syStrategy syzstr)
static BOOLEAN jjPLUSMINUS_Gen(leftv res, leftv u, leftv v)
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
BOOLEAN mp_IsDiagUnit(matrix U, const ring R)
void Werror(const char *fmt,...)
BOOLEAN slClose(si_link l)
syStrategy syFrank(const ideal arg, const int length, const char *method, const bool use_cache=true, const bool use_tensor_trick=false)
ideal idInit(int idsize, int rank)
initialise an ideal / module
static BOOLEAN idHomModule(ideal m, ideal Q, intvec **w)
VAR BOOLEAN yyInRingConstruction
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),...
BOOLEAN assumeStdFlag(leftv h)
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,...
void WerrorS(const char *s)
#define pEqualPolys(p1, p2)
unsigned nCmdAllocated
number of commands-slots allocated
matrix mp_Add(matrix a, matrix b, const ring R)
BOOLEAN slDump(si_link l)
char * rCharStr(const ring r)
TODO: make it a virtual method of coeffs, together with: Decompose & Compose, rParameter & rPar.
poly iiHighCorner(ideal I, int ak)
void mp_Monomials(matrix c, int r, int var, matrix m, const ring R)
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
static FORCE_INLINE number n_ChineseRemainderSym(number *a, number *b, int rl, BOOLEAN sym, CFArray &inv_cache, const coeffs r)
BOOLEAN mp_Equal(matrix a, matrix b, const ring R)
DetVariant mp_GetAlgorithmDet(matrix m, const ring r)
newstruct_desc newstructFromString(const char *s)
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
ideal kSba(ideal F, ideal Q, tHomog h, intvec **w, int sbaOrder, int arri, intvec *hilb, int syzComp, int newIdeal, intvec *vw)
static FORCE_INLINE char * nCoeffName(const coeffs cf)
VAR char my_yylinebuf[80]
ideal idSyzygies(ideal h1, tHomog h, intvec **w, BOOLEAN setSyzComp, BOOLEAN setRegularity, int *deg, GbVariant alg)
const struct sValCmd1 dArith1[]
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)
static BOOLEAN jjGE_N(leftv res, leftv u, leftv v)
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 BOOLEAN jjTENSOR(leftv res, leftv u, leftv v)
static FORCE_INLINE number n_SubringGcd(number a, number b, const coeffs r)
ideal id_Farey(ideal x, number N, const ring r)
const char feNotImplemented[]
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 ....
static BOOLEAN jjBRACK_Bim(leftv res, leftv u, leftv v, leftv w)
ideal idOppose(ring Rop_src, ideal I, const ring Rop_dst)
opposes a module I from Rop to currRing(dst)
static ideal idMult(ideal h1, ideal h2)
hh := h1 * h2
static FORCE_INLINE void n_Power(number a, int b, number *res, const coeffs r)
fill res with the power a^b
BOOLEAN pa(leftv res, leftv args)
int luRank(const matrix aMat, const bool isRowEchelon, const ring R)
Computes the rank of a given (m x n)-matrix.
GbVariant syGetAlgorithm(char *n, const ring r, const ideal)
const Variable & v
< [in] a sqrfree bivariate poly
static int jjCOMPARE_ALL(const void *aa, const void *bb)
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...
INLINE_THIS void Init(int l=0)
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.
static BOOLEAN jjWRONG(leftv, leftv)
static long p_Totaldegree(poly p, const ring r)
unsigned nCmdUsed
number of commands used
BOOLEAN load_builtin(const char *newlib, BOOLEAN autoexport, SModulFunc_t init)
#define idSimpleAdd(A, B)
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
static BOOLEAN jjTIMES_MA_I1(leftv res, leftv u, leftv v)
#define pSeries(n, p, u, w)
const CanonicalForm int s
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 (...
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
CanonicalForm ndConvSingNFactoryN(number, BOOLEAN, const coeffs)
intvec * delete_pos(int p)
lists rDecompose_list_cf(const ring r)
int slStatusSsiL(lists L, int timeout)
static int _gentable_sort_cmds(const void *a, const void *b)
compares to entry of cmdsname-list
long kHomModDeg(poly p, ring r)
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...
#define pCopy(p)
return a copy of the poly
#define SI_RESTORE_OPT1(A)
static FORCE_INLINE nMapFunc n_SetMap(const coeffs src, const coeffs dst)
set the mapping function pointers for translating numbers from src to dst
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
matrix id_Module2formatedMatrix(ideal mod, int rows, int cols, const ring R)
ideal id_Copy(ideal h1, const ring r)
copy an ideal
resolvente sySchreyerResolvente(ideal arg, int maxlength, int *length, BOOLEAN isMonomial=FALSE, BOOLEAN notReplace=FALSE)
static BOOLEAN jjKLAMMER_IV(leftv res, leftv u, leftv v)
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
ideal sm_Add(ideal a, ideal b, const ring R)
BOOLEAN rHasMixedOrdering(const ring r)
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
static BOOLEAN jjPFAC2(leftv res, leftv u, leftv v)
ideal id_Transp(ideal a, const ring rRing)
transpose a module
int mp_Compare(matrix a, matrix b, const ring R)
static const char ** rParameter(const ring r)
(r->cf->parameter)
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.
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...
ideal kInterRed(ideal F, ideal Q)
lists syConvRes(syStrategy syzstr, BOOLEAN toDel, int add_row_shift)
matrix mp_Copy(matrix a, const ring r)
copies matrix a (from ring r to r)
static BOOLEAN rField_is_Z(const ring r)
static bool rIsSCA(const ring r)
#define omFreeBin(addr, bin)
static BOOLEAN rField_is_Zp(const ring r)
INST_VAR sleftv sLastPrinted
void newBuffer(char *s, feBufferTypes t, procinfo *pi, int lineno)
ideal idSubstPoly(ideal id, int n, poly e)
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
matrix idDiff(matrix i, int k)
VAR char libnamebuf[1024]
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms
static int index(p_Length length, p_Ord ord)
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)
ideal singclap_sqrfree(poly f, intvec **v, int with_exps, const ring r)
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...
static FORCE_INLINE BOOLEAN n_IsUnit(number n, const coeffs r)
TRUE iff n has a multiplicative inverse in the given coeff field/ring r.
matrix mp_Sub(matrix a, matrix b, const ring R)
intvec * ivAdd(intvec *a, intvec *b)
ideal sm_Mult(ideal a, ideal b, const ring R)
static intvec * idSort(ideal id, BOOLEAN nolex=TRUE)
const char * getBlackboxName(const int t)
return the name to the type given by t (r/o)
void luDecomp(const matrix aMat, matrix &pMat, matrix &lMat, matrix &uMat, const ring R)
LU-decomposition of a given (m x n)-matrix.
ideal id_Subst(ideal id, int n, poly e, const ring r)
void id_Normalize(ideal I, const ring r)
normialize all polys in id
BOOLEAN jjLOAD_TRY(const char *s)
static BOOLEAN jjOP_IM_I(leftv res, leftv u, leftv v)
#define idPosConstant(I)
index of generator with leading term in ground ring (if any); otherwise -1
int scMult0Int(ideal S, ideal Q, const ring tailRing)
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
static BOOLEAN jjOP_IV_I(leftv res, leftv u, leftv v)
static BOOLEAN rField_is_Q(const ring r)
syStrategy syMinimize(syStrategy syzstr)
void Clean(ring r=currRing)
#define idMaxIdeal(D)
initialise the maximal ideal (at 0)