 |
My Project
UNKNOWN_GIT_VERSION
|
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 | 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 | 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 | 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 | 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 123 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 180 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 9038 of file iparith.cc.
9040 cmdnames *pCmdL = (cmdnames*)a;
9041 cmdnames *pCmdR = (cmdnames*)
b;
9046 if(pCmdL->name==
NULL)
return 1;
9047 if(pCmdR->name==
NULL)
return -1;
9050 if(strcmp(pCmdL->name,
"$INVALID$")==0)
return -1;
9051 if(strcmp(pCmdR->name,
"$INVALID$")==0)
return 1;
9054 if (pCmdL->tokval==-1)
9056 if (pCmdR->tokval==-1)
9057 return strcmp(pCmdL->name, pCmdR->name);
9062 if(pCmdR->tokval==-1)
return -1;
9064 return strcmp(pCmdL->name, pCmdR->name);
◆ check_valid()
Definition at line 9264 of file iparith.cc.
9271 WerrorS(
"not implemented for non-commutative rings");
9295 WerrorS(
"not implemented for rings with rings as coeffients");
9302 WerrorS(
"domain required as coeffients");
9308 WarnS(
"considering the image in Q[...]");
◆ iiArithAddCmd()
int iiArithAddCmd |
( |
const char * |
szName, |
|
|
short |
nAlias, |
|
|
short |
nTokval, |
|
|
short |
nToktype, |
|
|
short |
nPos = -1 |
|
) |
| |
Definition at line 9205 of file iparith.cc.
9229 if(szName==
NULL)
return -1;
9233 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 9178 of file iparith.cc.
9181 if(szName==
NULL)
return -1;
9186 Print(
"'%s' not found (%d)\n", szName, nIndex);
◆ iiExprArith1()
Definition at line 8448 of file iparith.cc.
8459 memcpy(&d->arg1,a,
sizeof(
sleftv));
8463 res->data=(
char *)d;
8476 res->data=bb->blackbox_Init(bb);
8477 if(!bb->blackbox_Assign(
res,a))
return FALSE;
8487 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 8318 of file iparith.cc.
8328 while (dA1[
i].cmd==op)
8347 if ((call_failed=dA1[
i].
p(
res,a)))
8367 while (dA1[
i].cmd==op)
8391 || (call_failed=dA1[
i].
p(
res,an)));
8432 while (dA1[
i].cmd==op)
8436 Werror(
"expected %s(`%s`)"
◆ iiExprArith2()
Definition at line 8259 of file iparith.cc.
8270 memcpy(&d->arg1,a,
sizeof(
sleftv));
8272 memcpy(&d->arg2,
b,
sizeof(
sleftv));
8276 res->data=(
char *)d;
8289 if (!bb->blackbox_Op2(op,
res,a,
b))
return FALSE;
8295 else if ((bt>
MAX_TOK)&&(op!=
'('))
8300 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 8246 of file iparith.cc.
◆ iiExprArith2TabIntern()
Definition at line 8086 of file iparith.cc.
8099 while (dA2[
i].cmd==op)
8101 if ((at==dA2[
i].arg1)
8102 && (bt==dA2[
i].arg2))
8119 if ((call_failed=dA2[
i].
p(
res,a,
b)))
8139 while (dA2[
i].cmd==op)
8166 || (call_failed=dA2[
i].
p(
res,an,bn)));
8205 Werror(
"`%s` is not defined",
s);
8212 Werror(
"%s(`%s`,`%s`) failed"
8217 Werror(
"`%s` %s `%s` failed"
8222 while (dA2[
i].cmd==op)
8224 if(((at==dA2[
i].arg1)||(bt==dA2[
i].arg2))
8229 Werror(
"expected %s(`%s`,`%s`)"
8232 Werror(
"expected `%s` %s `%s`"
◆ iiExprArith3()
Definition at line 8661 of file iparith.cc.
8672 memcpy(&d->arg1,a,
sizeof(
sleftv));
8674 memcpy(&d->arg2,
b,
sizeof(
sleftv));
8676 memcpy(&d->arg3,c,
sizeof(
sleftv));
8680 res->data=(
char *)d;
8692 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 8713 of file iparith.cc.
◆ iiExprArith3TabIntern()
Definition at line 8507 of file iparith.cc.
8520 while (dA3[
i].cmd==op)
8522 if ((at==dA3[
i].arg1)
8523 && (bt==dA3[
i].arg2)
8524 && (ct==dA3[
i].arg3))
8532 Print(
"call %s(%s,%s,%s)\n",
8534 if ((call_failed=dA3[
i].
p(
res,a,
b,c)))
8555 while (dA3[
i].cmd==op)
8571 Print(
"call %s(%s,%s,%s)\n",
8577 || (call_failed=dA3[
i].
p(
res,an,bn,cn)));
8626 Werror(
"`%s` is not defined",
s);
8632 Werror(
"%s(`%s`,`%s`,`%s`) failed"
8636 while (dA3[
i].cmd==op)
8638 if(((at==dA3[
i].arg1)
8640 ||(ct==dA3[
i].arg3))
8643 Werror(
"expected %s(`%s`,`%s`,`%s`)"
◆ iiExprArithM()
Definition at line 8751 of file iparith.cc.
8763 res->data=(
char *)d;
8768 memcpy(&d->arg1,a,
sizeof(
sleftv));
8803 if(!bb->blackbox_OpM(op,
res,a))
return FALSE;
8818 if ((args==
dArithM[
i].number_of_args)
8820 || ((
dArithM[
i].number_of_args==-2)&&(args>0)))
◆ iiInitArithmetic()
initialisation of arithmetic structured data
- Return values
-
Definition at line 9075 of file iparith.cc.
◆ iin_Int()
static int iin_Int |
( |
number & |
n, |
|
|
coeffs |
cf |
|
) |
| |
|
static |
◆ iiTabIndex()
Definition at line 8959 of file iparith.cc.
8969 if (op==dArithTab[
p].cmd)
return dArithTab[
p].start;
8970 if (op<dArithTab[
p].cmd) e=
p-1;
◆ iiTokType()
◆ IsCmd()
int IsCmd |
( |
const char * |
n, |
|
|
int & |
tok |
|
) |
| |
Definition at line 8860 of file iparith.cc.
8918 Warn(
"outdated identifier `%s` used - please change your code",
◆ jjALIGN_M()
◆ jjALIGN_V()
◆ jjAND_I()
◆ jjBAREISS()
Definition at line 3623 of file iparith.cc.
3634 l->m[0].data=(
void *)
m;
3635 l->m[1].data=(
void *)iv;
3636 res->data = (
char *)
l;
◆ jjBAREISS3()
Definition at line 5720 of file iparith.cc.
5725 int k=(int)(
long)
w->Data();
5732 l->m[0].data=(
void *)
m;
5733 l->m[1].data=(
void *)iv;
5740 l->m[0].data=(
void *)
m;
5742 res->data = (
char *)
l;
◆ jjBAREISS_BIM()
◆ jjBI2IM()
◆ jjBI2N()
◆ jjBI2P()
◆ jjBRACK_Bim()
Definition at line 5464 of file iparith.cc.
5467 int r = (int)(
long)
v->Data();
5468 int c = (int)(
long)
w->Data();
5469 if ((r<1)||(r>bim->
rows())||(c<1)||(c>bim->
cols()))
5471 Werror(
"wrong range[%d,%d] in bigintmat %s(%d x %d)",
5485 while (
h->next!=
NULL)
h=
h->next;
◆ jjBRACK_Im()
Definition at line 5437 of file iparith.cc.
5440 int r = (int)(
long)
v->Data();
5441 int c = (int)(
long)
w->Data();
5442 if ((r<1)||(r>iv->
rows())||(c<1)||(c>iv->
cols()))
5444 Werror(
"wrong range[%d,%d] in intmat %s(%d x %d)",
5457 while (
h->next!=
NULL)
h=
h->next;
◆ jjBRACK_Ma()
Definition at line 5492 of file iparith.cc.
5495 int r = (int)(
long)
v->Data();
5496 int c = (int)(
long)
w->Data();
5500 Werror(
"wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->
Fullname(),
5514 while (
h->next!=
NULL)
h=
h->next;
◆ jjBRACK_Ma_I_IV()
Definition at line 5550 of file iparith.cc.
5561 WerrorS(
"cannot build expression lists from unnamed objects");
5564 memcpy(&ut,u,
sizeof(ut));
5565 memset(&t,0,
sizeof(t));
5569 t.
data=(
char *)(
long)((*iv)[
l]);
5579 memcpy(u,&ut,
sizeof(ut));
◆ jjBRACK_Ma_IV_I()
Definition at line 5600 of file iparith.cc.
5611 WerrorS(
"cannot build expression lists from unnamed objects");
5614 memcpy(&ut,u,
sizeof(ut));
5615 memset(&t,0,
sizeof(t));
5619 t.
data=(
char *)(
long)((*iv)[
l]);
5629 memcpy(u,&ut,
sizeof(ut));
◆ jjBRACK_Ma_IV_IV()
Definition at line 5650 of file iparith.cc.
5662 WerrorS(
"cannot build expression lists from unnamed objects");
5665 memcpy(&ut,u,
sizeof(ut));
5666 memset(&t1,0,
sizeof(
sleftv));
5667 memset(&t2,0,
sizeof(
sleftv));
5670 for (vl=0;vl< vv->
length(); vl++)
5672 t1.
data=(
char *)(
long)((*vv)[vl]);
5673 for (wl=0;wl< wv->
length(); wl++)
5675 t2.
data=(
char *)(
long)((*wv)[wl]);
5685 memcpy(u,&ut,
sizeof(ut));
◆ jjBRACK_S()
Definition at line 5421 of file iparith.cc.
5423 char *
s= (
char *)u->
Data();
5424 int r = (int)(
long)
v->Data();
5425 int c = (int)(
long)
w->Data();
5428 if ( (r<1) || (r>
l) || (c<0) )
5434 sprintf((
char *)
res->data,
"%-*.*s",c,c,
s+r-1);
◆ jjBRACK_SM()
Definition at line 5521 of file iparith.cc.
5523 ideal
m= (ideal)u->
Data();
5524 int r = (int)(
long)
v->Data();
5525 int c = (int)(
long)
w->Data();
5527 if ((r<1)||(r>
m->rank)||(c<1)||(c>
IDELEMS(
m)))
5529 Werror(
"wrong range[%d,%d] in matrix %s(%d x %d)",r,c,u->
Fullname(),
5543 while (
h->next!=
NULL)
h=
h->next;
◆ jjBRACKET()
Definition at line 2847 of file iparith.cc.
2853 const poly q = (poly)
b->Data();
◆ jjBREAK0()
◆ jjBREAK1()
◆ jjCALL1ARG()
◆ jjCALL1MANY()
◆ jjCALL2ARG()
◆ jjCALL3ARG()
◆ jjCHAR()
◆ jjCHINREM_BI()
Definition at line 1681 of file iparith.cc.
1686 number *
x=(number *)
omAlloc(rl*
sizeof(number));
1687 number *q=(number *)
omAlloc(rl*
sizeof(number));
1689 for(
i=rl-1;
i>=0;
i--)
1696 for(
i=rl-1;
i>=0;
i--)
1702 res->data=(
char *)n;
◆ jjCHINREM_ID()
Definition at line 9315 of file iparith.cc.
9321 WerrorS(
"not implemented for rings with rings as coeffients (except ZZ)");
9327 int return_type=c->
m[0].
Typ();
9343 for (
unsigned i=0;
i<=(unsigned)c->
nr;
i++)
9348 if (bo) {
Werror(
"chinrem failed for list entry %d",
i+1);
break;}
9358 WerrorS(
"poly/ideal/module/matrix/list expected");
9375 ideal *
x=(ideal *)
omAlloc(rl*
sizeof(ideal));
9381 for(
i=rl-1;
i>=0;
i--)
9383 if (c->
m[
i].
Typ()!=return_type)
9408 xx=(number *)
omAlloc(rl*
sizeof(number));
9409 for(
i=rl-1;
i>=0;
i--)
9421 Werror(
"bigint expected at pos %d",
i+1);
9428 number *q=(number *)
omAlloc(rl*
sizeof(number));
9431 for(
i=rl-1;
i>=0;
i--)
9438 for(
i=rl-1;
i>=0;
i--)
9450 Werror(
"bigint expected at pos %d",
i+1);
9466 res->data=(
char *)n;
9481 for(
i=rl-1;
i>=0;
i--)
9486 res->rtyp=return_type;
◆ jjCOEF()
◆ jjCOEF_Id()
◆ jjCOEF_M()
◆ jjCOEFFS2_KB()
◆ jjCOEFFS3_Id()
Definition at line 5745 of file iparith.cc.
5749 WerrorS(
"3rd argument must be a name of a matrix");
5752 ideal
i=(ideal)u->
Data();
5753 int rank=(int)
i->rank;
◆ jjCOEFFS3_KB()
Definition at line 5759 of file iparith.cc.
5762 (ideal)(
v->Data()),(poly)(
w->Data()));
◆ jjCOEFFS3_P()
Definition at line 5765 of file iparith.cc.
5769 WerrorS(
"3rd argument must be a name of a matrix");
5777 memset(&t,0,
sizeof(t));
◆ jjCOEFFS_Id()
◆ jjCOLCOL()
Definition at line 693 of file iparith.cc.
700 if(isupper(u->
name[0]))
702 const char *c=u->
name+1;
703 while((*c!=
'\0')&&(islower(*c)||(isdigit(*c))||(*c==
'_'))) c++;
708 Print(
"%s of type 'ANY'. Trying load.\n", u->
name);
724 package pa=(package)u->Data();
738 WerrorS(
"reserved name with ::");
750 WerrorS(
"<package>::<id> expected");
◆ jjCOLON()
Definition at line 323 of file iparith.cc.
325 int l=(int)(
long)
v->Data();
328 int d=(int)(
long)u->
Data();
331 for(
i=
l-1;
i>=0;
i--) { (*vv)[
i]=d; }
332 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 9508 of file iparith.cc.
9514 if (at < bt)
return -1;
9515 if (at > bt)
return 1;
9516 int tab_pos=
iiTabIndex(dArithTab2,JJTAB2LEN,
'<');
9518 memset(&tmp,0,
sizeof(
sleftv));
9524 unsigned long ad=(
unsigned long)a->
Data();
9525 unsigned long bd=(
unsigned long)
b->Data();
9526 if (ad<bd)
return -1;
9527 else if (ad==bd)
return 0;
9538 unsigned long ad=(
unsigned long)a->
Data();
9539 unsigned long bd=(
unsigned long)
b->Data();
9540 if (ad<bd)
return -1;
9541 else if (ad==bd)
return 0;
◆ jjCOMPARE_BIM()
Definition at line 370 of file iparith.cc.
378 res->data = (
char *) (r<0);
381 res->data = (
char *) (r>0);
384 res->data = (
char *) (r<=0);
387 res->data = (
char *) (r>=0);
391 res->data = (
char *) (r==0);
395 if(r==-2) {
WerrorS(
"size incompatible");
return TRUE; }
◆ jjCOMPARE_IV()
Definition at line 342 of file iparith.cc.
350 res->data = (
char *) (r<0);
353 res->data = (
char *) (r>0);
356 res->data = (
char *) (r<=0);
359 res->data = (
char *) (r>=0);
363 res->data = (
char *) (r==0);
367 if(r==-2) {
WerrorS(
"size incompatible");
return TRUE; }
◆ jjCOMPARE_IV_I()
Definition at line 398 of file iparith.cc.
401 int b = (int)(
long)(
v->Data());
406 res->data = (
char *) (r<0);
409 res->data = (
char *) (r>0);
412 res->data = (
char *) (r<=0);
415 res->data = (
char *) (r>=0);
419 res->data = (
char *) (r==0);
◆ jjCOMPARE_MA()
Definition at line 425 of file iparith.cc.
434 res->data = (
char *) (
long)(r < 0);
437 res->data = (
char *) (
long)(r > 0);
440 res->data = (
char *) (
long)(r <= 0);
443 res->data = (
char *) (
long)(r >= 0);
447 res->data = (
char *)(
long) (r == 0);
◆ jjCOMPARE_P()
Definition at line 453 of file iparith.cc.
455 poly
p=(poly)u->
Data();
456 poly q=(poly)
v->Data();
461 res->data = (
char *) (r < 0);
464 res->data = (
char *) (r > 0);
467 res->data = (
char *) (r <= 0);
470 res->data = (
char *) (r >= 0);
◆ jjCOMPARE_S()
Definition at line 480 of file iparith.cc.
482 char* a = (
char * )(u->
Data());
483 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 3754 of file iparith.cc.
3756 ring r=(ring)
v->Data();
3762 extern int ipower (
int b,
int n );
3763 elems=
ipower(r->cf->ch,r->cf->extRing->pFDeg(r->cf->extRing->qideal->m[0],r->cf->extRing));
3765 res->data = (
char *)(
long)elems;
◆ jjDEFINED()
Definition at line 3806 of file iparith.cc.
3813 else if (
v->rtyp!=0)
res->data=(
void *)(-1);
◆ jjDEG()
Definition at line 3768 of file iparith.cc.
3771 poly
p=(poly)
v->Data();
3773 else res->data=(
char *)-1;
◆ jjDEG_IV()
Definition at line 1847 of file iparith.cc.
1849 poly
p=(poly)u->
Data();
1855 res->data = (
char *)(d);
1858 res->data=(
char *)(
long)(-1);
◆ jjDEG_M()
Definition at line 3776 of file iparith.cc.
3778 ideal I=(ideal)u->
Data();
3784 res->data = (
char *)(
long)d;
◆ jjDEG_M_IV()
Definition at line 1836 of file iparith.cc.
1839 ideal I=(ideal)u->
Data();
1844 res->data = (
char *)((
long)d);
◆ jjDEGREE()
Definition at line 3787 of file iparith.cc.
3793 PrintS(
"// NOTE: computation of degree is being performed for\n");
3794 PrintS(
"// generic fibre, that is, over Q\n");
◆ jjDelete_ID()
Definition at line 1868 of file iparith.cc.
1870 int pos=(int)(
long)
v->Data();
1871 ideal I=(ideal)u->
Data();
◆ jjDelete_IV()
Definition at line 1861 of file iparith.cc.
1863 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 3819 of file iparith.cc.
3821 number n = reinterpret_cast<number>(
v->Data());
◆ jjDET()
◆ jjDET_BI()
◆ jjDET_I()
◆ jjDET_S()
Definition at line 3900 of file iparith.cc.
3902 ideal I=(ideal)
v->Data();
3913 res->data = (
char *)
p;
◆ jjDIFF_COEF()
Definition at line 4319 of file iparith.cc.
4323 WerrorS(
"differentiation not defined in the coefficient ring");
4326 number n = (number) u->
Data();
4327 number
k = (number)
v->Data();
◆ jjDIFF_ID()
◆ jjDIFF_ID_ID()
◆ jjDIFF_P()
◆ jjDIM()
Definition at line 3916 of file iparith.cc.
3921 Warn(
"dim(%s) may be wrong because the mixed monomial ordering",
v->Name());
3926 ideal vid = (ideal)
v->Data();
3930 res->data = (
char *)-1L;
3952 for(
unsigned ii=0;ii<(unsigned)
IDELEMS(vv);ii++)
3961 for(
unsigned jj = 0;jj<(unsigned)
IDELEMS(vc)-1;jj++)
3963 if((vc->m[jj]!=
NULL)
3984 res->data = (
char *)d;
◆ jjDIM2()
Definition at line 1902 of file iparith.cc.
1907 Warn(
"dim(%s,...) may be wrong because the mixed monomial ordering",
v->Name());
1912 ideal vid = (ideal)
v->Data();
1916 res->data = (
char *)-1;
1925 res->data = (
char *)d;
1931 res->data = (
char *)((
long)
scDimInt((ideal)(
v->Data()),(ideal)
w->Data()));
1935 res->data = (
char *)((
long)
scDimInt((ideal)(
v->Data()),q));
◆ jjDIM_R()
◆ jjDIV_BI()
Definition at line 1256 of file iparith.cc.
1258 number q=(number)
v->Data();
1266 res->data = (
char *)q;
◆ jjDIV_Ma()
Definition at line 1291 of file iparith.cc.
1293 poly q=(poly)
v->Data();
1318 res->data=(
char *)mm;
◆ jjDIV_N()
Definition at line 1269 of file iparith.cc.
1271 number q=(number)
v->Data();
1279 res->data = (
char *)q;
◆ jjDIV_P()
Definition at line 1282 of file iparith.cc.
1284 poly q=(poly)
v->CopyD();
1285 poly
p=(poly)(u->
CopyD());
◆ jjDIVISION()
Definition at line 1940 of file iparith.cc.
1942 ideal vi=(ideal)
v->Data();
1944 ideal ui=(ideal)u->
Data();
1978 res->data=(
char *)L;
◆ jjDIVISION4()
Definition at line 6744 of file iparith.cc.
6758 WarnS(
"<module>,<module>,<int>[,<intvec>] expected!");
6765 ideal P=(ideal)w1.
Data();
6766 ideal
Q=(ideal)w2.
Data();
6768 int n=(int)(
long)v3->
Data();
6775 while( (
i > 0) && ((*w0) > 0) )
6781 WarnS(
"not all weights are positive!");
6795 L->
m[1].
rtyp=v1->Typ();
6800 L->
m[1].
data=(
void *)
R->m[0];
◆ jjDIVMOD_I()
Definition at line 1233 of file iparith.cc.
1236 int a= (int)(
long)u->
Data();
1237 int b= (int)(
long)
v->Data();
1251 r=((a-c) /
b);
break;
1253 res->data=(
void *)((
long)r);
◆ jjDOTDOT()
◆ jjDUMMY()
◆ jjDUMP()
◆ jjE()
Definition at line 4006 of file iparith.cc.
4009 int co=(int)(
long)
v->Data();
4015 else WerrorS(
"argument of gen must be positive");
◆ jjELIMIN()
◆ jjELIMIN_ALG()
◆ jjELIMIN_HILB()
◆ jjELIMIN_IV()
◆ jjENVELOPE()
◆ jjEQUAL_BI()
◆ jjEQUAL_I()
Definition at line 1327 of file iparith.cc.
1329 res->data = (
char *)((
int)((long)u->
Data()) == (
int)((long)
v->Data()));
◆ jjEQUAL_Ma()
◆ jjEQUAL_N()
◆ jjEQUAL_P()
Definition at line 1357 of file iparith.cc.
1359 poly
p=(poly)u->
Data();
1360 poly q=(poly)
v->Data();
◆ jjEQUAL_R()
◆ jjEQUAL_REST()
◆ jjEQUAL_SM()
◆ jjERROR()
◆ jjEXECUTE()
Definition at line 4018 of file iparith.cc.
4020 char * d = (
char *)
v->Data();
4021 char *
s = (
char *)
omAlloc(strlen(d) + 13);
4022 strcpy(
s, (
char *)d);
4023 strcat(
s,
"\n;RETURN();\n");
◆ jjEXPORTTO()
◆ jjEXTGCD_BI()
Definition at line 2013 of file iparith.cc.
2015 number uu=(number)u->
Data();number vv=(number)
v->Data();
2024 res->data=(
char *)L;
◆ jjEXTGCD_I()
Definition at line 2027 of file iparith.cc.
2029 int uu=(int)(
long)u->
Data();
int vv=(int)(
long)
v->Data();
2030 int p0=
ABS(uu),p1=
ABS(vv);
2031 int f0 = 1, f1 = 0, g0 = 0, g1 = 1, q, r;
2053 res->data=(
char *)L;
◆ jjEXTGCD_P()
Definition at line 2056 of file iparith.cc.
2060 if (ret)
return TRUE;
2063 res->data=(
char *)L;
2064 L->
m[0].
data=(
void *)r;
2066 L->
m[1].
data=(
void *)pa;
2068 L->
m[2].
data=(
void *)pb;
◆ jjFAC_P()
Definition at line 4067 of file iparith.cc.
4077 l->m[0].data=(
void *)
f;
4079 l->m[1].data=(
void *)
v;
4080 res->data=(
void *)
l;
◆ jjFAC_P2()
Definition at line 2073 of file iparith.cc.
2076 int sw=(int)(
long)dummy->
Data();
2078 if ((sw<0)||(sw>2)) fac_sw=1;
2091 l->m[0].data=(
void *)
f;
2093 l->m[1].data=(
void *)
v;
2094 res->data=(
void *)
l;
2099 res->data=(
void *)
f;
2112 res->data=(
void *)
p;
◆ jjFACSTD()
Definition at line 4027 of file iparith.cc.
4060 WarnS(
"no factorization implemented");
4064 res->data=(
void *)L;
◆ jjFACSTD2()
◆ jjFactModD_M()
Definition at line 7741 of file iparith.cc.
7767 leftv u =
v;
int factorsGiven = 0;
7770 WerrorS(
"expected arguments (poly, int [, poly, poly] [, int, int])");
7773 else h = (poly)u->
Data();
7777 WerrorS(
"expected arguments (poly, int [, poly, poly] [, int, int])");
7780 else d = (int)(
long)u->
Data();
7786 WerrorS(
"expected arguments (poly, int [, poly, poly] [, int, int])");
7791 f0 = (poly)u->
Data();
7801 WerrorS(
"expected arguments (poly, int [, poly, poly] [, int, int])");
7806 xIndex = (int)(
long)u->
Data();
7807 yIndex = (int)(
long)u->
next->
Data();
7813 WerrorS(
"expected arguments (poly, int [, poly, poly] [, int, int])");
7820 WerrorS(
"expected non-constant polynomial argument(s)");
7824 if ((xIndex < 1) || (n < xIndex))
7826 Werror(
"index for variable x (%d) out of range [1..%d]", xIndex, n);
7829 if ((yIndex < 1) || (n < yIndex))
7831 Werror(
"index for variable y (%d) out of range [1..%d]", yIndex, n);
7834 if (xIndex == yIndex)
7836 WerrorS(
"expected distinct indices for variables x and y");
7841 if (factorsGiven == 0)
7855 WerrorS(
"expected h(0,y) to have exactly two distinct monic factors");
7870 res->data = (
char*)L;
◆ jjFAREY_BI()
Definition at line 2142 of file iparith.cc.
2146 number uu=(number)u->
Data();
2147 number vv=(number)
v->Data();
◆ jjFAREY_ID()
Definition at line 2153 of file iparith.cc.
2155 ideal uu=(ideal)u->
Data();
2156 number vv=(number)
v->Data();
◆ jjFAREY_LI()
Definition at line 9489 of file iparith.cc.
9496 for (
unsigned i=0;
i<=(unsigned)c->
nr;
i++)
9501 if (bo) {
Werror(
"farey failed for list entry %d",
i+1);
break;}
◆ jjFETCH()
Definition at line 2168 of file iparith.cc.
2170 ring r=(ring)u->
Data();
2179 int par_perm_size=0;
2188 par_perm_size=
rPar(r);
2197 perm=(
int *)
omAlloc0((r->N+1)*
sizeof(int));
2198 if (par_perm_size!=0)
2199 par_perm=(
int *)
omAlloc0(par_perm_size*
sizeof(
int));
2204 char ** r_par_names=
NULL;
2205 if (r->cf->extRing!=
NULL)
2207 r_par=r->cf->extRing->N;
2208 r_par_names=r->cf->extRing->names;
2211 char ** c_par_names=
NULL;
2215 c_par_names=
currRing->cf->extRing->names;
2217 maFindPerm(r->names, r->N, r_par_names, r_par,
2219 perm,par_perm,
currRing->cf->type);
2224 if (par_perm_size!=0)
2238 Print(
"// par nr %d: %s -> %s\n",
2244 memset(&tmpW,0,
sizeof(
sleftv));
2248 perm,par_perm,par_perm_size,nMap)))
2266 Werror(
"no identity map from %s (%s -> %s)",u->
Fullname(),s1,s2);
◆ jjFETCH_M()
Definition at line 6888 of file iparith.cc.
6890 ring r=(ring)u->
Data();
6898 WerrorS(
"fetch(<ring>,<name>[,<intvec>[,<intvec>])");
6903 if (perm_par_l!=
NULL)
6912 int par_perm_size=0;
6921 par_perm_size=
rPar(r);
6929 par_perm_size=
rPar(r);
6931 if (par_perm_size!=0)
6932 par_perm=(
int *)
omAlloc0(par_perm_size*
sizeof(
int));
6934 if (perm_par_l==
NULL)
6936 if (par_perm_size!=0)
6941 if (par_perm_size==0)
WarnS(
"source ring has no parameters");
6946 if (i<perm_par_v->
length()) par_perm[
i]=(*perm_par_v)[
i];
6950 Warn(
"invalid entry for par %d: %d\n",
i,par_perm[
i]);
6958 if (i<perm_var_v->
length()) perm[
i+1]=(*perm_var_v)[
i];
6962 Warn(
"invalid entry for var %d: %d\n",
i,perm[
i]);
6971 Print(
"// var nr %d: %s -> var %s\n",
i,r->names[
i-1],
currRing->names[perm[
i]-1]);
6977 if (par_perm[
i-1]<0)
6978 Print(
"// par nr %d: %s -> par %s\n",
6980 else if (par_perm[
i-1]>0)
6981 Print(
"// par nr %d: %s -> var %s\n",
6987 memset(&tmpW,0,
sizeof(
sleftv));
6991 perm,par_perm,par_perm_size,nMap)))
7009 Werror(
"no identity map from %s (%s -> %s)",u->
Fullname(),s1,s2);
◆ jjFIND2()
Definition at line 2270 of file iparith.cc.
2277 char *where=(
char *)u->
Data();
2278 char *what=(
char *)
v->Data();
2279 char *
found = strstr(where,what);
2282 res->data=(
char *)((
found-where)+1);
◆ jjFIND3()
Definition at line 5807 of file iparith.cc.
5815 int n=(int)(
long)
w->Data();
5816 char *where=(
char *)u->
Data();
5817 char *what=(
char *)
v->Data();
5819 if ((1>n)||(n>(
int)strlen(where)))
5821 Werror(
"start position %d out of range",n);
5824 found = strchr(where+n-1,*what);
5825 if (*(what+1)!=
'\0')
5827 while((
found !=
NULL) && (strncmp(
found+1,what+1,strlen(what+1))!=0))
5834 res->data=(
char *)((
found-where)+1);
◆ jjFRES()
Definition at line 2320 of file iparith.cc.
2324 w->data = (
char *)
"complete";
◆ jjFRES3()
Definition at line 2288 of file iparith.cc.
2291 ideal
id = (ideal)u->
Data();
2292 int max_length = (int)(
long)
v->Data();
2293 if (max_length < 0) {
2294 WerrorS(
"length for fres must not be negative");
2297 if (max_length == 0) {
2300 Warn(
"full resolution in a qring may be infinite, "
2301 "setting max length to %d", max_length);
2304 char *method = (
char *)
w->Data();
2308 if (strcmp(method,
"complete") != 0
2309 && strcmp(method,
"frame") != 0
2310 && strcmp(method,
"extended frame") != 0
2311 && strcmp(method,
"single module") != 0) {
2312 WerrorS(
"wrong optional argument for fres");
2316 res->data = (
void *)r;
◆ jjFWALK()
◆ jjFWALK3()
Definition at line 5838 of file iparith.cc.
5840 if ((
int)(
long)
w->Data()==0)
◆ jjGCD_BI()
Definition at line 2350 of file iparith.cc.
2352 number n1 = (number) u->
Data();
2353 number n2 = (number)
v->Data();
◆ jjGCD_I()
Definition at line 2336 of file iparith.cc.
2338 int uu=(int)(
long)u->
Data();
int vv=(int)(
long)
v->Data();
2339 int p0=
ABS(uu),p1=
ABS(vv);
2347 res->data=(
char *)(
long)p0;
◆ jjGCD_N()
Definition at line 2357 of file iparith.cc.
2359 number a=(number) u->
Data();
2360 number
b=(number)
v->Data();
◆ jjGCD_P()
◆ jjGE_BI()
◆ jjGE_I()
Definition at line 1179 of file iparith.cc.
1181 res->data = (
char *)(
long)((int)((
long)u->
Data()) >= (
int)((long)
v->Data()));
◆ jjGE_N()
◆ jjGETDUMP()
◆ jjGT_BI()
◆ jjGT_I()
Definition at line 1197 of file iparith.cc.
1199 res->data = (
char *)(
long)((int)((
long)u->
Data()) > (
int)((long)
v->Data()));
◆ jjGT_N()
◆ jjHIGHCORNER()
◆ jjHIGHCORNER_M()
Definition at line 4104 of file iparith.cc.
4109 ideal I=(ideal)
v->Data();
4123 WerrorS(
"module must be zero-dimensional");
4124 if (delete_w)
delete w;
4147 if (delete_w)
delete w;
4148 res->data=(
void *)po;
◆ jjHILBERT()
Definition at line 4151 of file iparith.cc.
4156 PrintS(
"// NOTE: computation of Hilbert series etc. is being\n");
4157 PrintS(
"// performed for generic fibre, that is, over Q\n");
◆ jjHILBERT2()
Definition at line 2380 of file iparith.cc.
2385 PrintS(
"// NOTE: computation of Hilbert series etc. is being\n");
2386 PrintS(
"// performed for generic fibre, that is, over Q\n");
2394 switch((
int)(long)
v->Data())
2397 res->data=(
void *)iv;
◆ jjHILBERT3()
Definition at line 5847 of file iparith.cc.
5852 Werror(
"weight vector must have size %d, not %d",
5859 PrintS(
"// NOTE: computation of Hilbert series etc. is being\n");
5860 PrintS(
"// performed for generic fibre, that is, over Q\n");
5868 switch((
int)(long)
v->Data())
5871 res->data=(
void *)iv;
◆ jjHILBERT_IV()
Definition at line 4166 of file iparith.cc.
4171 PrintS(
"// NOTE: computation of Hilbert series etc. is being\n");
4172 PrintS(
"// performed for generic fibre, that is, over Q\n");
◆ jjHOMOG1()
Definition at line 4178 of file iparith.cc.
4181 ideal v_id=(ideal)
v->Data();
4189 char *s_isHomog=
omStrDup(
"isHomog");
4195 else if (
w!=
NULL)
delete w;
◆ jjHOMOG1_W()
Definition at line 2447 of file iparith.cc.
2451 ideal v_id=(ideal)
v->Data();
2460 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 4245 of file iparith.cc.
4249 ring q=(ring)
v->Data();
4252 if (q->qideal==
NULL)
4259 WerrorS(
"can only get ideal from identical qring");
◆ jjidElem()
◆ jjidFreeModule()
◆ jjidHead()
◆ jjidMaxIdeal()
◆ jjidMinBase()
◆ jjidTransp()
◆ jjidVec2Ideal()
◆ jjIm2Iv()
◆ jjIMPART()
◆ jjINDEPSET()
◆ jjINDEPSET2()
◆ jjINDEX_I()
◆ jjINDEX_IV()
Definition at line 1410 of file iparith.cc.
1414 WerrorS(
"indexed object must have a name");
1421 memset(&t,0,
sizeof(t));
1425 t.
data=(
char *)((
long)(*iv)[
i]);
◆ jjINDEX_P()
Definition at line 1446 of file iparith.cc.
1448 poly
p=(poly)u->
Data();
1449 int i=(int)(
long)
v->Data();
◆ jjINDEX_P_IV()
◆ jjINDEX_PBu()
◆ jjINDEX_V()
Definition at line 1515 of file iparith.cc.
1517 poly
p=(poly)u->
Data();
1518 int i=(int)(
long)
v->Data();
◆ jjINDEX_V_IV()
◆ jjINTERPOLATION()
Definition at line 2480 of file iparith.cc.
2483 const int n = L->
nr;
assume (n >= 0);
2484 std::vector<ideal> V(n + 1);
2486 for(
int i = n;
i >= 0;
i--) V[
i] = (ideal)(L->
m[
i].
Data());
◆ jjINTERRED()
Definition at line 4280 of file iparith.cc.
4285 WarnS(
"interred: this command is experimental over the integers");
◆ jjINTERSEC3S()
◆ jjINTERSECT()
◆ jjINTERSECT3()
Definition at line 5932 of file iparith.cc.
5934 ideal I1=(ideal)u->
Data();
5935 ideal I2=(ideal)
v->Data();
5936 ideal I3=(ideal)
w->Data();
◆ jjINTERSECT_PL()
Definition at line 7013 of file iparith.cc.
7016 int l=
v->listLength();
7047 WerrorS(
"cannot convert to ideal or module");
7058 r[
i]=(ideal)
h->Data();
7070 r[
i]=(ideal)tmp.
Data();
◆ jjINTMAT3()
Definition at line 5918 of file iparith.cc.
5920 intvec* im=
new intvec((
int)(
long)
v->Data(),(int)(
long)
w->Data(), 0);
5926 (*im)[
i] = (*arg)[
i];
5929 res->data = (
char *)im;
◆ jjINTVEC_PL()
Definition at line 7249 of file iparith.cc.
7260 (*iv)[
i]=(int)(
long)
h->Data();
7279 res->data=(
char *)iv;
◆ jjIS_RINGVAR0()
◆ jjIS_RINGVAR_P()
◆ jjIS_RINGVAR_S()
◆ jjJACOB_M()
Definition at line 4338 of file iparith.cc.
4340 ideal
id = (ideal)a->
Data();
4350 for(
int i = 0;
i < W;
i++,
p++, q++ )
◆ jjJACOB_P()
Definition at line 4307 of file iparith.cc.
4311 poly
p=(poly)(
v->Data());
4316 res->data = (
char *)
i;
◆ jjJanetBasis()
◆ jjJanetBasis2()
◆ jjJET4()
Definition at line 7282 of file iparith.cc.
7296 WerrorS(
"2nd argument must be a unit");
7309 WerrorS(
"2nd argument must be a diagonal matrix of units");
7314 (
int)(long)u3->
Data(),
7323 Werror(
"%s(`poly`,`poly`,`int`,`intvec`) exppected",
◆ jjJET_ID()
◆ jjJET_ID_IV()
◆ jjJET_ID_M()
Definition at line 5976 of file iparith.cc.
5980 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 1558 of file iparith.cc.
1561 char * nn = (
char *)
omAlloc(strlen(u->
name) + 14);
1562 sprintf(nn,
"%s(%d)",u->
name,(
int)(
long)
v->Data());
◆ jjKLAMMER_IV()
Definition at line 1571 of file iparith.cc.
1576 long slen = strlen(u->
name) + 14;
1577 char *n = (
char*)
omAlloc(slen);
1590 sprintf(n,
"%s(%d)",u->
name,(*iv)[
i]);
◆ jjKLAMMER_PL()
Definition at line 7365 of file iparith.cc.
7368 && ((strcmp(u->
Name(),
"real")==0) || (strcmp(u->
Name(),
"complex")==0)))
7371 memset(u,0,
sizeof(
sleftv));
7389 Werror(
"`int` expected while building `%s(`",u->
name);
7394 sprintf(nn,
"%s(%d",u->
name,(
int)(
long)
v->Data());
7398 while (*
s!=
'\0')
s++;
7402 Werror(
"`int` expected while building `%s`",nn);
7406 sprintf(
s,
",%d",(
int)(
long)
v->Data());
7408 while (*
s!=
'\0')
s++;
◆ jjKLAMMER_rest()
◆ jjKoszul()
◆ jjKoszul_Id()
◆ jjL2R()
◆ jjLE_BI()
◆ jjLE_I()
Definition at line 1211 of file iparith.cc.
1213 res->data = (
char *)(
long)((int)((
long)u->
Data()) <= (
int)((long)
v->Data()));
◆ jjLE_N()
◆ jjLEADCOEF()
◆ jjLEADEXP()
Definition at line 4387 of file iparith.cc.
4389 poly
p=(poly)
v->Data();
4402 res->data=(
char *)iv;
◆ jjLEADMONOM()
Definition at line 4405 of file iparith.cc.
4407 poly
p=(poly)
v->Data();
4416 res->data = (
char*) lm;
◆ jjLIFT()
◆ jjLIFT3()
◆ jjLIFT_4()
Definition at line 7417 of file iparith.cc.
7429 ideal I=(ideal)u->
Data();
7442 Werror(
"%s(`ideal`,`ideal`,`matrix`,`string`)\n"
7443 "or (`module`,`module`,`matrix`,`string`)expected",
◆ jjLIFTSTD()
◆ jjLIFTSTD3()
◆ jjLIFTSTD_4()
Definition at line 7448 of file iparith.cc.
7461 ideal I=(ideal)u->
Data();
7468 &(hw->data.uideal),alg);
7474 Werror(
"%s(`ideal`,`ideal`,`matrix`,`string`)\n"
7475 "or (`module`,`module`,`matrix`,`string`)expected",
◆ jjLIST_PL()
Definition at line 7480 of file iparith.cc.
7483 if (
v!=
NULL) sl =
v->listLength();
7487 int add_row_shift = 0;
7489 if (weights!=
NULL) add_row_shift=weights->
min_in();
7516 Werror(
"`%s` is undefined",
h->Fullname());
7522 ((ring)L->
m[
i].
data)->ref++;
7528 res->data=(
char *)L;
◆ jjLISTRING()
Definition at line 4424 of file iparith.cc.
4428 if (mm==0) mm=0x7fff;
4429 int isLetterplace=(int)(
long)
atGet(
v,
"isLetterplaceRing",
INT_CMD);
4434 r->CanShortOut=
FALSE;
4437 res->data=(
char *)r;
◆ jjLOAD()
load lib/module given in v
Definition at line 5218 of file iparith.cc.
5223 #ifdef HAVE_DYNAMIC_LOADING
5230 Werror(
"%s: unknown type",
s);
5248 Werror(
"can not create package `%s`",plib);
5254 package pa=IDPACKAGE(pl);
5255 if ((pa->language==
LANG_C)
5258 Werror(
"can not create package `%s` - binaries exists",plib);
5264 package savepack=currPack;
5280 #ifdef HAVE_DYNAMIC_LOADING
5283 WerrorS(
"Dynamic modules are not supported by this version of Singular");
◆ jjLOAD1()
◆ jjLOAD2()
◆ jjLOAD_E()
Definition at line 2566 of file iparith.cc.
2568 char *
s=(
char *)u->
Data();
2569 if(strcmp(
s,
"with")==0)
2571 if (strcmp(
s,
"try")==0)
2573 WerrorS(
"invalid second argument");
2574 WerrorS(
"load(\"libname\" [,option]);");
◆ jjLOAD_TRY()
◆ jjLT_BI()
◆ jjLT_I()
Definition at line 1224 of file iparith.cc.
1226 res->data = (
char *)(
long)((int)((
long)u->
Data()) < (
int)((long)
v->Data()));
◆ jjLT_N()
◆ jjLU_DECOMP()
◆ jjLU_INVERSE()
Definition at line 7087 of file iparith.cc.
7102 matrix iMat;
int invertible;
7108 int rr = aMat->
rows();
7109 int cc = aMat->
cols();
7112 Werror(
"given matrix (%d x %d) is not quadratic, hence not invertible", rr, cc);
7117 WerrorS(
"matrix must be constant");
7127 int rr = uMat->
rows();
7128 int cc = uMat->
cols();
7131 Werror(
"third matrix (%d x %d) is not quadratic, hence not invertible",
7140 WerrorS(
"matricesx must be constant");
7147 Werror(
"expected either one or three matrices");
7165 res->data=(
char*)ll;
◆ jjLU_SOLVE()
Definition at line 7168 of file iparith.cc.
7189 WerrorS(
"expected exactly three matrices and one vector as input");
7199 Werror(
"first matrix (%d x %d) is not quadratic",
7205 Werror(
"second matrix (%d x %d) is not quadratic",
7211 Werror(
"second matrix (%d x %d) and third matrix (%d x %d) do not fit",
7217 Werror(
"third matrix (%d x %d) and vector (%d x 1) do not fit",
7226 WerrorS(
"matrices must be constant");
7246 res->data=(
char*)ll;
◆ jjMakeSub()
static Subexpr jjMakeSub |
( |
leftv |
e | ) |
|
|
static |
◆ jjMAP()
◆ jjMATRIX_Id()
Definition at line 6446 of file iparith.cc.
6448 int mi=(int)(
long)
v->Data();
6449 int ni=(int)(
long)
w->Data();
6452 Werror(
"converting ideal to matrix: dimensions must be positive(%dx%d)",mi,ni);
6463 memcpy(
m->m,I->m,
i*
sizeof(poly));
6464 memset(I->m,0,
i*
sizeof(poly));
6466 res->data = (
char *)
m;
◆ jjMATRIX_Ma()
Definition at line 6482 of file iparith.cc.
6484 int mi=(int)(
long)
v->Data();
6485 int ni=(int)(
long)
w->Data();
6488 Werror(
"converting matrix to matrix: dimensions must be positive(%dx%d)",mi,ni);
6505 res->data = (
char *)
m;
◆ jjMATRIX_Mo()
Definition at line 6469 of file iparith.cc.
6471 int mi=(int)(
long)
v->Data();
6472 int ni=(int)(
long)
w->Data();
6475 Werror(
"converting module to matrix: dimensions must be positive(%dx%d)",mi,ni);
◆ jjMEMORY()
Definition at line 4479 of file iparith.cc.
4486 switch(((
int)(
long)
v->Data()))
4501 res->data = (
char *)0;
4505 res->data = (
char *)0;
◆ jjMINOR_M()
Definition at line 5987 of file iparith.cc.
6027 Werror(
"`%s` is undefined",
v->Fullname());
6043 const int mk = (
const int)(
long)u->
Data();
6044 bool noIdeal =
true;
bool noK =
true;
bool noAlgorithm =
true;
6045 bool noCacheMinors =
true;
bool noCacheMonomials =
true;
6046 ideal IasSB;
int k;
char* algorithm;
int cacheMinors;
int cacheMonomials;
6062 noAlgorithm =
false;
6067 noCacheMinors =
false;
6073 noCacheMonomials =
false;
6087 noAlgorithm =
false;
6092 noCacheMinors =
false;
6097 noCacheMonomials =
false;
6104 algorithm = (
char*)u->
next->
Data();
6105 noAlgorithm =
false;
6109 noCacheMinors =
false;
6114 noCacheMonomials =
false;
6122 if (strcmp(algorithm,
"bareiss") == 0)
6123 algorithm = (
char*)
"Bareiss";
6124 if (strcmp(algorithm,
"laplace") == 0)
6125 algorithm = (
char*)
"Laplace";
6126 if (strcmp(algorithm,
"cache") == 0)
6127 algorithm = (
char*)
"Cache";
6136 if ((!noK) && (
k == 0))
6138 WerrorS(
"Provided number of minors to be computed is zero.");
6141 if ((!noAlgorithm) && (strcmp(algorithm,
"Bareiss") != 0)
6142 && (strcmp(algorithm,
"Laplace") != 0)
6143 && (strcmp(algorithm,
"Cache") != 0))
6145 WerrorS(
"Expected as algorithm one of 'B/bareiss', 'L/laplace', or 'C/cache'.");
6148 if ((!noAlgorithm) && (strcmp(algorithm,
"Bareiss") == 0)
6151 Werror(
"Bareiss algorithm not defined over coefficient rings %s",
6152 "with zero divisors.");
6156 if ((mk < 1) || (mk >
m->rows()) || (mk >
m->cols()))
6165 if ((!noAlgorithm) && (strcmp(algorithm,
"Cache") == 0)
6166 && (noCacheMinors || noCacheMonomials))
6169 cacheMonomials = 100000;
6175 (noIdeal ? 0 : IasSB),
false);
6176 else if (strcmp(algorithm,
"Cache") == 0)
6178 (noIdeal ? 0 : IasSB), 3, cacheMinors,
6179 cacheMonomials,
false);
6182 (noIdeal ? 0 : IasSB),
false);
◆ jjMINRES_R()
◆ jjMINUS_B()
◆ jjMINUS_B_P()
◆ jjMINUS_BI()
◆ jjMINUS_BIM()
◆ jjMINUS_I()
Definition at line 878 of file iparith.cc.
880 void *
ap=u->
Data();
void *bp=
v->Data();
881 int aa=(int)(
long)
ap;
882 int bb=(int)(
long)bp;
884 unsigned int a=(
unsigned int)(
unsigned long)
ap;
885 unsigned int b=(
unsigned int)(
unsigned long)bp;
889 WarnS(
"int overflow(-), result may be wrong");
891 res->data = (
char *)((
long)cc);
◆ jjMINUS_IV()
◆ jjMINUS_MA()
Definition at line 952 of file iparith.cc.
958 Werror(
"matrix size not compatible(%dx%d, %dx%d)",
◆ jjMINUS_N()
◆ jjMINUS_SM()
Definition at line 965 of file iparith.cc.
967 ideal
A=(ideal)u->
Data(); ideal
B=(ideal)
v->Data();
971 Werror(
"matrix size not compatible(%dx%d, %dx%d)",
◆ jjMINUS_V()
◆ jjMOD_BI()
Definition at line 2626 of file iparith.cc.
2628 number q=(number)
v->Data();
◆ jjMOD_N()
Definition at line 2637 of file iparith.cc.
2639 number q=(number)
v->Data();
◆ jjMOD_P()
Definition at line 2648 of file iparith.cc.
2650 poly q=(poly)
v->Data();
2656 poly
p=(poly)(u->
Data());
◆ jjMODULO()
Definition at line 2577 of file iparith.cc.
2596 ideal u_id=(ideal)u->
Data();
2597 ideal v_id=(ideal)
v->Data();
2600 if ((*w_u).compare((w_v))!=0)
2602 WarnS(
"incompatible weights");
2603 delete w_u; w_u=
NULL;
2611 WarnS(
"wrong weights");
2612 delete w_u; w_u=
NULL;
2617 res->data = (
char *)
idModulo(u_id,v_id ,hom,&w_u);
◆ jjMONITOR1()
◆ jjMONITOR2()
Definition at line 2671 of file iparith.cc.
2674 char *opt=(
char *)
v->Data();
2686 if(strcmp(
l->m->type,
"ASCII")!=0)
2688 Werror(
"ASCII link required, not `%s`",
l->m->type);
2693 if (
l->name[0]!=
'\0')
2697 if (
v==
NULL) opt=(
const char*)
"i";
2698 else opt=(
const char *)
v->Data();
◆ jjMONOM()
◆ jjmpTrace()
◆ jjmpTransp()
◆ jjMSTD()
Definition at line 4512 of file iparith.cc.
4520 l->m[0].data=(
char *)r;
4523 l->m[1].data=(
char *)
m;
4524 res->data=(
char *)
l;
◆ jjMULT()
◆ jjN2BI()
Definition at line 4547 of file iparith.cc.
4549 number n,
i;
i=(number)
v->Data();
4554 res->data=(
void *)n;
◆ jjNAMEOF()
◆ jjNAMES()
◆ jjNAMES0()
◆ jjNAMES_I()
◆ jjNEWSTRUCT2()
Definition at line 2736 of file iparith.cc.
2740 const char *
s=(
const char *)u->
Data();
2741 newstruct_desc d=
NULL;
2747 else WerrorS(
"name of newstruct must be longer than 1 character");
◆ jjNEWSTRUCT3()
◆ jjnInt()
◆ jjnlInt()
◆ jjNOT()
Definition at line 4582 of file iparith.cc.
4584 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 3828 of file iparith.cc.
3830 number n = reinterpret_cast<number>(
v->Data());
◆ jjNVARS()
Definition at line 4587 of file iparith.cc.
4589 res->data = (
char *)(
long)(((ring)(
v->Data()))->N);
◆ jjOP_BI_BIM()
◆ jjOP_BIM_BI()
Definition at line 266 of file iparith.cc.
269 number bb = (number)(
v->Data());
276 res->data=(
char *)cc;
◆ jjOP_BIM_I()
Definition at line 247 of file iparith.cc.
250 int bb = (int)(
long)(
v->Data());
255 case '+': cc=
bimAdd(aa,bb);
break;
256 case '-': cc=
bimSub(aa,bb);
break;
257 case '*': cc=
bimMult(aa,bb);
break;
259 res->data=(
char *)cc;
◆ jjOP_I_BIM()
◆ jjOP_I_IM()
◆ jjOP_I_IV()
◆ jjOP_IM_I()
Definition at line 304 of file iparith.cc.
307 int bb = (int)(
long)(
v->Data());
316 res->data=(
char *)aa;
◆ jjOP_IV_I()
Definition at line 283 of file iparith.cc.
286 int bb = (int)(
long)(
v->Data());
290 case '+': (*aa) += bb;
break;
291 case '-': (*aa) -= bb;
break;
292 case '*': (*aa) *= bb;
break;
295 case '%': (*aa) %= bb;
break;
297 res->data=(
char *)aa;
◆ jjOP_REST()
◆ jjOpenClose()
◆ jjOPPOSE()
Definition at line 2866 of file iparith.cc.
2869 ring r = (ring)a->
Data();
2872 res->data =
b->Data();
2873 res->rtyp =
b->rtyp;
2878 Werror(
"%s is not an opposite ring to current ring",a->
Fullname());
2891 res->rtyp = argtype;
2899 res->rtyp = argtype;
2907 res->rtyp = argtype;
2920 res->rtyp = argtype;
2925 WerrorS(
"unsupported type in oppose");
◆ jjOPPOSITE()
Definition at line 5046 of file iparith.cc.
5048 ring r = (ring)a->
Data();
5056 WarnS(
"opposite only for global orderings");
◆ jjOPTION_PL()
◆ jjOR_I()
◆ jjORD()
◆ jjP2BI()
Definition at line 4644 of file iparith.cc.
4646 poly
p=(poly)
v->Data();
4650 WerrorS(
"poly must be constant");
4659 res->data=(
void *)n;
◆ jjP2I()
◆ jjP2N()
◆ jjPAR1()
Definition at line 4604 of file iparith.cc.
4606 int i=(int)(
long)
v->Data();
4609 if ((0<
i) && (
i<=
p))
4615 Werror(
"par number %d out of range 1..%d",
i,
p);
◆ jjPARDEG()
Definition at line 4620 of file iparith.cc.
4622 number nn=(number)
v->Data();
◆ jjPARSTR1()
Definition at line 4626 of file iparith.cc.
4633 int i=(int)(
long)
v->Data();
4639 Werror(
"par number %d out of range 1..%d",
i,
p);
◆ jjPARSTR2()
Definition at line 2750 of file iparith.cc.
2753 int i=(
int)(long)
v->Data();
2761 Werror(
"par number %d out of range 1..%d",
i,
p);
◆ jjPFAC1()
Definition at line 4440 of file iparith.cc.
4445 memset(&tmp, 0,
sizeof(tmp));
◆ jjPFAC2()
Definition at line 3123 of file iparith.cc.
3130 n1 = (number)u->
CopyD();
3134 i = (int)(
long)u->
Data();
3142 i = (int)(
long)
v->Data();
3146 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 755 of file iparith.cc.
757 unsigned int a=(
unsigned int)(
unsigned long)u->
Data();
758 unsigned int b=(
unsigned int)(
unsigned long)
v->Data();
760 res->data = (
char *)((
long)c);
763 WarnS(
"int overflow(+), result may be wrong");
◆ jjPLUS_ID()
◆ jjPLUS_IV()
◆ jjPLUS_MA()
Definition at line 824 of file iparith.cc.
830 Werror(
"matrix size not compatible(%dx%d, %dx%d)",
◆ jjPLUS_MA_P()
◆ jjPLUS_N()
◆ jjPLUS_P_MA()
◆ jjPLUS_S()
Definition at line 863 of file iparith.cc.
865 char* a = (
char * )(u->
Data());
866 char*
b = (
char * )(
v->Data());
867 char* r = (
char * )
omAlloc(strlen(a) + strlen(
b) + 1);
◆ jjPLUS_SM()
Definition at line 836 of file iparith.cc.
838 ideal
A=(ideal)u->
Data(); ideal
B=(ideal)
v->Data();
842 Werror(
"matrix size not compatible(%dx%d, %dx%d)",
◆ jjPLUS_V()
◆ jjPLUSMINUS_Gen()
◆ jjPLUSPLUS()
◆ jjpMaxComp()
◆ jjPOWER_BI()
Definition at line 569 of file iparith.cc.
571 int e=(int)(
long)
v->Data();
572 number n=(number)u->
Data();
579 WerrorS(
"exponent must be non-negative");
◆ jjPOWER_I()
Definition at line 523 of file iparith.cc.
525 int b=(int)(
long)u->
Data();
526 int e=(int)(
long)
v->Data();
535 else if ((e==0)||(
b==1))
553 if(rc/
b!=oldrc) overflow=
TRUE;
557 WarnS(
"int overflow(^), result may be wrong");
559 res->data = (
char *)((
long)rc);
565 WerrorS(
"exponent must be non-negative");
◆ jjPOWER_ID()
◆ jjPOWER_N()
Definition at line 585 of file iparith.cc.
587 int e=(int)(
long)
v->Data();
588 number n=(number)u->
Data();
◆ jjPOWER_P()
Definition at line 603 of file iparith.cc.
605 int v_i=(int)(
long)
v->Data();
608 WerrorS(
"exponent must be non-negative");
616 Werror(
"OVERFLOW in power(d=%ld, e=%d, max=%ld)",
◆ jjPREIMAGE()
Definition at line 6196 of file iparith.cc.
6206 WerrorS(
"2nd/3rd arguments must have names");
6210 const char *ring_name=u->
Name();
6217 if ((preim_ring==
NULL)
6220 Werror(
"preimage ring `%s` is not the basering",mapping->preimage);
6236 Werror(
"`%s` is not defined in `%s`",
v->
name,ring_name);
6240 if (kernel_cmd) image=
idInit(1,1);
6257 Werror(
"`%s` is not defined in `%s`",
w->name,ring_name);
6264 WarnS(
"preimage in local qring may be wrong: use Ring::preimageLoc instead");
◆ jjPREIMAGE_R()
◆ jjPRIME()
◆ jjPROC()
◆ jjPROC1()
◆ jjPROC3()
◆ jjPRUNE()
Definition at line 4688 of file iparith.cc.
4691 ideal v_id=(ideal)
v->Data();
4696 WarnS(
"wrong weights");
◆ jjQRDS()
Definition at line 7931 of file iparith.cc.
7938 WerrorS(
"expected (matrix, number, number, number) as arguments");
7943 (number)(
v->Data()),
7944 (number)(
w->Data()),
7945 (number)(
x->Data()));
◆ jjQUOT()
◆ jjRANDOM()
Definition at line 2947 of file iparith.cc.
2949 int i=(int)(
long)u->
Data();
2950 int j=(int)(
long)
v->Data();
2951 if (
j-
i <0) {
WerrorS(
"invalid range for random");
return TRUE;}
◆ jjRANDOM_Im()
Definition at line 6270 of file iparith.cc.
6273 int i=(int)(
long)u->
Data();
6274 int r=(int)(
long)
v->Data();
6275 int c=(int)(
long)
w->Data();
6276 if ((r<=0) || (c<=0))
return TRUE;
6292 res->data = (
char *)iv;
◆ jjRANK1()
◆ jjRANK2()
Definition at line 2955 of file iparith.cc.
2958 int isRowEchelon = (int)(
long)
v->Data();
2959 if (isRowEchelon != 1) isRowEchelon = 0;
2960 int rank =
luRank(
m, isRowEchelon);
2961 res->data =(
char *)(
long)rank;
◆ jjrCharStr()
◆ jjREAD()
◆ jjREAD2()
◆ jjREDUCE3_CID()
◆ jjREDUCE3_CP()
◆ jjREDUCE3_ID()
◆ jjREDUCE3_P()
◆ jjREDUCE4()
Definition at line 7546 of file iparith.cc.
7577 WerrorS(
"2nd argument must be a diagonal matrix of units");
7585 (
int)(long)u4->
Data()
7595 else u1p=(poly)u1->
Data();
7598 else u2p=(poly)u2->
Data();
7602 WerrorS(
"2nd argument must be a unit");
◆ jjREDUCE5()
Definition at line 7618 of file iparith.cc.
7631 WerrorS(
"2nd argument must be a diagonal matrix of units");
7639 (
int)(long)u4->
Data(),
7651 WerrorS(
"2nd argument must be a unit");
7662 Werror(
"%s(`ideal`,`ideal`,`matrix`,`int`,`intvec`) exppected",
◆ jjREDUCE_ID()
Definition at line 2988 of file iparith.cc.
2990 ideal ui=(ideal)u->
Data();
2991 ideal vi=(ideal)
v->Data();
◆ jjREDUCE_P()
Definition at line 2980 of file iparith.cc.
2982 ideal vi=(ideal)
v->Data();
◆ jjREGULARITY()
◆ jjREPART()
◆ jjRES()
Definition at line 2997 of file iparith.cc.
2999 int maxl=(int)(
long)
v->Data();
3002 WerrorS(
"length for res must not be negative");
3008 ideal u_id=(ideal)u->
Data();
3017 "full resolution in a qring may be infinite, setting max length to %d",
3031 int add_row_shift=0;
3035 add_row_shift = ww->
min_in();
3036 (*ww) -= add_row_shift;
3052 (
"`lres` not implemented for inhomogeneous input or qring");
3056 WarnS(
"the current implementation of `lres` may not work in the case of a single variable");
3066 (
"`kres` not implemented for inhomogeneous input or qring");
3078 (
"`hres` not implemented for inhomogeneous input or qring");
3081 ideal u_id_copy=
idCopy(u_id);
3083 r=
syHilb(u_id_copy,&dummy);
3096 res->data=(
void *)r;
3097 if ((weights!=
NULL) && (ww!=
NULL)) {
delete ww; ww=
NULL; }
3101 if (weights!=
NULL) (*ww) += add_row_shift;
◆ jjRES3()
Definition at line 6585 of file iparith.cc.
6587 int maxl=(int)
v->Data();
6588 ideal u_id=(ideal)u->
Data();
6604 WarnS(
"wrong weights");
◆ jjRESERVED0()
◆ jjRESERVEDNAME()
Definition at line 4728 of file iparith.cc.
4730 char *
s= (
char *)
v->Data();
4737 res->data = (
char *)1;
4746 res->data = (
char *)1;
◆ jjRESTART()
Definition at line 8060 of file iparith.cc.
8062 int c=(int)(
long)u->
Data();
8066 PrintS(
"delete all variables\n");
8071 default:
WerrorS(
"not implemented");
◆ jjRING3()
◆ jjRING_1()
◆ jjRING_2()
◆ jjRING_LIST()
◆ jjRING_PL()
Definition at line 8031 of file iparith.cc.
8036 WerrorS(
"expected `cring` [ `id` ... ]");
8042 char **n=(
char**)
omAlloc0(
N*
sizeof(
char*));
8043 for(
int i=0;
i<
N;
i++,names=names->
next)
8045 n[
i]=(
char *)names->Name();
◆ jjRINGLIST()
Definition at line 4771 of file iparith.cc.
4773 ring r=(ring)
v->Data();
4779 long mm=r->bitmask/2;
◆ jjRINGLIST_C()
◆ jjrOrdStr()
◆ jjROWS()
Definition at line 4801 of file iparith.cc.
4803 ideal
i = (ideal)
v->Data();
4804 res->data = (
char *)
i->rank;
◆ jjROWS_BIM()
◆ jjROWS_IV()
◆ jjRPAR()
◆ jjrParStr()
◆ jjRSUM()
◆ jjrVarStr()
◆ jjSBA()
Definition at line 4864 of file iparith.cc.
4867 ideal v_id=(ideal)
v->Data();
4874 WarnS(
"wrong weights");
◆ jjSBA_1()
Definition at line 4890 of file iparith.cc.
4893 ideal v_id=(ideal)
v->Data();
4900 WarnS(
"wrong weights");
◆ jjSBA_2()
Definition at line 4916 of file iparith.cc.
4919 ideal v_id=(ideal)
v->Data();
4926 WarnS(
"wrong weights");
◆ jjSetRing()
Definition at line 3598 of file iparith.cc.
3603 ring r=(ring)u->
Data();
3607 char name_buffer[100];
3608 static int ending=1000000;
3610 sprintf(name_buffer,
"PYTHON_RING_VAR%d",ending);
◆ jjSIMPL_ID()
Definition at line 3163 of file iparith.cc.
3165 int sw = (int)(
long)
v->Data();
3196 res->data = (
char * )
id;
◆ jjSIMPL_P()
Definition at line 3258 of file iparith.cc.
3260 int sw = (int)(
long)
v->Data();
3271 res->data = (
char * )
p;
◆ jjSLIM_GB()
Definition at line 4822 of file iparith.cc.
4828 WerrorS(
"qring not supported by slimgb at the moment");
4833 WerrorS(
"ordering must be global for slimgb");
4837 WarnS(
"groebner base computations with inexact coefficients can not be trusted due to rounding errors");
4840 ideal u_id=(ideal)u->
Data();
4845 WarnS(
"wrong weights");
◆ jjSMATRIX_Mo()
Definition at line 6508 of file iparith.cc.
6510 int mi=(int)(
long)
v->Data();
6511 int ni=(int)(
long)
w->Data();
6514 Werror(
"converting to smatrix: dimensions must be positive(%dx%d)",mi,ni);
◆ jjSort_Id()
◆ jjSORTLIST()
◆ jjSQR_FREE()
Definition at line 4975 of file iparith.cc.
4985 l->m[0].data=(
void *)
f;
4987 l->m[1].data=(
void *)
v;
4988 res->data=(
void *)
l;
◆ jjSQR_FREE2()
Definition at line 3200 of file iparith.cc.
3203 int sw=(int)(
long)dummy->
Data();
3218 l->m[0].data=(
void *)
f;
3220 l->m[1].data=(
void *)
v;
3221 res->data=(
void *)
l;
3226 res->data=(
void *)
f;
3239 res->data=(
void *)
p;
◆ jjSTATUS2()
◆ jjSTATUS2L()
◆ jjSTATUS3()
Definition at line 6628 of file iparith.cc.
6632 yes = (strcmp((
char *)
res->data, (
char *)
w->Data()) == 0);
6634 res->data = (
void *)(
long)yes;
◆ jjSTATUS_M()
Definition at line 7873 of file iparith.cc.
7881 #if defined(HAVE_USLEEP)
7882 if (((
long)
res->data) == 0L)
7891 #elif defined(HAVE_SLEEP)
7892 if (((
int)
res->data) == 0)
7897 si_sleep((is - 1)/1000000 + 1);
◆ jjSTD()
Definition at line 4942 of file iparith.cc.
4945 WarnS(
"groebner base computations with inexact coefficients can not be trusted due to rounding errors");
4947 ideal v_id=(ideal)
v->Data();
4954 WarnS(
"wrong weights");
◆ jjSTD_1()
Definition at line 3300 of file iparith.cc.
3304 ideal i1=(ideal)(u->
Data());
3310 poly
p=(poly)
v->Data();
3314 memset(i0->m,0,
sizeof(poly)*
IDELEMS(i0));
3347 i0=(ideal)
v->CopyD();
3349 memset(i0->m,0,
sizeof(poly)*
IDELEMS(i0));
◆ jjSTD_HILB()
◆ jjSTD_HILB_W()
◆ jjSTD_HILB_WP()
Definition at line 7948 of file iparith.cc.
7955 ideal i1=(ideal)(u->
Data());
7961 WerrorS(
"expected `std(`ideal/module`,`poly/vector`,`intvec`,`intvec`)");
7976 i0->m[0]=(poly)
v->Data();
7981 i0=(ideal)
v->Data();
7985 WerrorS(
"expected `std(`ideal/module`,`poly/vector`,`intvec`,`intvec`)");
7992 memset(i0->m,0,
sizeof(poly)*
IDELEMS(i0));
8002 WarnS(
"wrong weights");
◆ jjSTRING_PL()
Definition at line 7688 of file iparith.cc.
7695 int n =
v->listLength();
7698 res->data =
v->String();
7702 char** slist = (
char**)
omAlloc(n*
sizeof(
char*));
7707 slist[
i] =
v->String();
7709 j+=strlen(slist[
i]);
7711 char*
s = (
char*)
omAlloc((
j+1)*
sizeof(char));
7715 strcat(
s, slist[
i]);
◆ jjstrlen()
Definition at line 5307 of file iparith.cc.
5309 res->data = (
char *)strlen((
char *)
v->Data());
◆ jjSUBST_Bu()
◆ jjSUBST_Id()
Definition at line 6384 of file iparith.cc.
6389 if (nok)
return TRUE;
6390 ideal
id=(ideal)u->
Data();
6394 if (monomexpr!=
NULL)
6409 Warn(
"possible OVERFLOW in subst, max exponent is %ld",
currRing->bitmask/2);
◆ jjSUBST_Id_I()
◆ jjSUBST_Id_N()
◆ jjSUBST_Id_X()
Definition at line 6436 of file iparith.cc.
6439 memset(&tmp,0,
sizeof(tmp));
◆ jjSUBST_M()
Definition at line 7904 of file iparith.cc.
7916 if ((rest!=
NULL) && (!
b))
7921 memset(&tmp_res,0,
sizeof(tmp_res));
7923 memcpy(
res,&tmp_res,
sizeof(tmp_res));
◆ jjSUBST_P()
◆ jjSUBST_Test()
Definition at line 6317 of file iparith.cc.
6320 monomexpr=(poly)
w->Data();
6321 poly
p=(poly)
v->Data();
6325 Werror(
"`%s` substitutes a ringvar only by a term",
6330 if ((ringvar=
pVar(
p))==0)
6339 WerrorS(
"ringvar/par expected");
◆ jjSYZ_2()
◆ jjSYZYGY()
◆ jjTENSOR()
Definition at line 3395 of file iparith.cc.
3397 ideal
A=(ideal)u->
Data();
3398 ideal
B=(ideal)
v->Data();
◆ jjTENSOR_Ma()
◆ jjTEST()
◆ jjTIMES_BI()
◆ jjTIMES_BIM()
◆ jjTIMES_I()
Definition at line 978 of file iparith.cc.
980 int a=(int)(
long)u->
Data();
981 int b=(int)(
long)
v->Data();
983 if ((c>INT_MAX)||(c<INT_MIN))
984 WarnS(
"int overflow(*), result may be wrong");
985 res->data = (
char *)((
long)((int)c));
◆ jjTIMES_ID()
◆ jjTIMES_IV()
◆ jjTIMES_MA()
Definition at line 1142 of file iparith.cc.
1148 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 997 of file iparith.cc.
999 res->data = (
char *)(
nMult( (number)u->
Data(), (number)
v->Data()));
1000 number n=(number)
res->data;
1002 res->data=(
char *)n;
◆ jjTIMES_P()
Definition at line 1007 of file iparith.cc.
1020 Warn(
"possible OVERFLOW in mult(d=%ld, d=%ld, max=%ld)",
1032 Warn(
"possible OVERFLOW in mult(d=%ld, d=%ld, max=%ld)",
◆ jjTIMES_SM()
Definition at line 1157 of file iparith.cc.
1159 ideal
A=(ideal)u->
Data(); ideal
B=(ideal)
v->Data();
1163 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 5132 of file iparith.cc.
5134 int i=(int)(
long)
v->Data();
5135 if ((0<
i) && (i<=currRing->
N))
5140 res->data=(
char *)
p;
◆ jjVARSTR1()
Definition at line 5149 of file iparith.cc.
5156 int i=(int)(
long)
v->Data();
5157 if ((0<
i) && (i<=currRing->
N))
◆ jjVARSTR2()
◆ jjVDIM()
◆ jjWAIT1ST1()
◆ jjWAIT1ST2()
Definition at line 3434 of file iparith.cc.
3445 int t = (int)(
long)
v->Data();
3455 res->data = (
void*)(
long)
i;
◆ jjWAITALL1()
Definition at line 5187 of file iparith.cc.
5197 for(
int nfinished = 0; nfinished < Lforks->
nr+1; nfinished++)
5213 res->data = (
void*)(
long)
j;
◆ jjWAITALL2()
Definition at line 3458 of file iparith.cc.
3470 int timeout = 1000*(int)(
long)
v->Data();
3478 for(
unsigned nfinished = 0; nfinished < ((unsigned)Lforks->
nr)+1; nfinished++)
3503 res->data = (
void*)(
long)ret;
◆ jjWEDGE()
◆ jjWRONG()
◆ pHeadProc()
◆ Tok2Cmdname()
const char* Tok2Cmdname |
( |
int |
tok | ) |
|
Definition at line 8984 of file iparith.cc.
8990 if (tok==
ANY_TYPE)
return "any_type";
8991 if (tok==
COMMAND)
return "command";
8992 if (tok==
NONE)
return "nothing";
9004 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 197 of file iparith.cc.
◆ singclap_factorize_retry
int 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, 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)
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 might be != 0
BOOLEAN jjStdJanetBasis(leftv res, leftv v, int flag)
flag: 0: JB, 1: SB
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)
void pRestoreDegProcs(ring r, pFDegProc old_FDeg, pLDegProc old_lDeg)
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)
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...
int singclap_factorize_retry
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)
poly singclap_det(const matrix m, const ring s)
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
BOOLEAN yyInRingConstruction
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)
void omPrintInfo(FILE *fd)
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)
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)
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 BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
static unsigned pLength(poly a)
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)
#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)
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
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)
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)
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)
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)
void omPrintBinStats(FILE *fd)
BOOLEAN iiExport(leftv v, int toLev)
matrix mp_Transp(matrix a, const ring R)
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 omPrintStats(FILE *fd)
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)
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 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 )
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
#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)
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)
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)
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)
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),...
static SArithBase sArithBase
Base entry for arithmetic.
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.
void(* WerrorS_callback)(const char *s)
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)
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)
poly sm_CallDet(ideal I, const ring R)
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)
static int WerrorS_dummy_cnt
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
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)
const struct sConvertTypes dConvertTypes[]
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)
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)
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)
ideal id_Head(ideal h, const ring r)
returns the ideals of initial terms
static si_char_2 Tok2Cmdname_buf
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)
BOOLEAN sm_CheckDet(ideal I, int d, BOOLEAN sw, const ring r)
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)