Slices and Views
================

    >>> from qitensor import qubit
    >>> ha = qubit('a')
    >>> hb = qubit('b')
    >>> ha * hb
    |a,b>
    >>> x = (ha * hb).array()
    >>> x
    HilbertArray(|a,b>,
    array([[ 0.+0.j,  0.+0.j],
           [ 0.+0.j,  0.+0.j]]))

You can use numpy style indexes:

    >>> x[0, 0]
    0j

Or you can index using a dictionary:

    >>> x[{ ha: 0, hb: 0 }]
    0j

An incomplete index set returns a slice:

    >>> y = x[{ ha: 0 }]
    >>> y
    HilbertArray(|b>,
    array([ 0.+0.j,  0.+0.j]))

As in numpy, slices are views and so tie to the source array:
(note: y = [1, 2] would untie y)

    >>> y[:] = [1, 2]
    >>> y
    HilbertArray(|b>,
    array([ 1.+0.j,  2.+0.j]))
    >>> x
    HilbertArray(|a,b>,
    array([[ 1.+0.j,  2.+0.j],
           [ 0.+0.j,  0.+0.j]]))

This provides a convenient way to fill arrays:

    >>> x[{ ha: 1 }] = [3, 4]
    >>> x
    HilbertArray(|a,b>,
    array([[ 1.+0.j,  2.+0.j],
           [ 3.+0.j,  4.+0.j]]))

numpy style slices work the same, except it may not always be clear which axes
go to which component spaces:

    >>> x[0, :]
    HilbertArray(|b>,
    array([ 1.+0.j,  2.+0.j]))
    >>> x[:, 0]
    HilbertArray(|a>,
    array([ 1.+0.j,  3.+0.j]))

The .H property turns a ket space into a bra space (and vice versa):

    >>> ha.H
    <a|
    >>> ha.H.H
    |a>
    >>> (ha*hb).H
    <a,b|
    >>> ha * hb.H
    |a><b|

The .O property is a shortcut for (self * self.H).

    >>> (ha * hb).O
    |a,b><a,b|

To index a bra space:

    >>> x = ha.O.array()
    >>> x
    HilbertArray(|a><a|,
    array([[ 0.+0.j,  0.+0.j],
           [ 0.+0.j,  0.+0.j]]))
    >>> x[{ ha: 0, ha.H: 1 }] = 5
    >>> x
    HilbertArray(|a><a|,
    array([[ 0.+0.j,  5.+0.j],
           [ 0.+0.j,  0.+0.j]]))

The .space attribute gives the space for an array.

    >>> x.space
    |a><a|

Spaces of larger dimension are supported.

    >>> from qitensor import qudit
    >>> hc = qudit('c', 3)
    >>> hc.array()
    HilbertArray(|c>,
    array([ 0.+0.j,  0.+0.j,  0.+0.j]))

It is also possible to index using something other than natural numbers.

    >>> from qitensor import indexed_space
    >>> hd = indexed_space('d', ['up', 'down'])
    >>> x = hd.array([5, 7])
    >>> x['up']
    (5+0j)
    >>> y = (ha * hd.H).array([[1, 2], [3, 4]])
    >>> y
    HilbertArray(|a><d|,
    array([[ 1.+0.j,  2.+0.j],
           [ 3.+0.j,  4.+0.j]]))
    >>> y[{ ha: 1, hd.H: 'down' }]
    (4+0j)