opycaml / number.idl.in

// -------------------------------------- Number protocol

boolean PyNumber_Check(PyObject  *o);
// Returns 1 if the object o provides numeric protocols, and false otherwise. This function always succeeds.

[new] PyNumberObject* PyNumber_Add(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of adding o1 and o2, or NULL on failure. This is the equivalent of the Python expression o1 + o2.

[new] PyNumberObject* PyNumber_Subtract(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of subtracting o2 from o1, or NULL on failure. This is the equivalent of the Python expression o1 - o2.

[new] PyNumberObject* PyNumber_Multiply(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of multiplying o1 and o2, or NULL on failure. This is the equivalent of the Python expression o1 * o2.

[new] PyNumberObject* PyNumber_Divide(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of dividing o1 by o2, or NULL on failure. This is the equivalent of the Python expression o1 / o2.

[new] PyNumberObject* PyNumber_FloorDivide(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Return the floor of o1 divided by o2, or NULL on failure. This is equivalent to the “classic” division of integers.

[new] PyNumberObject* PyNumber_TrueDivide(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Return a reasonable approximation for the mathematical value of o1 divided by o2, or NULL on failure. The return value is “approximate” because binary floating point numbers are approximate; it is not possible to represent all real numbers in base two. This function can return a floating point value when passed two integers.

[new] PyNumberObject* PyNumber_Remainder(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the remainder of dividing o1 by o2, or NULL on failure. This is the equivalent of the Python expression o1 % o2.

[new] PyNumberObject* PyNumber_Divmod(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// See the built-in function divmod(). Returns NULL on failure. This is the equivalent of the Python expression divmod(o1, o2).

[new] PyNumberObject* PyNumber_Power(PyNumberObject *o1, PyNumberObject *o2, PyNumberObject *o3);
// Return value: New reference.
// See the built-in function pow(). Returns NULL on failure. This is the equivalent of the Python expression pow(o1, o2, o3), where o3 is optional. If o3 is to be ignored, pass Py_None in its place (passing NULL for o3 would cause an illegal memory access).

[new] PyNumberObject* PyNumber_Negative(PyNumberObject *o);
// Return value: New reference.
// Returns the negation of o on success, or NULL on failure. This is the equivalent of the Python expression -o.

[new] PyNumberObject* PyNumber_Positive(PyNumberObject *o);
// Return value: New reference.
// Returns o on success, or NULL on failure. This is the equivalent of the Python expression +o.

[new] PyNumberObject* PyNumber_Absolute(PyNumberObject *o);
// Return value: New reference.
// Returns the absolute value of o, or NULL on failure. This is the equivalent of the Python expression abs(o).

[new] PyNumberObject* PyNumber_Invert(PyNumberObject *o);
// Return value: New reference.
// Returns the bitwise negation of o on success, or NULL on failure. This is the equivalent of the Python expression ~o.

[new] PyNumberObject* PyNumber_Lshift(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of left shifting o1 by o2 on success, or NULL on failure. This is the equivalent of the Python expression o1 << o2.

[new] PyNumberObject* PyNumber_Rshift(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of right shifting o1 by o2 on success, or NULL on failure. This is the equivalent of the Python expression o1 >> o2.

[new] PyNumberObject* PyNumber_And(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the “bitwise and” of o1 and o2 on success and NULL on failure. This is the equivalent of the Python expression o1 & o2.

[new] PyNumberObject* PyNumber_Xor(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the “bitwise exclusive or” of o1 by o2 on success, or NULL on failure. This is the equivalent of the Python expression o1 ^ o2.

[new] PyNumberObject* PyNumber_Or(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the “bitwise or” of o1 and o2 on success, or NULL on failure. This is the equivalent of the Python expression o1 | o2.

[new] PyNumberObject* PyNumber_InPlaceAdd(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of adding o1 and o2, or NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 += o2.

[new] PyNumberObject* PyNumber_InPlaceSubtract(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of subtracting o2 from o1, or NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 -= o2.

[new] PyNumberObject* PyNumber_InPlaceMultiply(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of multiplying o1 and o2, or NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 *= o2.

[new] PyNumberObject* PyNumber_InPlaceDivide(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of dividing o1 by o2, or NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 /= o2.

[new] PyNumberObject* PyNumber_InPlaceFloorDivide(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the mathematical floor of dividing o1 by o2, or NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 //= o2.

[new] PyNumberObject* PyNumber_InPlaceTrueDivide(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Return a reasonable approximation for the mathematical value of o1 divided by o2, or NULL on failure. The return value is “approximate” because binary floating point numbers are approximate; it is not possible to represent all real numbers in base two. This function can return a floating point value when passed two integers. The operation is done in-place when o1 supports it.

[new] PyNumberObject* PyNumber_InPlaceRemainder(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the remainder of dividing o1 by o2, or NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 %= o2.

[new] PyNumberObject* PyNumber_InPlacePower(PyNumberObject *o1, PyNumberObject *o2, PyNumberObject *o3);
// Return value: New reference.
// See the built-in function pow(). Returns NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 **= o2 when o3 is Py_None, or an in-place variant of pow(o1, o2, o3) otherwise. If o3 is to be ignored, pass Py_None in its place (passing NULL for o3 would cause an illegal memory access).

[new] PyNumberObject* PyNumber_InPlaceLshift(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of left shifting o1 by o2 on success, or NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 <<= o2.

[new] PyNumberObject* PyNumber_InPlaceRshift(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the result of right shifting o1 by o2 on success, or NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 >>= o2.

[new] PyNumberObject* PyNumber_InPlaceAnd(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the “bitwise and” of o1 and o2 on success and NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 &= o2.

[new] PyNumberObject* PyNumber_InPlaceXor(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the “bitwise exclusive or” of o1 by o2 on success, or NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 ^= o2.

[new] PyNumberObject* PyNumber_InPlaceOr(PyNumberObject *o1, PyNumberObject *o2);
// Return value: New reference.
// Returns the “bitwise or” of o1 and o2 on success, or NULL on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python statement o1 |= o2.

// int PyNumber_Coerce(PyObject **p1, PyObject **p2);
// This function takes the addresses of two variables of type PyObject*. If the objects pointed to by *p1 and *p2 have the same type, increment their reference count and return 0 (success). If the objects can be converted to a common numeric type, replace *p1 and *p2 by their converted value (with ‘new’ reference counts), and return 0. If no conversion is possible, or if some other error occurs, return -1 (failure) and don’t increment the reference counts. The call PyNumber_Coerce(&o1, &o2) is equivalent to the Python statement o1, o2 = coerce(o1, o2).

// int PyNumber_CoerceEx(PyObject **p1, PyObject **p2);
// This function is similar to PyNumber_Coerce(), except that it returns 1 when the conversion is not possible and when no error is raised. Reference counts are still not increased in this case.

[new] PyIntObject* PyNumber_Int(PyNumberObject *o);
// Return value: New reference.
// Returns the o converted to an integer object on success, or NULL on failure. If the argument is outside the integer range a long object will be returned instead. This is the equivalent of the Python expression int(o).

[new] PyLongObject* PyNumber_Long(PyNumberObject *o);
// Return value: New reference.
// Returns the o converted to a long integer object on success, or NULL on failure. This is the equivalent of the Python expression long(o).

[new] PyFloatObject* PyNumber_Float(PyNumberObject *o);
// Return value: New reference.
// Returns the o converted to a float object on success, or NULL on failure. This is the equivalent of the Python expression float(o).

[new] PyIntegralObject* PyNumber_Index(PyNumberObject *o); /* [new] ?? not sure */ 
// Returns the o converted to a Python int or long on success or NULL with a TypeError exception raised on failure.

PyIntObject* PyNumber_ToBase(PyNumberObject *n, int base);
// Returns the integer n converted to base as a string with a base marker of '0b', '0o', or '0x' if applicable. When base is not 2, 8, 10, or 16, the format is 'x#num' where x is the base. If n is not an int object, it is converted with PyNumber_Index() first.

size_or_fail PyNumber_AsSsize_t(PyNumberObject *o, PyObject *exc); [mlname asSsize_t_exn]
// Returns o converted to a Py_ssize_t value if o can be interpreted as an integer. If o can be converted to a Python int or long but the attempt to convert to a Py_ssize_t value would raise an OverflowError, then the exc argument is the type of exception that will be raised (usually IndexError or OverflowError). If exc is NULL, then the exception is cleared and the value is clipped to PY_SSIZE_T_MIN for a negative integer or PY_SSIZE_T_MAX for a positive integer.

boolean PyIndex_Check(PyObject *o); // or bool_or_fail ?
// Returns True if o is an index integer (has the nb_index slot of the tp_as_number structure filled in).
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.