Operators and solvers for high-performance computing.

## Project description

The PyOperators package defines operators and solvers for high-performance computing. These operators are multi-dimensional functions with optimised and controlled memory management. If linear, they behave like matrices with a sparse storage footprint.

## Getting started

To define an operator, one needs to define a direct function which will replace the usual matrix-vector operation:

```>>> def f(x, out):
...     out[...] = 2 * x
```

Then, you can instantiate an Operator:

```>>> A = pyoperators.Operator(direct=f, flags='symmetric')
```

An alternative way to define an operator is to define a subclass:

```>>> from pyoperators import flags, Operator
... @flags.symmetric
... class MyOperator(Operator):
...     def direct(x, out):
...         out[...] = 2 * x
...
... A = MyOperator()
```

This operator does not have an explicit shape, it can handle inputs of any shape:

```>>> A(np.ones(5))
array([ 2.,  2.,  2.,  2.,  2.])
>>> A(np.ones((2,3)))
array([[ 2.,  2.,  2.],
[ 2.,  2.,  2.]])
```

By setting the symmetric flag, we ensure that A’s transpose is A:

```>>> A.T is A
True
```

For non-explicit shape operators, we get the corresponding dense matrix by specifying the input shape:

```>>> A.todense(shapein=2)
array([[2, 0],
[0, 2]])
```

Operators do not have to be linear. Many operators are already predefined, such as the IdentityOperator, the DiagonalOperator or the nonlinear ClipOperator.

The previous A matrix could be defined more easily like this:

```>>> from pyoperators import I
>>> A = 2 * I
```

where I is the identity operator with no explicit shape.

Operators can be combined together by addition, element-wise multiplication or composition. Note that the operator * stands for matrix multiplication if the two operators are linear, or for element-wise multiplication otherwise:

```>>> from pyoperators import I, DiagonalOperator
>>> B = 2 * I + DiagonalOperator(range(3))
>>> B.todense()
array([[2, 0, 0],
[0, 3, 0],
[0, 0, 4]])
```

Algebraic rules can easily be attached to operators. They are used to simplify expressions to speed up their execution. The B Operator has been reduced to:

```>>> B
DiagonalOperator(array([2, ..., 4], dtype=int64), broadcast='disabled', dtype=int64, shapein=3, shapeout=3)
```

Many simplifications are available. For instance:

```>>> from pyoperators import Operator
>>> C = Operator(flags='idempotent,linear')
>>> C * C is C
True
>>> D = Operator(flags='involutary')
>>> D(D)
IdentityOperator()
```

## Requirements

List of requirements:

• python 2.6
• numpy >= 1.6
• scipy >= 0.9

Optional requirements:

• numexpr (>= 2.0 is better)
• PyWavelets : wavelet transforms

## Release historyRelease notifications

0.13.16

0.13.15

0.13.14

0.13.13.post04

0.13.13

0.13.12

0.13.11

0.13.10

0.13.9

0.13.8

0.13.7

0.13.6.post06

0.13.6.post05

0.13.6.post04

0.13.6

0.13.5

0.13.4.post01

0.13.4

0.13.3

0.13.2

0.13.1

0.13

0.12.14

0.12.13

0.12.12

0.12.11

0.12.9

0.12.8

0.12.7

0.12.6

0.12.5

This version

0.12.4

0.12.3

0.12.2

0.12.1

0.12

0.11.1

0.11

0.10.2

0.10.1

0.10

0.9

0.8.2

0.7.3

0.7.2

0.7.1

0.7

0.6.3

0.6.2

0.6.1

0.6

0.5

0.4

0.3

0.2

0.1

0.12.8-dirty

0.11.dev11-g64ac6