np 1.0.2
np = numpy++: numpy with added convenience functionality
License: BSD

np -- create numpy arrays as ``np[1,3,5]``, and more
====================================================

``np``  = ``numpy`` + handy tools

It's easy: start by importing ``np`` (the alias for numpy):

.. code-block:: python

    import np


Create a 1-D array: 
  
.. code-block:: python

    np[1, 3, 5]


Create a 2-D matrix:

.. code-block:: python

    np.m[1, 2, 3: 
        :4, 5, 6:
        :7, 8, 9]


For the numerical Python package ``numpy`` itself, see http://www.numpy.org/.

The idea of ``np`` is to provide a way of creating numpy arrays with a compact syntax and without an explicit function call. Making the module name ``np`` subscriptable, while still keeping it essentially an alias for numpy, does this in a clean way.

Any feedback is very welcome: ``koos.zevenhoven@aalto.fi``.

Getting Started
===============

Requirements
------------

* Works best with Python 3.5+ (Tested also with 3.4 and 2.7)
* numpy (you should install this using your python package manager like ``conda`` or ``pip``)

Installation
------------

``np`` can be installed with ``pip`` or ``pip3``:

.. code-block:: bash

    $ pip install np


or directly from the source code:

.. code-block:: bash

    $ git clone https://github.com/k7hoven/np.git
    $ cd np
    $ python setup.py install 

Basic Usage
===========

Even before the ``np`` tool, a popular style of using ``numpy`` has been to import it as ``np``:

.. code-block:: python

    >>> import numpy as np
    >>> my_array = np.array([3, 4, 5])
    >>> my_2d_array = np.array([[1, 2], [3, 4]])

The most important feature of ``np`` is to make the creation of arrays less verbose, while everything else works as before. The above code becomes:

.. code-block:: python

    >>> import np
    >>> my_array = np[3, 4, 5]
    >>> my_2d_array = np[[1, 2], [3, 4]]
    >>> my_matrix = np.m[1, 2: 3, 4]
    >>> my_matrix2 = np.m[1, 2, 3:
    ...                  :4, 5, 6:
    ...                  :7, 8, 9]
    >>> my_row_vector = np.m[1, 2, 3]


As you can see from the above example, you can create numpy arrays by subscripting the ``np`` module. Since most people would have numpy imported as ``np`` anyway, this requires no additional names to clutter the namespace. Also, the syntax ``np[1,2,3]`` resembles the syntax for ``bytes`` literals, ``b"asd"``.

The above also shows how you can use ``np.m`` and colons to easily create matrices (NxM) or row vectors (1xM).

The `np` package also provides a convenient way of ensuring something is a numpy array, that is, a shortcut to ``numpy.asarray()``:

.. code-block:: python

    >>> import np
    >>> mylist = [1, 3, 5]
    >>> mylist + [7, 9, 11]
    [1, 3, 5, 7, 9, 11]
    >>> np(mylist) + [7, 9, 11]
    array([8, 12, 16])


As an experimental feature, there are also shortcuts for giving the arrays a specific data type (numpy dtype):

.. code-block:: python

    >>> np[1, 2, 3]
    array([1, 2, 3])
    >>> np.f[1, 2, 3]
    array([ 1.,  2.,  3.])
    >>> np.f2[1, 2, 3]
    array([ 1.,  2.,  3.], dtype=float16)
    >>> np.u4[1, 2, 3]
    array([1, 2, 3], dtype=uint32)
    >>> np.c[1, 2, 3]
    array([ 1.+0.j,  2.+0.j,  3.+0.j])


Changelog
=========

1.0.0 (2017-09-20)
------------------

- Creating matrices is now even simpler::
 
    np.m[1, 2: 3, 4] == np.array([[1, 2], [3, 4]])

    np.m[1, 2:
        :3, 4] == np.array([[1, 2], [3, 4]])

    np.m[1, 2] == np.array([[1, 2]])

    np.m[1, 2].T == np.array([[1],
                              [2]])


- ``np(...)`` corresponds to ``np.asarray(...)``
- Many improvements to error handling
- Some more cleanups to type shortcuts

0.2.0 (2016-03-29)
------------------

- Quick types are now ``np.i``, ``np.f``, ``np.u``, ``np.c``, or with the 
  number of *bytes* per value appended: 
  ``np.i4`` -> int32, ``np.u2`` -> uint16, ``np.c16`` -> complex128, ...
  (still somewhat experimental)
- Removed the old np.i8 and np.ui8 which represented 8-bit types, which
  was inconsistent with short numpy dtype names which correspond to numbers of
  bytes. The rest of the bit-based shortcuts are deprecated and will be removed
  later.
- Handle Python versions >=3.5 better; now even previously imported plain numpy
  module objects become the exact same object as np. 
- Tests for all np functionality
- Ridiculously slow tests that runs the numpy test suite several times to
  make sure that np does not affect numpy functionality.
- Remove numpy from requirements and give a meaningful error instead if numpy
  is missing (i.e. install it using your package manager like conda or pip)
- Better reprs for subscriptable array creator objects and the np/numpy module.

0.1.4 (2016-01-26)
------------------

- Bug fix

0.1.2 (2015-06-17)
------------------

- Improved experimental dtype shortcuts: np.f[1,2], np.i32[1,2], etc.

0.1.1 (2015-06-17)
------------------

- PyPI-friendly readme

0.1.0 (2015-06-17)
------------------

- First distributable version
- Easy arrays such as np[[1,2],[3,4]]
- Shortcut for np.asanyarray(obj): np(obj)
- Experimental dtype shortcuts: np.f64[[1,2],[3,4]]