# week 4 - Sparse Matrix Inequalities

This week I worked on adding support for inequalities to sparse matrices. The pull request is here (still pending). I also modified, the c++ routines used to produce a boolean output, pull request here. This is so these inequalities don't have to be cast to bool in python. Once both of these are accepted the inequalities will be using the c++ routines that produce boolean output.

These are separate pull requests but they are related and one will need to be rebased once the other is accepted. Or I may combine them.

Each of the four basic inequalities has its own particular quirks which make it more or less efficient with sparse matrices. Here we consider `A` to be a sparse matrix. The cases where `B` is a scalar, or sparse are considered. (By scalar we effectively mean a matrix the same size as `A` with every element as the scalar value `B`.

#### `A < B`

For scalar B, this operation is only efficient if `B < 0` otherwise the resulting matrix will be dense.

For sparse `A` and `B` this is also efficient.

#### `A > B`

For scalar `B` the efficiency is the opposite of the less than operator. That is `B > 0` has efficient output. Similarly to `<` this operation is efficient with other sparse matrices.

#### `A <= B`

This operation is pretty much useless. The only case which make this efficient is when `B < 0`. But this case is already covered by `<`, and `<` can be used efficiently with sparse matrices. So why use `<=`? I'll discuss the pros and cons of having these non-strict inequalities in a moment.

Another disadvantage of non strict inequalities like these is that they raies `NotImplementedError` when comparing with 0. This is because of the nature of the c++ routines. When comparing every pair of elements they don't consider cases where both are zero.

#### `A >= B`

Like `<=` this operation is only efficient for one case, when `B > 0`. And also like `<=`, it is not very useful.

### Why have non strict inequalities?

I can't really think of uses for `>=` and `<=` but they might exist, I added them because they were easy to implement once I had done `>` and `<`. In practice, they don't slow the usage down. But removing non - strict inequalities removes 24,990 lines of code.

## Implementation

The inequality operations are implemented as c++ routines, these are wrapped to provide a python interface using SWIG, then the various inequalities are added appropriately.

### C++

The inequalities routines were implemented by reusing existing routines like `csr_binop_csr`. Overrides for inequalities had to be added to `complex_wrapper.h` too.

The binop routines had to altered, another class was added to their templates, `T2`, for the type of data out. In theory this could be something other than bool.

### SWIG

To handle boolean output data a new swig macro was added to create typemaps that have `npy_bool_wrapper` as this output class. I then use these to instantiate the boolean operations.

### Python

Here the associated python special methods corresponding to the inequalities were added in `compressed.py`. These operations can be used with a scalar, dense, or sparse matrix. Numpy style broadcasting is not implemented.

To produce a bool output by default for boolean comparisons, I altered the `_binopt` function to pass the c++ routines a matrix to use for output with a bool dtype.

## Problems

When testing the inequalities with dense matrices, I could not get the proper behavior with a dense matrix on the left hand side. Previously, with `!=` and `==` I modified the `__bool__` method but that did not work in this case. This is because of the same problem I will be dealing with in the next stage of my proposal, interactions with numpy ufuncs.

## Comments

Comments powered by Disqus