parrotcode: Complex Numbers PMC Class Contents | PMCs

# NAME

src/pmc/complex.pmc - Complex Numbers PMC Class

# DESCRIPTION

`Complex` provides a representation of complex numbers. It handles string parsing/generating and basic mathematical operations.

## Functions

`static void complex_parse_string(Interp *interpreter, FLOATVAL *re, FLOATVAL *im, STRING *value)`

Parses the string in `value` to produce a complex number, represented by the real (`*re`) and imaginary (`*im`) parts. Raises an exception if it cannot understand the string. The string should be of the form `a+bi` with optional spaces around `+` and before `i`. You can also use `j` instead of `i`.

`static FLOATVAL *complex_locate_keyed_num(Interp *interpreter, PMC *self, STRING *key)`

Interpret the string `key`; valid keys are `real` and `imag`, representing the real and imaginary parts of the complex number.

`PMC *instantiate(PMC *sig)`

Create a new complex PMC with passed arguments according to pdd03.

`void *invoke(void *next)`

Pythonic object constructor. SELF is a Complex Class object. Return a new `complex` object according to 2.1. Built-in Functions.

## Methods

`void init()`

Initializes the complex number with the value 0+0i.

`void init_pmc (PMC *initializer)`

Initializes the complex number with the specified values. (not implemented)

`void destroy ()`

Cleans up.

`PMC *clone ()`

Creates an identical copy of the complex number.

`INTVAL get_integer ()`

Returns the modulus of the complex number as an integer.

`FLOATVAL get_number ()`

Returns the modulus of the complex number.

`STRING *get_string ()`

Returns the complex number as a string in the form `a+bi`.

`INTVAL get_bool ()`

Returns true if the complex number is non-zero.

`INTVAL get_integer_keyed (PMC *key)`

`INTVAL get_integer_keyed_str (STRING *key)`

`FLOATVAL get_number_keyed (PMC *key)`

`FLOATVAL get_number_keyed_str (STRING *key)`

`PMC *get_pmc_keyed (PMC *key)`

`PMC *get_pmc_keyed_str (STRING *key)`

Returns the requested number (real part for `real` and imaginary for `imag`).

`PMC *get_pmc_keyed_int (INTVAL key)`

Returns the requested number (real part for `0` and imaginary for `1`).

`FLOATVAL get_number_keyed_int(INTVAL key)`

Quick hack to emulate get_real() and get_imag():

```  key = 0 ... get real part
key = 1 ... get imag part```
`void set_number_keyed_int(INTVAL key, FLOATVAL v)`

Set real or imag depending on key

`void set_string_native (STRING *value)`

Parses the string `value` into a complex number; raises an exception on failure.

`void set_pmc (PMC *value)`

if `value` is a Complex PMC then the complex number is set to its value; otherwise `value`'s string representation is parsed with `set_string_native()`.

`void set_integer_native (INTVAL value)`

`void set_number_native (FLOATVAL value)`

Sets the real part of the complex number to `value` and the imaginary part to `0.0`

`void set_integer_keyed (PMC *key, INTVAL value)`

`void set_integer_keyed_str (STRING *key, INTVAL value)`

`void set_number_keyed (PMC *key, FLOATVAL value)`

`void set_number_keyed_str (STRING *key, FLOATVAL value)`

`void set_pmc_keyed (PMC *key, PMC *value)`

`void set_pmc_keyed_str (STRING *key, PMC *value)`

Sets the requested number (real part for `real` and imaginary for `imag`) to `value`.

`PMC *add (PMC *value, PMC *dest)`

`PMC *add_int (INTVAL value, PMC *dest)`

`PMC *add_float (FLOATVAL value, PMC *dest)`

Adds `value` to the complex number, placing the result in `dest`.

`PMC *subtract (PMC *value, PMC *dest)`

`PMC *subtract_int (INTVAL value, PMC *dest)`

`PMC *subtract_float (FLOATVAL value, PMC *dest)`

Subtracts `value` from the complex number, placing the result in `dest`.

`PMC *multiply (PMC *value, PMC *dest)`

`PMC *multiply_int (INTVAL value, PMC *dest)`

`PMC *multiply_float (FLOATVAL value, PMC *dest)`

Multiplies the complex number with `value`, placing the result in `dest`.

`void i_multiply (PMC *value)`

`void i_multiply_int (INTVAL value)`

`void i_multiply_float (FLOATVAL value)`

Multiplies the complex number SELF inplace with `value`.

`PMC *divide (PMC *value, PMC *dest)`

`PMC *divide_int (INTVAL value, PMC *dest)`

`PMC *divide_float (FLOATVAL value, PMC *dest)`

Divide the complex number by `value`, placing the result in `dest`.

`void i_divide (PMC *value, PMC *dest)`

`void i_divide_int (INTVAL value, PMC *dest)`

`void i_divide_float (FLOATVAL value, PMC *dest)`

Divide the complex number `SELF` by `value` inplace.

TODO divide by zero exception

`PMC *neg(PMC *dest)`

`void neg()`

Set `dest` to the negated value of `SELF`.

`INTVAL is_equal (PMC *value)`

Compares the complex number with `value` and returns true if they are equal.

`PMC *absolute(PMC *dest)`

`void i_absolute()`

Sets `dest` to the absolute value of SELF that is the distance from (0.0).

`METHOD PMC *ln()`

Returns the natural logorithm of SELF.

`METHOD PMC *exp()`

Returns e ^ SELF.

`METHOD PMC *sin()`

`METHOD PMC *cos()`

`METHOD PMC *tan()`

`METHOD PMC *csc()`

`METHOD PMC *sec()`

`METHOD PMC *cot()`

Returns `FUNC`(SELF).

`METHOD PMC *asin()`

`METHOD PMC *acos()`

`METHOD PMC *atan()`

`METHOD PMC *acsc()`

`METHOD PMC *asec()`

`METHOD PMC *acot()`

Returns the inverse function of SELF.

`METHOD PMC *sinh()`

Returns the arctangent of SELF.

`METHOD PMC *cosh()`

Returns the arcsine of SELF.

`METHOD PMC *tanh()`

Returns the arccosine of SELF.

`METHOD PMC *asinh()`

`METHOD PMC *acosh()`

`METHOD PMC *atanh()`

`METHOD PMC *acsch()`

`METHOD PMC *asech()`

`METHOD PMC *acoth()`

The inverse hyperbolic functions. Currently all broken, but for `func(a+bi) = c+di`, `|c|` and `|d|` will be correct, confusingly enough.

`PMC *pow(PMC *value, PMC *dest)`

Return SELF to the `value`th power and return result in `dest`.

`METHOD PMC *sqrt()`

Return the square root of SELF.