#######################################################

# Copyright (c) 2019, ArrayFire

# All rights reserved.

#

# This file is distributed under 3-clause BSD license.

# The complete license agreement can be obtained at:

# http://arrayfire.com/licenses/BSD-3-Clause

########################################################

"""

Array class and helper functions.

"""

import inspect

import os

from .base import BaseArray

from .bcast import _bcast_var

from .index import Index, ParallelRange, _Index4

from .library import backend, safe_call

from .library import (

Dtype, Source, c_bool_t, c_char_ptr_t, c_dim_t, c_double_t, c_int_t, c_longlong_t, c_pointer, c_size_t, c_uint_t,

c_ulonglong_t, c_void_ptr_t)

from .util import (

_is_number, dim4, dim4_to_tuple, implicit_dtype, to_c_type, to_dtype, to_str, to_typecode, to_typename)

_is_running_in_py_charm = "PYCHARM_HOSTED" in os.environ

_display_dims_limit = None

def set_display_dims_limit(*dims):

"""

Sets the dimension limit after which array's data won't get

presented to the result of str(arr).

Default is None, which means there is no limit.

Parameters

----------

*dims : dimension limit args

Example

-------

set_display_dims_limit(10, 10, 10, 10)

"""

global _display_dims_limit

_display_dims_limit = dims

def get_display_dims_limit():

"""

Gets the dimension limit after which array's data won't get

presented to the result of str(arr).

Default is None, which means there is no limit.

Returns

-----------

- tuple of the current limit

- None is there is no limit

Example

-------

get_display_dims_limit()

# None

set_display_dims_limit(10, 10, 10, 10)

get_display_dims_limit()

# (10, 10, 10, 10)

"""

return _display_dims_limit

def _in_display_dims_limit(dims):

if _is_running_in_py_charm:

return False

if _display_dims_limit is not None:

limit_len = len(_display_dims_limit)

dim_len = len(dims)

if dim_len > limit_len:

return False

for i in range(dim_len):

if dims[i] > _display_dims_limit[i]:

return False

return True

def _create_array(buf, numdims, idims, dtype, is_device):

out_arr = c_void_ptr_t(0)

c_dims = dim4(idims[0], idims[1], idims[2], idims[3])

if not is_device:

safe_call(backend.get().af_create_array(

c_pointer(out_arr), c_void_ptr_t(buf), numdims, c_pointer(c_dims), dtype.value))

else:

safe_call(backend.get().af_device_array(

c_pointer(out_arr), c_void_ptr_t(buf), numdims, c_pointer(c_dims), dtype.value))

return out_arr

def _create_strided_array(buf, numdims, idims, dtype, is_device, offset, strides):

out_arr = c_void_ptr_t(0)

c_dims = dim4(idims[0], idims[1], idims[2], idims[3])

if offset is None:

offset = 0

offset = c_dim_t(offset)

if strides is None:

strides = (1, idims[0], idims[0]*idims[1], idims[0]*idims[1]*idims[2])

while len(strides) < 4:

strides = strides + (strides[-1],)

strides = dim4(strides[0], strides[1], strides[2], strides[3])

if is_device:

location = Source.device

else:

location = Source.host

safe_call(backend.get().af_create_strided_array(

c_pointer(out_arr), c_void_ptr_t(buf), offset, numdims, c_pointer(c_dims), c_pointer(strides), dtype.value,

location.value))

return out_arr

def _create_empty_array(numdims, idims, dtype):

out_arr = c_void_ptr_t(0)

if numdims == 0:

return out_arr

c_dims = dim4(idims[0], idims[1], idims[2], idims[3])

safe_call(backend.get().af_create_handle(c_pointer(out_arr), numdims, c_pointer(c_dims), dtype.value))

return out_arr

def constant_array(val, d0, d1=None, d2=None, d3=None, dtype=Dtype.f32):

"""

Internal function to create a C array. Should not be used externall.

"""

if not isinstance(dtype, c_int_t):

if isinstance(dtype, int):

dtype = c_int_t(dtype)

elif isinstance(dtype, Dtype):

dtype = c_int_t(dtype.value)

else:

raise TypeError("Invalid dtype")

out = c_void_ptr_t(0)

dims = dim4(d0, d1, d2, d3)

if isinstance(val, complex):

c_real = c_double_t(val.real)

c_imag = c_double_t(val.imag)

if dtype.value != Dtype.c32.value and dtype.value != Dtype.c64.value:

dtype = Dtype.c32.value

safe_call(backend.get().af_constant_complex(c_pointer(out), c_real, c_imag, 4, c_pointer(dims), dtype))

elif dtype.value == Dtype.s64.value:

c_val = c_longlong_t(val.real)

safe_call(backend.get().af_constant_long(c_pointer(out), c_val, 4, c_pointer(dims)))

elif dtype.value == Dtype.u64.value:

c_val = c_ulonglong_t(val.real)

safe_call(backend.get().af_constant_ulong(c_pointer(out), c_val, 4, c_pointer(dims)))

else:

c_val = c_double_t(val)

safe_call(backend.get().af_constant(c_pointer(out), c_val, 4, c_pointer(dims), dtype))

return out

def _binary_func(lhs, rhs, c_func):

out = Array()

other = rhs

if _is_number(rhs):

ldims = dim4_to_tuple(lhs.dims())

rty = implicit_dtype(rhs, lhs.type())

other = Array()

other.arr = constant_array(rhs, ldims[0], ldims[1], ldims[2], ldims[3], rty.value)

elif not isinstance(rhs, Array):

raise TypeError("Invalid parameter to binary function")

safe_call(c_func(c_pointer(out.arr), lhs.arr, other.arr, _bcast_var.get()))

return out

def _binary_funcr(lhs, rhs, c_func):

out = Array()

other = lhs

if _is_number(lhs):

rdims = dim4_to_tuple(rhs.dims())

lty = implicit_dtype(lhs, rhs.type())

other = Array()

other.arr = constant_array(lhs, rdims[0], rdims[1], rdims[2], rdims[3], lty.value)

elif not isinstance(lhs, Array):

raise TypeError("Invalid parameter to binary function")

c_func(c_pointer(out.arr), other.arr, rhs.arr, _bcast_var.get())

return out

def _ctype_to_lists(ctype_arr, dim, shape, offset=0):

if dim == 0:

return list(ctype_arr[offset: offset + shape[0]])

dim_len = shape[dim]

res = [[]] * dim_len

for n in range(dim_len):

res[n] = _ctype_to_lists(ctype_arr, dim - 1, shape, offset)

offset += shape[0]

return res

def _slice_to_length(key, dim):

tkey = [key.start, key.stop, key.step]

if tkey[0] is None:

tkey[0] = 0

elif tkey[0] < 0:

tkey[0] = dim - tkey[0]

if tkey[1] is None:

tkey[1] = dim

elif tkey[1] < 0:

tkey[1] = dim - tkey[1]

if tkey[2] is None:

tkey[2] = 1

return int(((tkey[1] - tkey[0] - 1) / tkey[2]) + 1)

def _get_info(dims, buf_len):

elements = 1

numdims = 0

if dims:

numdims = len(dims)

idims = [1]*4

for i in range(numdims):

elements *= dims[i]

idims[i] = dims[i]

elif buf_len != 0:

idims = [buf_len, 1, 1, 1]

numdims = 1

else:

raise RuntimeError("Invalid size")

return numdims, idims

def _get_indices(key):

inds = _Index4()

if isinstance(key, tuple):

n_idx = len(key)

for n in range(n_idx):

inds[n] = Index(key[n])

else:

inds[0] = Index(key)

return inds

def _get_assign_dims(key, idims):

from .algorithm import sum

dims = [1]*4

for n, _ in enumerate(idims):

dims[n] = idims[n]

if _is_number(key):

dims[0] = 1

return dims

if isinstance(key, slice):

dims[0] = _slice_to_length(key, idims[0])

return dims

if isinstance(key, ParallelRange):

dims[0] = _slice_to_length(key.S, idims[0])

return dims

if isinstance(key, BaseArray):

# If the array is boolean take only the number of nonzeros

if key.dtype() is Dtype.b8:

dims[0] = int(sum(key))

else:

dims[0] = key.elements()

return dims

if not isinstance(key, tuple):

raise IndexError("Invalid type while assigning to arrayfire.array")

n_inds = len(key)

for n in range(n_inds):

if _is_number(key[n]):

dims[n] = 1

elif isinstance(key[n], BaseArray):

# If the array is boolean take only the number of nonzeros

if key[n].dtype() is Dtype.b8:

dims[n] = int(sum(key[n]))

else:

dims[n] = key[n].elements()

elif isinstance(key[n], slice):

dims[n] = _slice_to_length(key[n], idims[n])

elif isinstance(key[n], ParallelRange):

dims[n] = _slice_to_length(key[n].S, idims[n])

else:

raise IndexError("Invalid type while assigning to arrayfire.array")

return dims

def transpose(a, conj=False):

"""

Perform the transpose on an input.

Parameters

-----------

a : af.Array

Multi dimensional arrayfire array.

conj : optional: bool. default: False.

Flag to specify if a complex conjugate needs to applied for complex inputs.

Returns

--------

out : af.Array

Containing the tranpose of `a` for all batches.

"""

out = Array()

safe_call(backend.get().af_transpose(c_pointer(out.arr), a.arr, conj))

return out

def transpose_inplace(a, conj=False):

"""

Perform inplace transpose on an input.

Parameters

-----------

a : af.Array

- Multi dimensional arrayfire array.

- Contains transposed values on exit.

conj : optional: bool. default: False.

Flag to specify if a complex conjugate needs to applied for complex inputs.

Note

-------

Input `a` needs to be a square matrix or a batch of square matrices.

"""

safe_call(backend.get().af_transpose_inplace(a.arr, conj))

class Array(BaseArray):

"""

A multi dimensional array container.

Parameters

----------

src : optional: array.array, list or C buffer. default: None.

- When `src` is `array.array` or `list`, the data is copied to create the Array()

- When `src` is None, an empty buffer is created.

dims : optional: tuple of ints. default: (0,)

- When using the default values of `dims`, the dims are caclulated as `len(src)`

dtype: optional: str or arrayfire.Dtype. default: None.

- if str, must be one of the following:

- 'f' for float

- 'd' for double

- 'b' for bool

- 'B' for unsigned char

- 'h' for signed 16 bit integer

- 'H' for unsigned 16 bit integer

- 'i' for signed 32 bit integer

- 'I' for unsigned 32 bit integer

- 'l' for signed 64 bit integer

- 'L' for unsigned 64 bit integer

- 'F' for 32 bit complex number

- 'D' for 64 bit complex number

- if arrayfire.Dtype, must be one of the following:

- Dtype.f32 for float

- Dtype.f64 for double

- Dtype.b8 for bool

- Dtype.u8 for unsigned char

- Dtype.s16 for signed 16 bit integer

- Dtype.u16 for unsigned 16 bit integer

- Dtype.s32 for signed 32 bit integer

- Dtype.u32 for unsigned 32 bit integer

- Dtype.s64 for signed 64 bit integer

- Dtype.u64 for unsigned 64 bit integer

- Dtype.c32 for 32 bit complex number

- Dtype.c64 for 64 bit complex number

- if None, Dtype.f32 is assumed

Attributes

-----------

arr: ctypes.c_void_p

ctypes variable containing af_array from arrayfire library.

Examples

--------

Creating an af.Array() from array.array()

>>> import arrayfire as af

>>> import array

>>> a = array.array('f', (1, 2, 3, 4))

>>> b = af.Array(a, (2,2))

>>> af.display(b)

[2 2 1 1]

1.0000 3.0000

2.0000 4.0000

Creating an af.Array() from a list

>>> import arrayfire as af

>>> import array

>>> a = [1, 2, 3, 4]

>>> b = af.Array(a)

>>> af.display(b)

[4 1 1 1]

1.0000

2.0000

3.0000

4.0000

Creating an af.Array() from numpy.array()

>>> import numpy as np

>>> import arrayfire as af

>>> a = np.random.random((2,2))

>>> a

array([[ 0.33042524, 0.36135449],

[ 0.86748649, 0.42199135]])

>>> b = af.Array(a.ctypes.data, a.shape, a.dtype.char)

>>> af.display(b)

[2 2 1 1]

0.3304 0.8675

0.3614 0.4220

Note

-----

- The class is currently limited to 4 dimensions.

- arrayfire.Array() uses column major format.

- numpy uses row major format by default which can cause issues during conversion

"""

# Numpy checks this attribute to know which class handles binary builtin operations, such as __add__.

# Setting to such a high value should make sure that arrayfire has priority over

# other classes, ensuring that e.g. numpy.float32(1)*arrayfire.randu(3) is handled by

# arrayfire's __radd__() instead of numpy's __add__()

__array_priority__ = 30

def __init__(self, src=None, dims=None, dtype=None, is_device=False, offset=None, strides=None):

super().__init__()

buf = None

buf_len = 0

if dtype is not None:

if isinstance(dtype, str):

type_char = dtype

else:

type_char = to_typecode[dtype.value]

else:

type_char = None

_type_char = 'f'

if src is not None:

if isinstance(src, Array):

safe_call(backend.get().af_retain_array(c_pointer(self.arr), src.arr))

return

host = __import__("array")

if isinstance(src, host.array):

buf, buf_len = src.buffer_info()

_type_char = src.typecode

numdims, idims = _get_info(dims, buf_len)

elif isinstance(src, list):

tmp = host.array('f', src)

buf, buf_len = tmp.buffer_info()

_type_char = tmp.typecode

numdims, idims = _get_info(dims, buf_len)

elif isinstance(src, (c_void_ptr_t, int)):

buf = src if not isinstance(src, c_void_ptr_t) else src.value

numdims, idims = _get_info(dims, buf_len)

elements = 1

for dim in idims:

elements *= dim

if elements == 0:

raise RuntimeError("Expected dims when src is data pointer")

if type_char is None:

raise TypeError("Expected type_char when src is data pointer")

_type_char = type_char

else:

raise TypeError("src is an object of unsupported class")

if type_char is not None and type_char != _type_char:

raise TypeError("Can not create array of requested type from input data type")

if offset is None and strides is None:

self.arr = _create_array(buf, numdims, idims, to_dtype[_type_char], is_device)

else:

self.arr = _create_strided_array(buf, numdims, idims, to_dtype[_type_char], is_device, offset, strides)

else:

if type_char is None:

type_char = 'f'

numdims = len(dims) if dims else 0

idims = [1] * 4

for n in range(numdims):

idims[n] = dims[n]

self.arr = _create_empty_array(numdims, idims, to_dtype[type_char])

def as_type(self, ty):

"""

Cast current array to a specified data type

Parameters

----------

ty : Return data type

"""

from .arith import cast

return cast(self, ty)

def copy(self):

"""

Performs a deep copy of the array.

Returns

-------

out: af.Array()

An identical copy of self.

"""

out = Array()

safe_call(backend.get().af_copy_array(c_pointer(out.arr), self.arr))

return out

def __del__(self):

"""

Release the C array when going out of scope

"""

if not self.arr.value:

return

backend.get().af_release_array(self.arr)

self.arr.value = 0

def device_ptr(self):

"""

Return the device pointer exclusively held by the array.

Returns

--------

ptr : int

Contains location of the device pointer

Note

----

- This can be used to integrate with custom C code and / or PyCUDA or PyOpenCL.

- Implies `af.device.lock_array()`. The device pointer of `a` is not freed by memory

manager until `unlock_device_ptr()` is called.

- No other arrays will share the same device pointer.

- A copy of the memory is done if multiple arrays share the same memory or the array

is not the owner of the memory.

- In case of a copy the return value points to the newly allocated memory which is

now exclusively owned by the array.

"""

ptr = c_void_ptr_t(0)

backend.get().af_get_device_ptr(c_pointer(ptr), self.arr)

return ptr.value

def raw_ptr(self):

"""

Return the device pointer held by the array.

Returns

--------

ptr : int

Contains location of the device pointer

Note

----

- This can be used to integrate with custom C code and / or PyCUDA or PyOpenCL.

- No mem copy is peformed, this function returns the raw device pointer.

- This pointer may be shared with other arrays. Use this function with caution.

- In particular the JIT compiler will not be aware of the shared arrays.

- This results in JITed operations not being immediately visible through the other array.

"""

ptr = c_void_ptr_t(0)

backend.get().af_get_raw_ptr(c_pointer(ptr), self.arr)

return ptr.value

def offset(self):

"""

Return the offset, of the first element relative to the raw pointer.

Returns

--------

offset : int

The offset in number of elements

"""

offset = c_dim_t(0)

safe_call(backend.get().af_get_offset(c_pointer(offset), self.arr))

return offset.value

def strides(self):

"""

Return the distance in bytes between consecutive elements for each dimension.

Returns

--------

strides : tuple

The strides for each dimension

"""

s0 = c_dim_t(0)

s1 = c_dim_t(0)

s2 = c_dim_t(0)

s3 = c_dim_t(0)

safe_call(backend.get().af_get_strides(c_pointer(s0), c_pointer(s1), c_pointer(s2), c_pointer(s3), self.arr))

strides = (s0.value, s1.value, s2.value, s3.value)

return strides[:self.numdims()]

def elements(self):

"""

Return the number of elements in the array.

"""

num = c_dim_t(0)

safe_call(backend.get().af_get_elements(c_pointer(num), self.arr))

return num.value

def __len__(self):

return self.elements()

def allocated(self):

"""

Returns the number of bytes allocated by the memory manager for the array.

"""

num = c_size_t(0)

safe_call(backend.get().af_get_allocated_bytes(c_pointer(num), self.arr))

return num.value

def dtype(self):

"""

Return the data type as a arrayfire.Dtype enum value.

"""

dty = c_int_t(Dtype.f32.value)

safe_call(backend.get().af_get_type(c_pointer(dty), self.arr))

return to_dtype[to_typecode[dty.value]]

def type(self):

"""

Return the data type as an int.

"""

return self.dtype().value

@property

def T(self):

"""

Return the transpose of the array

"""

return transpose(self, False)

@property

def H(self):

"""

Return the hermitian transpose of the array

"""

return transpose(self, True)

def dims(self):

"""

Return the shape of the array as a tuple.

"""

d0 = c_dim_t(0)

d1 = c_dim_t(0)

d2 = c_dim_t(0)

d3 = c_dim_t(0)

safe_call(backend.get().af_get_dims(c_pointer(d0), c_pointer(d1), c_pointer(d2), c_pointer(d3), self.arr))

dims = (d0.value, d1.value, d2.value, d3.value)

return dims[:self.numdims()]

@property

def shape(self):

"""

The shape of the array

"""

return self.dims()

def numdims(self):

"""

Return the number of dimensions of the array.

"""

nd = c_uint_t(0)

safe_call(backend.get().af_get_numdims(c_pointer(nd), self.arr))

return nd.value

def is_empty(self):

"""

Check if the array is empty i.e. it has no elements.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_empty(c_pointer(res), self.arr))

return res.value

def is_scalar(self):

"""

Check if the array is scalar i.e. it has only one element.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_scalar(c_pointer(res), self.arr))

return res.value

def is_row(self):

"""

Check if the array is a row i.e. it has a shape of (1, cols).

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_row(c_pointer(res), self.arr))

return res.value

def is_column(self):

"""

Check if the array is a column i.e. it has a shape of (rows, 1).

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_column(c_pointer(res), self.arr))

return res.value

def is_vector(self):

"""

Check if the array is a vector i.e. it has a shape of one of the following:

- (rows, 1)

- (1, cols)

- (1, 1, vols)

- (1, 1, 1, batch)

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_vector(c_pointer(res), self.arr))

return res.value

def is_sparse(self):

"""

Check if the array is a sparse matrix.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_sparse(c_pointer(res), self.arr))

return res.value

def is_complex(self):

"""

Check if the array is of complex type.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_complex(c_pointer(res), self.arr))

return res.value

def is_real(self):

"""

Check if the array is not of complex type.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_real(c_pointer(res), self.arr))

return res.value

def is_double(self):

"""

Check if the array is of double precision floating point type.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_double(c_pointer(res), self.arr))

return res.value

def is_single(self):

"""

Check if the array is of single precision floating point type.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_single(c_pointer(res), self.arr))

return res.value

def is_half(self):

"""

Check if the array is of half floating point type (fp16).

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_half(c_pointer(res), self.arr))

return res.value

def is_real_floating(self):

"""

Check if the array is real and of floating point type.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_realfloating(c_pointer(res), self.arr))

return res.value

def is_floating(self):

"""

Check if the array is of floating point type.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_floating(c_pointer(res), self.arr))

return res.value

def is_integer(self):

"""

Check if the array is of integer type.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_integer(c_pointer(res), self.arr))

return res.value

def is_bool(self):

"""

Check if the array is of type b8.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_bool(c_pointer(res), self.arr))

return res.value

def is_linear(self):

"""

Check if all elements of the array are contiguous.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_linear(c_pointer(res), self.arr))

return res.value

def is_owner(self):

"""

Check if the array owns the raw pointer or is a derived array.

"""

res = c_bool_t(False)

safe_call(backend.get().af_is_owner(c_pointer(res), self.arr))

return res.value

def __add__(self, other):

"""

Return self + other.

"""

return _binary_func(self, other, backend.get().af_add)

def __iadd__(self, other):

"""

Perform self += other.

"""

self = _binary_func(self, other, backend.get().af_add)

return self

def __radd__(self, other):

"""

Return other + self.

"""

return _binary_funcr(other, self, backend.get().af_add)

def __sub__(self, other):

"""

Return self - other.

"""

return _binary_func(self, other, backend.get().af_sub)

def __isub__(self, other):

"""

Perform self -= other.

"""

self = _binary_func(self, other, backend.get().af_sub)

return self

def __rsub__(self, other):

"""

Return other - self.

"""

return _binary_funcr(other, self, backend.get().af_sub)

def __mul__(self, other):

"""

Return self * other.

"""

return _binary_func(self, other, backend.get().af_mul)

def __imul__(self, other):

"""

Perform self *= other.

"""

self = _binary_func(self, other, backend.get().af_mul)

return self

def __rmul__(self, other):

"""

Return other * self.

"""

return _binary_funcr(other, self, backend.get().af_mul)

def __truediv__(self, other):

"""

Return self / other.

"""

return _binary_func(self, other, backend.get().af_div)

def __itruediv__(self, other):

"""

Perform self /= other.

"""

self = _binary_func(self, other, backend.get().af_div)

return self

def __rtruediv__(self, other):

"""

Return other / self.

"""

return _binary_funcr(other, self, backend.get().af_div)

def __div__(self, other):

"""

Return self / other.

"""

return _binary_func(self, other, backend.get().af_div)

def __idiv__(self, other):

"""

Perform other / self.

"""

self = _binary_func(self, other, backend.get().af_div)

return self

def __rdiv__(self, other):

"""

Return other / self.

"""

return _binary_funcr(other, self, backend.get().af_div)

def __mod__(self, other):

"""

Return self % other.

"""

return _binary_func(self, other, backend.get().af_mod)

def __imod__(self, other):

"""

Perform self %= other.

"""

self = _binary_func(self, other, backend.get().af_mod)

return self

def __rmod__(self, other):

"""

Return other % self.

"""

return _binary_funcr(other, self, backend.get().af_mod)

def __pow__(self, other):

"""

Return self ** other.

"""

return _binary_func(self, other, backend.get().af_pow)

def __ipow__(self, other):

"""

Perform self **= other.

"""

self = _binary_func(self, other, backend.get().af_pow)

return self

def __rpow__(self, other):

"""

Return other ** self.

"""

return _binary_funcr(other, self, backend.get().af_pow)

def __lt__(self, other):

"""

Return self < other.

"""

return _binary_func(self, other, backend.get().af_lt)

def __gt__(self, other):

"""

Return self > other.

"""

return _binary_func(self, other, backend.get().af_gt)

def __le__(self, other):

"""

Return self <= other.