/**
* JNumeric - a Jython port of Numerical Java
* Current Maintainer: Daniel Lemire, Ph.D.
* (c) 1998, 1999 Timothy Hochberg, tim.hochberg@ieee.org
*
* Free software under the Python license, see http://www.python.org
* Home page: http://jnumerical.sourceforge.net
*
*/
package jnumeric;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.util.Comparator;
import org.python.core.Py;
import org.python.core.PyArray;
import org.python.core.PyComplex;
import org.python.core.PyEllipsis;
import org.python.core.PyException;
import org.python.core.PyFloat;
import org.python.core.PyIgnoreMethodTag;
import org.python.core.PyInteger;
import org.python.core.PyList;
import org.python.core.PyNone;
import org.python.core.PyObject;
import org.python.core.PySequence;
import org.python.core.PySlice;
import org.python.core.PyString;
import org.python.core.PyTuple;
import org.python.core.PyType;
import org.python.core.JyAttribute;
import org.python.core.__builtin__;
import jnumeric.*;
// TODO Fix up interface to unary ufuncs.
// TODO Fix up object behaviour (doesn't work correctly(?) with e.g, tuples).
// TODO Pow uses Math.pow for integer types -- should be fixed to use an integer
// pow.
// Strategy: define Multiarray._pow(double, double), Multiarray._pow(int, int),
// etc and use instead of
// Math.pow. (double and float cases would use math.pow). (Look at CNumeric
// umath).
/**
* The container for n-dimensional arrays.
*
* The array itself is stored as a one-dimensional array;
* the mathematical routines manipulating these arrays
* must treat it appropriately based on their shape
* and stride.
*
*/
public class PyMultiarray extends PySequence {
//
// Variables and the basic constructor for Multiarray.
// (These should only be accessed from within the Numeric (java) package.)
//
private static final long serialVersionUID = 4524353697384690762L;
/**
* Used to format arrays for str([0]) and repr([1])
*/
public static int maxLineWidth = 77;
/**
* Used to format arrays for str([0]) and repr([1])
*/
public static int precision = 8;
/**
* Used to format arrays for str([0]) and repr([1])
*/
public static boolean suppressSmall = false;
/**
* Python class of PyMultiarray.
*
* @see PyObject
*/
public static final PyType ATYPE = PyType.fromClass(PyMultiarray.class);
String docString = "PyMultiarray methods:\n" +
" astype(typecode)]\n" +
" itemsize()\n" +
" byteswapped()\n" +
" copy()\n" +
" typecode()\n" +
" iscontiguous()\n" +
" tostring()\n" +
" tolist()\n";
/**
* 1D Java array that holds array data. May be shared between arrays.
*/
Object data;
/**
* Type code of the array. Allowable types are:
* '1':Byte
* 's':Short
* 'i':Int
* 'l':Long
* 'f':Float
* 'd':Double
* 'F':ComplexFloat
* 'D':ComplexDouble
* 'O':PyObject
*/
char _typecode;
// Start, dimensions, and strides determine the structure of the array.
int start;
int[] dimensions;
int[] strides;
// Many functions work only on contiguous arrays,
// so we keep track of that here.
boolean isContiguous;
/**
* Create a multiarray object given values of instance variables.
*
* @param data The 1D array
* @param _typecode Datatype of the array
* @param start Start of the array
* @param dimensions Dimensionality
* @param strides Strides
*/
public PyMultiarray(final Object data, final char _typecode, final int start, final int[] dimensions, final int[] strides) {
super(PyMultiarray.ATYPE);
//this.javaProxy = this;
Object javaProxy = JyAttribute.getAttr(this, JyAttribute.JAVA_PROXY_ATTR);
javaProxy = JyAttribute.getAttr(this, JyAttribute.JAVA_PROXY_ATTR);
this.data = data;
this._typecode = _typecode;
this.start = start;
this.dimensions = dimensions;
this.strides = strides;
this.isContiguous = true;
this.setIsContiguous();
}
/**
* Create a multiarray object from a sequence and a type.
* @param seq Array-like
* @param typecode Datatype of the array
*/
public PyMultiarray(final PyObject seq, final char typecode) {
super(PyMultiarray.ATYPE);
//this.javaProxy = this;
Object javaProxy = JyAttribute.getAttr(this, JyAttribute.JAVA_PROXY_ATTR);
javaProxy = JyAttribute.getAttr(this, JyAttribute.JAVA_PROXY_ATTR);
final PyMultiarray a = PyMultiarray.array(seq, typecode);
this.data = a.data;
this._typecode = a._typecode;
this.start = a.start;
this.dimensions = a.dimensions;
this.strides = a.strides;
this.isContiguous = a.isContiguous;
}
/**
* Create a multiarray object from a sequence.
* @param seq Array-like
*/
public PyMultiarray(final PyObject seq) {
super(PyMultiarray.ATYPE);
//this.javaProxy = this;
Object javaProxy = JyAttribute.getAttr(this, JyAttribute.JAVA_PROXY_ATTR);
javaProxy = JyAttribute.getAttr(this, JyAttribute.JAVA_PROXY_ATTR);
final PyMultiarray a = PyMultiarray.array(seq, '\0');
this.data = a.data;
this._typecode = a._typecode;
this.start = a.start;
this.dimensions = a.dimensions;
this.strides = a.strides;
this.isContiguous = a.isContiguous;
}
/**
* Create a multiarray object from a sequence (the slow general way)
*/
private static PyMultiarray seqToMultiarray(final PyObject seq, char typecode) {
final int[] newShape = PyMultiarray.shapeOf(seq);
final PyObject[] flatData = PyMultiarray.seqToObjects(
seq,
PyMultiarray.shapeToNItems(newShape));
typecode = (typecode == '\0') ? PyMultiarray.objectsToType(flatData)
: typecode;
final PyMultiarray newArray = PyMultiarray.zeros(
PyMultiarray.shapeOf(seq),
typecode);
final int size = PyMultiarray.typeToNElements(typecode);
for (int i = 0; i < flatData.length; i++) {
Array.set(
newArray.data,
size * i,
PyMultiarray.objectToJava(flatData[i], typecode, true));
}
// Set complex elements if array is complex.
if (size == 2) {
for (int i = 0; i < flatData.length; i++) {
Array.set(
newArray.data,
size * i + 1,
PyMultiarray.objectToJava(flatData[i], typecode, false));
}
}
return newArray;
}
private static char arrayClassToType(final Class> klass) {
if (klass.isArray()) {
return PyMultiarray.arrayClassToType(klass.getComponentType());
}
return PyMultiarray.classToType(klass);
}
private static int[] arrayDataToShape(final Object data, final int depth) {
final int length = Array.getLength(data);
final Class> klass = data.getClass().getComponentType();
// If data is an array of arrays:
if (length != 0 && klass.isArray()) {
final int[] shape = PyMultiarray.arrayDataToShape(
Array.get(data, 0),
depth + 1);
shape[depth] = length;
// Verify that the array is well formed.
for (int i = 0; i < length; i++) {
final int[] shape2 = PyMultiarray.arrayDataToShape(
Array.get(data, i),
depth + 1);
if (shape.length != shape2.length) { throw Py
.ValueError("malformed array"); }
for (int j = depth + 1; j < shape.length; j++) {
if (shape[j] != shape2[j]) { throw Py
.ValueError("malformed array"); }
}
}
return shape;
}
// If data is just an array of Primitives:
final int[] shape = new int[depth + 1];
shape[depth] = length;
return shape;
}
private static int arrayDataToFlat(final Object data, final Object flat, int offset) {
final Class> klass = data.getClass().getComponentType();
final int length = Array.getLength(data);
if (klass.isArray()) {
for (int i = 0; i < length; i++) {
offset = PyMultiarray.arrayDataToFlat(
Array.get(data, i),
flat,
offset);
}
return offset;
}
System.arraycopy(data, 0, flat, offset, length);
return offset + length;
}
/**
* Create a multiarray object from a PyArray (jarray).
* Don't copy unless forced to.
*/
private static PyMultiarray arrayToMultiarray(final PyArray seq, final char typecode) {
Object data = seq.__tojava__(Object.class);
final char type = PyMultiarray.arrayClassToType(data.getClass());
final int[] shape = PyMultiarray.arrayDataToShape(data, 0);
final int[] strides = PyMultiarray.shapeToStrides(
shape,
PyMultiarray.typeToNElements(type));
if (shape.length > 1) {
final Object flat = Array.newInstance(
PyMultiarray.typeToClass(type),
PyMultiarray.shapeToNItems(shape));
PyMultiarray.arrayDataToFlat(data, flat, 0);
data = flat;
}
final PyMultiarray ma = new PyMultiarray(data, type, 0, shape, strides);
return (typecode == '\0' || typecode == type) ? ma : PyMultiarray
.array(ma, typecode);
}
//
// Multiarray creation functions.
//
/**
* Create a new multiarray from seq of type
* typecode ('\0' indicates the type should be inferred from
* seq).
* @param seq Array-like
* @param typecode Datatype of the array
* @return The new multiarray
*/
public static PyMultiarray array(final PyObject seq, final char typecode) {
if (seq instanceof PyMultiarray) {
final PyMultiarray a = (PyMultiarray) seq;
final PyMultiarray b = PyMultiarray.zeros(
a.dimensions,
(typecode == '\0') ? a._typecode : typecode);
PyMultiarray.copyAToB(a, b);
return b;
}
if (seq instanceof PyArray) {
final PyArray copyOfSeq = (PyArray) seq.__getslice__(
Py.None,
Py.None,
Py.None);
return PyMultiarray.arrayToMultiarray(copyOfSeq, typecode);
}
return PyMultiarray.seqToMultiarray(seq, typecode);
}
/**
* Create a new multiarray from seq. The type is determined by
* examining seq.
* @param seq Array-like
* @return The new multiarray
*/
public static PyMultiarray array(final PyObject seq) {
return PyMultiarray.array(seq, '\0');
}
/**
* Create a new multiarray of zeros with shape shape of type
* typecode.
* @param shape A tuple or list describing the dimensionality of the array
* (e.g., (10,) for a 10-element vector, [2, 5] for a 2 by 5 matrix))
* @param typecode Datatype of the array
* @return The new multiarray
*/
public static PyMultiarray zeros(final int[] shape, final char typecode) {
// int length = Math.max(1,
// typeToNElements(typecode)*shapeToNItems(shape));
final int length = PyMultiarray.typeToNElements(typecode)
* PyMultiarray.shapeToNItems(shape);
final Object data = Array.newInstance(
PyMultiarray.typeToClass(typecode),
length);
if (typecode == 'O') {
for (int i = 0; i < Array.getLength(data); i++) {
Array.set(data, i, Py.Zero);
}
}
final int[] strides = PyMultiarray.shapeToStrides(
shape,
PyMultiarray.typeToNElements(typecode));
return new PyMultiarray(data, typecode, 0, shape, strides);
}
/**
* Create a new multiarray of zeros with shape shape of type
* typecode.
* @param shape A tuple or list describing the dimensionality of the array
* (e.g., (10,) for a 10-element vector, [2, 5] for a 2 by 5 matrix))
* @param typecode Datatype of the array
* @return The new multiarray
*/
public static PyMultiarray zeros(final Object shape, final char typecode) {
return PyMultiarray.zeros(
PyMultiarray.objectToInts(shape, true),
typecode);
}
/**
* Create a new multiarray of zeros with shape shape with type
* inferenced from shape.
* @param shape A tuple or list describing the dimensionality of the array
* (e.g., (10,) for a 10-element vector, [2, 5] for a 2 by 5 matrix))
* @return The new multiarray
*/
public static PyMultiarray zeros(final PyObject shape) {
return PyMultiarray.zeros(
PyMultiarray.objectToInts(shape, true),
PyMultiarray.asarray(shape).typecode());
}
/**
* Create a range of numbers in [start, stop) with the given step and
* typecode.
*/
static PyMultiarray arrayRange(final double start, final double stop, final double step, final char typecode) {
final int length = Math.max(0, (int) Math.ceil((stop - start) / step));
final PyMultiarray a = PyMultiarray.zeros(new int[] { length }, 'd');
for (int i = 0; i < length; i++) {
Array.setDouble(a.data, i, i * step + start);
}
return a.astype(typecode);
}
/**
* Create a range of numbers in [start, stop) with the given step and
* typecode.
* @param start Start of the range (included)
* @param stop End of the range (not included)
* @param step Stepsize between the start and stop
* @param typecode Datatype of the array
* @return The new multiarray
*/
public static PyMultiarray arrayRange(PyObject start, PyObject stop, final PyObject step, char typecode) {
if (stop instanceof PyNone) {
stop = start;
start = Py.Zero;
}
if (typecode == '\0') {
typecode = PyMultiarray.objectsToType(new PyObject[] {
start,
stop,
step });
}
if (typecode != 'O') { return PyMultiarray.arrayRange(start.__float__()
.getValue(), stop.__float__().getValue(),
step.__float__().getValue(), typecode); }
// Treat objects specially.
final PyObject lengthObject = (stop._sub(start))._div(step);
final int length = Math.max(
0,
(int) Math.ceil(lengthObject.__float__().getValue()));
start = __builtin__.coerce(start, lengthObject).__getitem__(0);
final PyMultiarray a = PyMultiarray.zeros(new int[] { length }, 'O');
for (int i = 0; i < length; i++) {
a.set(i, start);
start = start._add(step);
}
return a;
}
/**
* Create a set of indices for use with fromFunction.
* @param o The input array
* @param typecode Datatype of the indices
* @return The set of indices
*/
public static PyMultiarray indices(final PyObject o, char typecode) {
final int[] baseShape = PyMultiarray.objectToInts(o, true);
final int[] shape = new int[baseShape.length + 1];
for (int i = 0; i < baseShape.length; i++) {
shape[i + 1] = baseShape[i];
}
shape[0] = baseShape.length;
if (typecode == '\0') {
typecode = PyMultiarray.asarray(o)._typecode;
}
final PyMultiarray result = PyMultiarray.zeros(shape, typecode);
for (int i = 0; i < baseShape.length; i++) {
final PyMultiarray subArray = PyMultiarray.swapAxes(
PyMultiarray.asarray(result.get(i)),
0,
i);
subArray.__add__(
PyMultiarray.arrayRange(0, baseShape[i], 1, typecode),
subArray);
}
return result;
}
/**
* Create an array by calling function the coordinates of each element of an
* array with the given shape.
* @param function The function to call
* @param shape A tuple or list describing the dimensionality of the array
* (e.g., (10,) for a 10-element vector, [2, 5] for a 2 by 5 matrix))
* @return The new multiarray
*/
public static PyMultiarray fromFunction(final PyObject function, final PyObject shape) {
final PyMultiarray index = PyMultiarray.indices(shape, '\0');
final PyMultiarray result = PyMultiarray.zeros(shape);
final PyMultiarray flatIndex = PyMultiarray.swapAxes(
PyMultiarray.reshape(index, new int[] {
result.dimensions.length,
-1 }),
0,
1);
final PyMultiarray flatResult = PyMultiarray.reshape(
result,
new int[] { -1 });
PyObject[] args = new PyObject[0];
final String[] keywords = new String[0];
final Class extends PyObject[]> objectArray = args.getClass();
for (int i = 0; i < flatResult.dimensions[0]; i++) {
args = (PyObject[]) ((PyMultiarray) flatIndex.get(i)).tolist()
.__tojava__(objectArray);
flatResult.set(i, function.__call__(args, keywords));
}
return result;
}
/**
* Create a 1D array from a string.
* @see #toString()
* @param s String from which to create the array
* @param type Datatype of the array
* @return The new multiarray
*/
public static PyMultiarray fromString(final String s, final char type) {
final int itemsize = PyMultiarray.typeToNBytes(type)
* PyMultiarray.typeToNElements(type);
if (s.length() % itemsize != 0) { throw Py
.ValueError("string size must be a multiple of element size"); }
Object data;
try {
data = PyMultiarray.fromByteArray(s.getBytes("ISO-8859-1"), type);
} catch (final UnsupportedEncodingException e) {
throw Py.RuntimeError("ISO-LATIN-1 encoding unavailable, can't convert from string.");
}
return new PyMultiarray(data, type, 0,
new int[] { Array.getLength(data)
/ PyMultiarray.typeToNElements(type) },
new int[] { PyMultiarray.typeToNElements(type) });
}
/**
* Return seq if it's a multiarray of type
* typecode, otherwise returns a new multiarray.
* @param seq Array-like
* @param typecode Datatype of the new array
* @return The new multiarray
*/
public static PyMultiarray asarray(final PyObject seq, final char typecode) {
if (seq instanceof PyMultiarray
&&
(typecode == '\0' || ((PyMultiarray) seq)._typecode == typecode)) {
return (PyMultiarray) seq;
}
if (seq instanceof PyArray) {
return PyMultiarray.arrayToMultiarray((PyArray) seq, typecode);
}
return PyMultiarray.array(seq, typecode);
}
/**
* Return seq if it's a multiarray, otherwise returns a new
* multiarray.
* @param seq Array-like
* @return The new multiarray
*/
public static PyMultiarray asarray(final PyObject seq) {
if (seq instanceof PyMultiarray) { return (PyMultiarray) seq; }
return PyMultiarray.array(seq);
}
/**
* Return seq if it's a contiguous multiarray, otherwise
* returns a new multiarray.
* @param seq Array-like
* @param _typecode Datatype (a single character)
* @return The new multiarray
*/
public static PyMultiarray ascontiguous(final PyObject seq, final char _typecode) {
if (seq instanceof PyMultiarray && ((PyMultiarray) (seq)).isContiguous
&&
((PyMultiarray) seq)._typecode == _typecode) { return (PyMultiarray) seq; }
return PyMultiarray.array(seq, _typecode);
}
/**
* Return seq if it's a contiguous multiarray of type
* typecode, otherwise returns a new multiarray.
* @param seq Array-like
* @return The new multiarray
*/
public static PyMultiarray ascontiguous(final PyObject seq) {
if (seq instanceof PyMultiarray && ((PyMultiarray) (seq)).isContiguous) { return (PyMultiarray) seq; }
return PyMultiarray.array(seq);
}
//
// Public multiarray methods and attributes.
//
/**
* Return the typecode.
* @return The typecode
* @see #_typecode
*/
public char typecode() {
return this._typecode;
}
/**
* Return the size (in bytes) of the items.
* @return The size (in bytes) of the items
*/
public int itemsize() {
return PyMultiarray.typeToNElements(this._typecode)
* PyMultiarray.typeToNBytes(this._typecode);
}
/**
* Return (1) if the array is contiguous, 0 otherwise.
* @return 1 if the array is contiguous, 0 otherwise
*/
public int iscontiguous() {
return this.isContiguous ? 1 : 0;
}
/**
* Return multiarray coerced to type.
*
* Note that CNumeric does the equivalent of return array(this, type) here.
* @param type The output type
* @return The new multiarray
*/
public PyMultiarray astype(final char type) {
return PyMultiarray.asarray(this, type);
}
/**
* Return multiarray data represented as a string.
* @return The string representation
*/
public String tostring() {
try {
return new String(PyMultiarray.toByteArray(
PyMultiarray.array(this).data,
this._typecode), "ISO-8859-1");
} catch (final UnsupportedEncodingException e) {
throw Py.RuntimeError("ISO-LATIN-1 encoding unavailable, can't convert to string.");
}
}
/**
* Return a multiarray with data byte swapped (little to big endian).
* @return The byte swapped multiarray
*/
public final PyMultiarray byteswapped() {
// This assumes typesize is even or 1 (it better be!).
final PyMultiarray result = PyMultiarray.array(this);
final byte[] bytes = PyMultiarray.toByteArray(
result.data,
this._typecode);
final int typesize = PyMultiarray.typeToNBytes(this._typecode);
final int swaps = typesize / 2;
for (int i = 0; i < Array.getLength(result.data); i++) {
for (int j = 0; j < swaps; j++) {
final byte temp = bytes[i * typesize + j];
bytes[i * typesize + j] = bytes[i * typesize
+ (typesize - 1 - j)];
bytes[i * typesize + (typesize - 1 - j)] = temp;
}
}
result.data = PyMultiarray.fromByteArray(bytes, this._typecode);
return result;
}
/**
* Return a copy.
* @return Multiarray copy
*/
public final PyMultiarray copy() {
return PyMultiarray.array(this);
}
/**
* Return multiarray as a Python list.
* @return Python list with the same data as the multiarray
*/
public final PyList tolist() {
if (this.dimensions.length == 0) { throw Py
.ValueError("Can't convert a 0d array to a list"); }
final PyObject[] items = new PyObject[this.dimensions[0]];
if (this.dimensions.length == 1) {
for (int i = 0; i < this.dimensions[0]; i++) {
items[i] = this.get(i);
}
} else {
for (int i = 0; i < this.dimensions[0]; i++) {
items[i] = ((PyMultiarray) this.get(i)).tolist();
}
}
return new PyList(items);
}
//
// Operations on matrices.
//
/**
* Return a reshaped multiarray (shares data with a if it is
* contiguous).
* @param o Input array
* @param shape A tuple or list describing the dimensionality of the array
* (e.g., (10,) for a 10-element vector, [2, 5] for a 2 by 5 matrix))
* @return The reshaped multiarray
*/
public static PyMultiarray reshape(final PyObject o, int[] shape) {
final PyMultiarray a = PyMultiarray.ascontiguous(o);
shape = PyMultiarray.fixedShape(
shape,
PyMultiarray.shapeToNItems(a.dimensions));
final int[] strides = PyMultiarray.shapeToStrides(
shape,
PyMultiarray.typeToNElements(a._typecode));
return new PyMultiarray(a.data, a._typecode, a.start, shape, strides);
}
/**
* Return a new array with the specified shape. The original array can have
* any total size.
* @param o Input array
* @param shape A tuple or list describing the dimensionality of the array
* (e.g., (10,) for a 10-element vector, [2, 5] for a 2 by 5 matrix))
* @return The resized multiarray
*/
public static PyMultiarray resize(final PyObject o, final int[] shape) {
final PyMultiarray a = PyMultiarray.ascontiguous(PyMultiarray.reshape(
PyMultiarray.asarray(o),
new int[] { -1 }));
final int nItems = PyMultiarray.shapeToNItems(shape);
final int nCopies = nItems / a.dimensions[0];
final int extra = nItems % a.dimensions[0];
final int nElements = PyMultiarray.typeToNElements(a._typecode);
final PyMultiarray result = PyMultiarray.zeros(shape, a._typecode);
for (int i = 0; i < nCopies; i++) {
System.arraycopy(a.data, a.start, result.data, i * a.dimensions[0]
* nElements, a.dimensions[0] * nElements);
}
System.arraycopy(a.data, a.start, result.data, nCopies
* a.dimensions[0] * nElements, extra * nElements);
return result;
}
/**
* Return a new, sorted array.
* @param o Array to be sorted
* @param axis Axis over which to sort
* @return A new, sorted array
*/
public static PyMultiarray sort(final PyObject o, final int axis) {
final PyMultiarray a = PyMultiarray.array(PyMultiarray.swapAxes(
PyMultiarray.asarray(o),
axis,
-1));
final int stride = a.dimensions[a.dimensions.length - 1];
for (int i = 0; i < Array.getLength(a.data); i += stride) {
switch (a._typecode) {
case '1':
java.util.Arrays.sort((byte[]) a.data, i, i + stride);
break;
case 's':
java.util.Arrays.sort((short[]) a.data, i, i + stride);
break;
case 'i':
java.util.Arrays.sort((int[]) a.data, i, i + stride);
break;
case 'l':
java.util.Arrays.sort((long[]) a.data, i, i + stride);
break;
case 'f':
java.util.Arrays.sort((float[]) a.data, i, i + stride);
break;
case 'd':
java.util.Arrays.sort((double[]) a.data, i, i + stride);
break;
default:
throw Py.ValueError("unsortable array type");
}
}
return PyMultiarray.swapAxes(a, axis, -1);
}
/**
* Returns the indices that would sort an array.
* @param o Input array
* @param axis Axis over which to sort
* @return The indices that would sort the array.
*/
public static PyMultiarray argSort(final PyObject o, final int axis) {
// We depend on 'a' being 'vanilla' below.
// There's a probable extra copy here though.
final PyMultiarray a = PyMultiarray.array(PyMultiarray.swapAxes(
PyMultiarray.asarray(o),
axis,
-1));
if (a._typecode == 'F' || a._typecode == 'D' || a._typecode == 'O') { throw Py
.ValueError("unsortable array type"); }
// 'data' holds the argsorted indices.
final int stride = a.dimensions[a.dimensions.length - 1];
final int size = Array.getLength(a.data);
final int data[] = new int[size];
// Create an array of Numbers tagged with indices
class IndexedArray {
Number item;
int index;
}
final IndexedArray ia[] = new IndexedArray[stride];
for (int j = 0; j < stride; j++) {
ia[j] = new IndexedArray();
}
// Create a comparator that sorts an IndexArray
final Comparator comp = new Comparator() {
public int compare(final IndexedArray o1, final IndexedArray o2) {
if (o1.item.equals(o2.item)) {
return 0;
}
final double d1 = o1.item.doubleValue();
final double d2 = o2.item.doubleValue();
if (d1 > d2) {
return 1;
}
return -1;
}
};
// Loop over all indices except the last.
for (int i = 0; i < size; i += stride) {
for (int j = 0; j < stride; j++) {
ia[j].item = (Number) Array.get(a.data, i + j);
ia[j].index = j;
}
// sort 'ia'
java.util.Arrays.sort(ia, comp);
// Load 'a' with the indices from 'ia' and change its type.
for (int j = 0; j < stride; j++) {
data[i + j] = ia[j].index;
}
}
a._typecode = 'i';
a.data = data;
return PyMultiarray.swapAxes(a, axis, -1);
}
/**
* Return a multiarray with the axes transposed according to
* perms (shares data with a).
* @param o Input array
* @param perms Axes to transpose
* @return The transposed multiarray
*/
public static PyMultiarray transpose(final PyObject o, final int[] perms) {
final PyMultiarray a = PyMultiarray.asarray(o);
final boolean[] used = new boolean[perms.length];
for (int i = 0; i < perms.length; i++) {
int axis = perms[i];
axis = (axis < 0) ? a.dimensions.length + axis : axis;
if (axis < 0 || axis >= a.dimensions.length || used[axis]) {
throw Py.ValueError("illegal permutation");
}
perms[i] = axis;
used[axis] = true;
}
final PyMultiarray ans = new PyMultiarray(
a.data,
a._typecode,
a.start,
a.dimensions.clone(),
a.strides.clone());
for (int i = 0; i < perms.length; i++) {
ans.dimensions[i] = a.dimensions[perms[i]];
ans.strides[i] = a.strides[perms[i]];
}
ans.setIsContiguous();
return ans;
}
/**
* Repeat elements of an array.
* @param oA Input array
* @param oRepeats The number of repetitions for each element.
* @param axis The axis along which to repeat values.
* @return Output array which has the same shape as a,
* except along the given axis.
*/
public static PyMultiarray repeat(final PyObject oA, final PyObject oRepeats, int axis) {
PyMultiarray a = PyMultiarray.asarray(oA), repeats = PyMultiarray
.asarray(oRepeats);
// Check axis and swap axis to zero.
if (axis < 0) {
axis += a.dimensions.length;
}
if (axis < 0 || axis >= a.dimensions.length) { throw Py
.ValueError("illegal axis"); }
a = PyMultiarray.swapAxes(a, 0, axis);
// Check repeats argument, copy and cast to integer.
repeats = PyMultiarray.array(repeats, 'i');
if (repeats.dimensions.length != 1) { throw Py
.ValueError("wrong number of dimensions"); }
// Create the result array.
final int[] dimensions = a.dimensions.clone();
for (int i = dimensions[0] = 0; i < repeats.dimensions[0]; i++) {
dimensions[0] += Array.getInt(repeats.data, i);
}
final PyMultiarray result = PyMultiarray.zeros(dimensions, a._typecode);
int location = 0;
for (int i = 0; i < repeats.dimensions[0]; i++) {
final PyObject chunk = a.get(i);
for (int j = 0; j < Array.getInt(repeats.data, i); j++) {
result.set(location++, chunk);
}
}
// Swap axis of result back to where it belongs and return.
return PyMultiarray.swapAxes(result, 0, axis);
}
/**
* Take elements from an array along an axis.
* @param oA The source array.
* @param oIndices The indices of the values to extract.
* @param axis The axis over which to select values.
* @return The returned array has the same type as oA.
*/
public static PyMultiarray take(final PyObject oA, final PyObject oIndices, int axis) {
PyMultiarray a = PyMultiarray.asarray(oA), indices = PyMultiarray
.asarray(oIndices);
// Check axis and rotate the axis to zero.
if (axis < 0) {
axis += a.dimensions.length;
}
if (axis < 0 || axis >= a.dimensions.length) { throw Py
.ValueError("illegal axis"); }
a = PyMultiarray.ascontiguous(PyMultiarray.rotateAxes(a, -axis));
// Check indices argument, copy and cast to integer.
indices = PyMultiarray.array(indices, 'i');
if (indices.dimensions.length != 1) { throw Py
.ValueError("wrong number of dimensions"); }
// Create the result array.
final int[] dimensions = a.dimensions.clone();
dimensions[0] = indices.dimensions[0];
final PyMultiarray result = PyMultiarray.zeros(dimensions, a._typecode);
final int stride = result.strides[0];
final int start = a.start;
for (int i = 0; i < indices.dimensions[0]; i++) {
final int item = Array.getInt(indices.data, i);
for (int j = 0; j < stride; j++) {
Array.set(
result.data,
i * stride + j,
Array.get(a.data, start + item * stride + j));
}
}
// Rotate axis of result back to where it belongs and return.
return PyMultiarray.rotateAxes(result, axis);
}
/**
* Implements choose()/clip()/where() functionality.
* Choose elements from object oA based on set of indices
* b.
* @param oA This array must contain integers in [0, n-1], where n is
* the number of choices, unless mode=wrap or mode=clip,
* in which cases any integers are permissible.
* @param b Choice arrays. a and all of the choices must be broadcastable
* to the same shape.
* @return The merged result.
*/
public static PyMultiarray choose(final PyObject oA, final PyObject b) {
PyMultiarray a = PyMultiarray.array(oA);
final boolean debug_this = false;
// Convert b into an array of PyMultiarrays.
// (b must be a PyObject because it might not be rectangular).
final int n = b.__len__();
final PyMultiarray[] bs = new PyMultiarray[n];
for (int i = 0; i < n; i++) {
bs[i] = PyMultiarray.ascontiguous(b.__getitem__(i));
}
// Find a common type for the arrays in bs.
char type = (n > 0) ? bs[0]._typecode : 'i';
for (int i = 1; i < n; i++) {
type = PyMultiarray.commonType(type, bs[i]._typecode);
}
// find bs array sizes and coerce its elements to correct type.
a = PyMultiarray.ascontiguous(a, 'i');
final int[] sizes = new int[n];
for (int i = 0; i < n; i++) {
if (a.dimensions.length < bs[i].dimensions.length) {
if (debug_this) {
System.out.println("choose() got " + a);
System.out.println("Comparing with this: " + bs[i]);
}
throw Py.ValueError("choice array has too many dimensions: "
+ bs[i].dimensions.length + " > " + a.dimensions.length);
}
for (int j = 0; j < bs[i].dimensions.length; j++) {
if (a.dimensions[j + a.dimensions.length
- bs[i].dimensions.length] != bs[i].dimensions[j]) { throw Py
.ValueError("array dimensions must agree."); }
}
bs[i] = PyMultiarray.array(bs[i], type);
sizes[i] = Array.getLength(bs[i].data);
}
final PyMultiarray result = PyMultiarray.zeros(a.dimensions, type);
final PyMultiarray flat = PyMultiarray
.reshape(result, new int[] { -1 });
for (int i = 0; i < Array.getLength(flat.data); i++) {
final int index = Array.getInt(a.data, i);
if (index < 0 || index >= n) { throw Py
.ValueError("invalid entry in choice array"); }
Array.set(flat.data, i, Array.get(bs[index].data, i % sizes[index]));
}
return result;
}
/**
* Join a sequence of arrays together.
* @param po sequence of array_like.
* The arrays must have the same shape, except in the dimension
* corresponding to axis (the first, by default).
* @param axis The axis along which the arrays will be joined. Default: 0.
* @return The concatenated array.
*/
public static PyMultiarray concatenate(final PyObject po, int axis) {
if (po.__len__() == 0) { return PyMultiarray.zeros(new int[] {}, 'i'); }
// Check axis and rotate the axis to zero.
PyMultiarray proto = PyMultiarray.asarray(po.__getitem__(0));
if (axis < 0) {
axis += proto.dimensions.length;
}
if (axis < 0 || axis >= proto.dimensions.length) {
throw Py.ValueError("illegal axis");
}
// Make array of multiarrays.
final PyMultiarray[] as = new PyMultiarray[po.__len__()];
as[0] = proto = PyMultiarray.rotateAxes(proto, -axis);
char type = proto.typecode();
final int[] dimensions = proto.dimensions.clone();
for (int i = 1; i < as.length; i++) {
as[i] = PyMultiarray.rotateAxes(
PyMultiarray.asarray(po.__getitem__(i)),
-axis);
type = PyMultiarray.commonType(type, as[i]._typecode);
if (as[i].dimensions.length != proto.dimensions.length) {
throw Py.ValueError("mismatched array dimensions");
}
for (int j = 1; j < proto.dimensions.length; j++) {
if (as[i].dimensions[j] != proto.dimensions[j]) {
throw Py.ValueError("mismatched array dimensions");
}
}
dimensions[0] += as[i].dimensions[0];
}
// Construct the result.
final PyMultiarray result = PyMultiarray.zeros(dimensions, type);
int start = 0;
for (final PyMultiarray element : as) {
final int end = start + element.dimensions[0];
result.setslice(start, end, 1, element);
start = end;
}
// Rotate axes back and return result.
return PyMultiarray.rotateAxes(result, axis);
}
/**
* Return the diagonal of a matrix.
* Actually, it returns a rank-one array containing all elements
* of the original, such that the difference between their indices
* along the specified axes is equal to the specified offset. This
* means it can operate on non-square matrices too.
* @param o Array from which the diagonals are taken.
* @param offset Offset of the diagonal from the main diagonal.
* Can be positive or negative.
* @param axis Axis from which the diagonals should be taken.
* @return A 1-D array containing the diagonal.
*/
// TODO This is a direct translation from Python -- need to figure it out.
public static PyMultiarray diagonal(final PyObject o, int offset, final int axis) {
// TODO Check arguments.
// Leave debugging statements here, but turned off, until thoroughly
// tested.
final boolean debug_this = false;
if (debug_this) {
System.out
.println("\n************************\nDiagonal gets passed in 'o' = "
+ o +
"with offset = " + offset + ", and axis = "
+ axis);
}
PyMultiarray a = PyMultiarray.rotateAxes(PyMultiarray.asarray(o), -2
- axis);
if (debug_this) {
System.out.println("\nDiagonal converts 'o' to " + a);
}
final int lastDimension = a.dimensions[a.dimensions.length - 1];
if (debug_this) {
System.out.println("\nLast dimension = a.dimensions[" +
a.dimensions.length + " -1] = " +
a.dimensions[a.dimensions.length - 1] + " = "
+ lastDimension);
}
final int[] shape = new int[a.dimensions.length - 1];
for (int i = 0; i < shape.length; i++) {
shape[i] = a.dimensions[i];
}
if (debug_this) {
System.out.println("shape[" + (shape.length - 1) + "] = " +
shape[shape.length - 1] + " becomes " +
shape[shape.length - 1] * lastDimension);
}
shape[shape.length - 1] *= lastDimension;
final int oldAshape = a.dimensions[a.dimensions.length - 1];
a = PyMultiarray.reshape(a, shape);
// System.out.println("Reshaping a to " + a);
// Need to adjust last dimension of shape to prevent
// wrap-around on higher off-diagonals.
final int shapeLastDim = shape[shape.length - 1] / lastDimension;
if (debug_this) {
System.out.println("offset = " + offset + ", shapeLastDim = "
+ shapeLastDim
+ ", a.dim[a.dim.len -2] = " + oldAshape
+ ", lastDimension - shapeLastDim = "
+ (lastDimension - shapeLastDim));
}
final int oldShape = shape[shape.length - 1];
if (offset > 0 && offset > lastDimension - shapeLastDim) {
shape[shape.length - 1] -= (offset - (lastDimension - shapeLastDim))
* lastDimension;
if (debug_this) {
System.out.println("Offset changes shape[shape.length-1] from "
+ oldShape
+ " to " + shape[shape.length - 1]);
}
}
if (offset < 0) {
offset = -lastDimension * offset;
}
if (debug_this) {
System.out.println("\nArrayRange("
+ offset
+ ","
+
shape[shape.length - 1]
+ ","
+
(lastDimension + 1)
+ ") = "
+ PyMultiarray.arrayRange(
offset,
shape[shape.length - 1],
lastDimension + 1,
'i'));
}
a = PyMultiarray.take(a, PyMultiarray.arrayRange(
offset,
shape[shape.length - 1],
lastDimension + 1,
'i'), -1);
// System.out.println("\nTake(a, arrayRange) leaves us with " + a );
return PyMultiarray.rotateAxes(a, 2 + axis);
}
// TODO check again!
/**
* Inner product of two arrays.
* @param oA First input array
* @param oB Second input array
* @param axisA Axis for the first array
* @param axisB Axis for the second array
* @return Inner product of the two arrays.
*/
public static PyObject innerProduct(final PyObject oA, final PyObject oB, int axisA, int axisB) {
PyMultiarray a = PyMultiarray.ascontiguous(oA), b = PyMultiarray
.ascontiguous(oB);
// Check arguments
// This next line emulates CNumeric behaviour that I'm not sure I like.
if (a.dimensions.length == 0 || b.dimensions.length == 0) {
return a.__mul__(b);
}
final char type = PyMultiarray.commonType(a._typecode, b._typecode);
if (axisA < 0) {
axisA += a.dimensions.length;
}
if (axisB < 0) {
axisB += b.dimensions.length;
}
if (axisA < 0 || axisA >= a.dimensions.length || axisB < 0
|| axisB >= b.dimensions.length) { throw Py
.ValueError("illegal axis"); }
if (a.dimensions[axisA] != b.dimensions[axisB]) { throw Py
.ValueError("arrays must be of same length along given axes"); }
// Rotate given axes to 0.
a = PyMultiarray.rotateAxes(a, -axisA);
b = PyMultiarray.rotateAxes(b, -axisB);
// Now do the inner product.
final int nDimsA = a.dimensions.length, nDimsB = b.dimensions.length;
final int[] dimensions = new int[nDimsA + nDimsB - 2];
final int[] aDimensions = new int[nDimsA + nDimsB - 1];
final int[] bDimensions = new int[nDimsA + nDimsB - 1];
for (int i = 1; i < nDimsA; i++) {
dimensions[i - 1] = aDimensions[i] = a.dimensions[i];
bDimensions[i] = 1;
}
for (int i = 1; i < nDimsB; i++) {
dimensions[nDimsA + i - 2] = bDimensions[nDimsA + i - 1] = b.dimensions[i];
aDimensions[nDimsA + i - 1] = 1;
}
aDimensions[0] = bDimensions[0] = a.dimensions[0];
a = PyMultiarray.reshape(a, aDimensions);
b = PyMultiarray.reshape(b, bDimensions);
final PyMultiarray result = PyMultiarray.zeros(dimensions, type);
for (int i = 0; i < a.dimensions[0]; i++) {
result.__add__(PyMultiarray.asarray(PyMultiarray.asarray(a.get(i))
.__mul__(b.get(i))), result);
}
// unrotate the axes and return.
final int[] axes = new int[result.dimensions.length];
for (int i = 0; i < nDimsA - 1; i++) {
axes[i] = (i + axisA) % (nDimsA - 1);
}
for (int i = 0; i < nDimsB - 1; i++) {
axes[nDimsA - 1 + i] = (nDimsA - 1) + (i + axisB - 1)
% (nDimsB - 1);
}
return PyMultiarray.returnValue(PyMultiarray.transpose(result, axes));
}
/**
* Return an array of indices of where the items would be locatated in the
* given array.
* @param o Input array, sorted in ascending order
* @param v Values to insert into o
* @return Array of insertion points with the same shape as v
*/
public static PyObject searchSorted(final PyObject o, final PyObject v) {
final PyMultiarray a = PyMultiarray.ascontiguous(o);
PyMultiarray values = PyMultiarray.ascontiguous(v);
if (a.dimensions.length != 1 || values.dimensions.length > 1) { throw Py
.ValueError("searchSorted only works on 1D arrays"); }
if (a._typecode == 'F' || a._typecode == 'D') { throw Py
.ValueError("cannot search complex arrays"); }
final boolean singleValue = (values.dimensions.length == 0);
if (singleValue) {
values = PyMultiarray.stretchAxes(values);
}
final PyMultiarray result = PyMultiarray.zeros(
new int[] { values.dimensions[0] },
'i');
for (int i = 0; i < values.dimensions[0]; i++) {
int start = 0, stop = a.dimensions[0] - 1;
int j = (start + stop) / 2;
if (a._typecode != 'O' && values._typecode != 'O') {
final double value = ((Number) Array.get(
values.data,
values.start + i)).doubleValue();
while (start != stop) {
final double val = ((Number) Array.get(a.data, a.start + j))
.doubleValue();
if ((val == value) || (stop == j)) {
break;
} else if (val < value) {
start = j;
} else {
stop = j;
}
j = (start + stop + 1) / 2;
}
} else {
final PyObject value = values.get(i);
while (start != stop) {
final PyObject val = a.get(j);
if (val._eq(value).__nonzero__() || (stop == j)) {
break;
} else if (val._le(value).__nonzero__()) {
start = j;
} else {
stop = j;
}
j = (start + stop + 1) / 2;
}
}
Array.setInt(result.data, i, j);
}
if (singleValue) { return result.get(0); }
return result;
}
/**
* Return convolution of two vectors.
* @param oA0 First vector
* @param oB0 Second vector
* @param mode Convolution mode, as an integer.
* 0 = 'valid'; This returns output of length max(M, N) - min(M, N) + 1.
* The convolution product is only given for points where the signals
* overlap completely. Values outside the signal boundary have no effect.
* 1 = 'same'; This returns output of length max(M, N).
* Boundary effects are still visible.
* 2 = 'full'; This returns the convolution at each point of overlap,
* with an output shape of (N+M-1,). At the end-points of the
* convolution, the signals do not overlap completely, and boundary
* effects may be seen.
* @return Discrete, linear convolution of oA0 and oB0
*/
public static PyMultiarray convolve(final PyObject oA0, final PyObject oB0, final int mode) {
PyMultiarray a0 = PyMultiarray.asarray(oA0), b0 = PyMultiarray
.asarray(oB0);
// Check arguments (If anyone cares, the 1d requirement could probably
// be relaxed.)
if (a0.dimensions.length != 1 || b0.dimensions.length != 1) { throw Py
.ValueError("convolve only works on 1D arrays"); }
// Make the arrays contiguous and then make a copy of the nondata parts.
a0 = PyMultiarray.ascontiguous(a0);
b0 = PyMultiarray.ascontiguous(b0);
final PyMultiarray a = new PyMultiarray(
a0.data,
a0._typecode,
a0.start,
a0.dimensions.clone(),
a0.strides.clone());
final PyMultiarray b = new PyMultiarray(
b0.data,
b0._typecode,
b0.start,
b0.dimensions.clone(),
b0.strides.clone());
// Create the result array.
final char type = PyMultiarray.commonType(a._typecode, b._typecode);
int padl = 0;
int length = Math.max(a.dimensions[0], b.dimensions[0]);
final int n = Math.min(a.dimensions[0], b.dimensions[0]);
switch (mode) {
case 0:
length = length - n + 1;
break;
case 1:
padl = n / 2;
break;
case 2:
length = length + n - 1;
padl = n - 1;
break;
default:
throw Py.ValueError("mode must be 0, 1, or 2");
}
// Create the result.
final PyMultiarray result = PyMultiarray.zeros(
new int[] { length },
type);
final int aSize = PyMultiarray.typeToNElements(a._typecode);
final int bSize = PyMultiarray.typeToNElements(b._typecode);
a.strides[0] = -1;
a.isContiguous = false;
for (int i = (n - padl - 1); i < length + (n - padl - 1); i++) {
final int j0 = Math.max(0, i - (a0.dimensions[0] - 1));
final int j1 = Math.min(i + 1, b0.dimensions[0]);
a.start = a0.start + aSize * (i - j0);
b.start = b0.start + bSize * j0;
a.dimensions[0] = b.dimensions[0] = j1 - j0;
result.set(i - (n - padl - 1), Umath.add.reduce(a.__mul__(b)));
}
return result;
}
/**
* Compute the padded length of a vector prior to using FFT.
* This is a helper routine for cross_correlate()
* @param length Length of original vector
* @return Length of padded vector
*/
public static int XC_padded_length(final int length) {
// Length of padding for FFT.
// Find the largest power of two that is less than 2*length.
return (int) Math.pow(
2.0,
Math.ceil(Math.log(2.0 * length) / Math.log(2.0)));
}
/**
* Perform padding on vector, prior to using FFT.
* This is a helper routine for cross_correlate()
* @param V Input vector
* @param padl Length to pad to
* @return Padded vector
*/
public static PyMultiarray XC_pad_vector(final PyMultiarray V, final int padl) {
final char type = V.typecode();
final PyMultiarray V_pad = PyMultiarray.zeros(new int[] { padl }, type);
final int V_dim = V.dimensions[0];
final int Lv2 = V_dim / 2;
// final boolean debug_this = false;
if (V_dim % 2 == 0) {
V_pad.setslice(0, Lv2, 1, V.getslice(Lv2, V_dim, 1));
V_pad.setslice(padl - Lv2, padl, 1, V.getslice(0, Lv2, 1));
}
else {
V_pad.setslice(0, Lv2 + 1, 1, V.getslice(Lv2, V_dim, 1));
V_pad.setslice(padl - Lv2, padl, 1, V.getslice(0, Lv2, 1));
}
return V_pad;
}
/**
* Recover the result of an FFT-based correlation.
* This is a helper routine for cross_correlate()
* @param R Input vector
* @param lenA Dimensions of A
* @param lenB Dimensions of B
* @param mode Correlation mode; see PyMulitarray.convolve
* @return Unpadded vector
*/
public static PyMultiarray XC_unpad_vector(final PyMultiarray R, int lenA, int lenB, final int mode) {
final boolean debug_this = false;
if (debug_this) {
System.out.println("R = " + R);
}
lenB = Math.max(lenA, lenB);
lenA = Math.min(lenA, lenB);
final int L = lenA + lenB;
final int L2 = L / 2;
final char type = R.typecode();
final int R_dim = R.dimensions[0];
/*
* First pull out the non-zero part of the FFT. Regardless of
* the mode we're in, we'll always be returning a subset of
* this. For two vectors of length lenA and lenB, there will
* always be (lenA + lenB - 1) of these.
*/
final PyMultiarray tmp = PyMultiarray.zeros(new int[] { L - 1 }, type);
if (L % 2 == 1) {
if (debug_this) {
System.out.println("UNPAD(odd): type = '" + type + "', L2 = "
+ L2 + ", R_dim = " + R_dim);
}
tmp.setslice(
0,
L2 + 1,
1,
R.getslice(R_dim - (L2 + 1), R_dim + 1, 1));
tmp.setslice(L2, L - 1, 1, R.getslice(0, L2 - 1, 1));
}
else {
if (debug_this) {
System.out.println("UNPAD(even): type = '" + type + "', L2 = "
+ L2 + ", R_dim = " + R_dim);
}
tmp.setslice(0, L2 - 1, 1, R.getslice(R_dim - L2 + 1, R_dim, 1));
tmp.setslice(L2 - 1, L + 1, 1, R.getslice(0, L2, 1));
}
final int start = L - lenB;
if (debug_this) {
System.out.println("\nUNPAD: tmp swapped = " + tmp);
}
PyMultiarray result;
// Now pull out the desired elements, in accordance with 'mode'.
switch (mode) {
case 0:
result = PyMultiarray.zeros(new int[] { lenB - lenA + 1 }, type);
if (debug_this) {
System.out.println("\nUNPAD: L = " + L + ", lenB = " + lenB
+ ", start = " + start);
}
result.setslice(
0,
L - 2 * start + 1,
1,
tmp.getslice(start - 1, L - start, 1));
break;
case 1:
result = PyMultiarray.zeros(new int[] { lenB }, type);
if (debug_this) {
System.out.println("\nUNPAD: lenB = " + lenB + ", start/2 = "
+ start / 2
+ ", L-start/2 = " + (L - start / 2));
}
result.setslice(
0,
lenB,
1,
tmp.getslice(start / 2, lenB + start / 2, 1));
break;
case 2: // Return all elements.
result = tmp;
break;
default:
throw Py.ValueError("mode must be 0,1, or 2");
}
// Finally, reverse the result inplace, then return.
result.setslice(
0,
result.dimensions[0],
1,
result.getslice(result.dimensions[0], -1, -1));
if (debug_this) {
System.out.println("\nUNPAD: result = " + result);
}
return result;
}
/**
* Return cross-correlation of two vectors.
* Cross-correlation is performed in Fourier space, since the
* computational complexity is Nlog(N), compared to N^2 in real space,
* (N=length of vectors),
* @param oA0 First vector
* @param oB0 Second vector
* @param mode Convolution mode; see PyMultiarray.convolve
* @return Cross-correlation of the two vectors
*/
public static PyMultiarray cross_correlate(final PyObject oA0, final PyObject oB0, final int mode) {
final boolean debug_this = false;
if (debug_this) {
System.out.println("MODE = " + mode);
}
PyMultiarray a0 = PyMultiarray.asarray(oA0), b0 = PyMultiarray
.asarray(oB0);
// Check arguments (If anyone cares, the 1d requirement could probably
// be relaxed.)
if (a0.dimensions.length != 1 || b0.dimensions.length != 1) { throw Py
.ValueError("cross_correlate only works on 1D arrays"); }
// Make the arrays contiguous and then make a copy of the nondata parts.
a0 = PyMultiarray.ascontiguous(a0);
b0 = PyMultiarray.ascontiguous(b0);
final PyMultiarray a = new PyMultiarray(
a0.data,
a0._typecode,
a0.start,
a0.dimensions.clone(),
a0.strides.clone());
final PyMultiarray b = new PyMultiarray(
b0.data,
b0._typecode,
b0.start,
b0.dimensions.clone(),
b0.strides.clone());
final char type = PyMultiarray.commonType(a._typecode, b._typecode);
final int length = Math.max(a.dimensions[0], b.dimensions[0]);
/*
* To do proper convolution(A, B), it's not enough to just FFT A and B,
* multiply A and conjugate(B), and return the real part of the
* inverse-FFT.
* You need to pad.
* Padding serves two purposes:
* 1. It makes the vector's length equal to a power of two, so that the
* FFT is happy.
* 2. It prevents contamination of the results by the assumption of an
* infinite series,
* when any real-life series is finite.
* 3. We do more than just padding - we re-arrange the data into a
* particular format.
* How much contamination is satisfactory?
* That's determined by the choice of 'mode' variable. See User Guide
* for CNumeric.
* We use the FFT for a number of reasons:
* 1. It's much faster than computing the convolution by the direct
* method
* (O[NlogN] compared to O[N^2])
* 2. The FFT has already been implemented, so we don't have as much
* work to do here.
* 3. Any improvements made in the future to the FFT routines
* will automatically be available here too.
*/
// Create copies of the two arrays, arranged in particular format,
// pad them out to a power of two.
final int padl = PyMultiarray.XC_padded_length(length);
if (debug_this) {
System.out.println("Length = " + length + " --> PADL = " + padl);
}
final PyMultiarray a_pad = PyMultiarray.XC_pad_vector(a, padl);
final PyMultiarray fft_a = FFT.fft(a_pad);
final PyMultiarray b_pad = PyMultiarray.XC_pad_vector(b, padl);
/*
* FF-Transformed arrays are complex, so is their product.
* Correlation works only on real (or integer) arguments and
* the result should have the same type as the original
* vectors. If integer, we need to make sure that we
* round, not just truncate.
* Finally, copy results into standard order ('unpad' them).
*/
final PyMultiarray prod = PyMultiarray.zeros(new int[] { padl }, 'D');
fft_a.__mul__(Umath.conjugate.__call__(FFT.fft(b_pad)), prod);
PyMultiarray inverse_prod_real = FFT.inverse_fft(prod).getReal();
PyMultiarray result;
if (PyMultiarray.typeToKind(type) == PyMultiarray.INTEGER) {
// This needs to be converted to a bona fide round() function.
// Anyone know is there is one already?
inverse_prod_real = (PyMultiarray) inverse_prod_real.__add__(Py
.newFloat(0.5));
final PyMultiarray inverse_prod_real_round = PyMultiarray.asarray(
inverse_prod_real,
type);
inverse_prod_real = inverse_prod_real_round;
result = PyMultiarray.XC_unpad_vector(
inverse_prod_real_round,
a.dimensions[0],
b.dimensions[0],
mode);
}
else {
result = PyMultiarray.XC_unpad_vector(
inverse_prod_real,
a.dimensions[0],
b.dimensions[0],
mode);
}
if (debug_this) {
System.out.println("\nCROSS_CORRELATE: RESULT = " + result);
}
return result;
}
//
// Accessory functions (may be useful for other members of JNumeric
// package).
//
/** Return the real part of this multiarray. */
final PyMultiarray getReal() {
if (this._typecode == 'F' || this._typecode == 'D') {
final int[] dims = this.dimensions.clone();
final int[] strs = this.strides.clone();
final char type = (this._typecode == 'F') ? 'f' : 'd';
return new PyMultiarray(this.data, type, this.start, dims, strs);
}
return this;
}
/**
* Return the imaginary part of this multiarray if its complex otherwise
* return null.
*/
final PyMultiarray getImag() {
if (this._typecode == 'F' || this._typecode == 'D') {
final int[] dims = this.dimensions.clone();
final int[] strs = this.strides.clone();
final char type = (this._typecode == 'F') ? 'f' : 'd';
return new PyMultiarray(this.data, type, this.start + 1, dims, strs);
}
return null;
}
/**
* Return the shape of a Python sequence.
* @param seq Array-like
* @return The shape of seq
*/
public final static int[] shapeOf(final PyObject seq) {
if (seq instanceof PyMultiarray) { return ((PyMultiarray) seq).dimensions
.clone(); }
return PyMultiarray._shapeOf(seq, 0);
}
private final static int[] _shapeOf(final PyObject seq, final int depth) {
int items;
// Take care of special cases (strings, nonsequence, and empty
// sequence).
if (seq instanceof PyString) { return new int[depth]; }
try {
items = seq.__len__();
} catch (final Throwable e) {
return new int[depth];
}
if (items == 0) { return new int[depth + 1]; }
// Loop over sequence elements and determine shape.
final int[] shape = PyMultiarray
._shapeOf(seq.__getitem__(0), depth + 1);
shape[depth] = items;
for (int i = 1; i < items; i++) {
final int[] shape2 = PyMultiarray._shapeOf(
seq.__getitem__(i),
depth + 1);
if (shape.length != shape2.length) { throw Py
.ValueError("malformed array"); }
for (int j = depth + 1; j < shape.length; j++) {
if (shape[j] != shape2[j]) { throw Py
.ValueError("malformed array"); }
}
}
return shape;
}
/**
* Return a multiarray with the axes rotated by n (axis 0->n, 1->n+1, etc.)
*/
static PyMultiarray rotateAxes(final PyMultiarray a, int n) {
final PyMultiarray result = new PyMultiarray(
a.data,
a._typecode,
a.start,
a.dimensions.clone(),
a.strides.clone());
while (n < 0) {
n += a.dimensions.length;
}
for (int i = 0; i < a.dimensions.length; i++) {
result.dimensions[(i + n) % a.dimensions.length] = a.dimensions[i];
result.strides[(i + n) % a.dimensions.length] = a.strides[i];
}
result.setIsContiguous();
return result;
}
/**
* Return a multiarray with the axess n0 and n1 swapped.
*/
static PyMultiarray swapAxes(final PyMultiarray a, int n0, int n1) {
final PyMultiarray result = new PyMultiarray(
a.data,
a._typecode,
a.start,
a.dimensions.clone(),
a.strides.clone());
if (n0 < 0) {
n0 += a.dimensions.length;
}
if (n1 < 0) {
n1 += a.dimensions.length;
}
if (n0 < 0 || n0 >= a.dimensions.length || n1 < 0
|| n1 >= a.dimensions.length) { throw Py
.ValueError("illegal axis"); }
result.dimensions[n0] = a.dimensions[n1];
result.strides[n0] = a.strides[n1];
result.dimensions[n1] = a.dimensions[n0];
result.strides[n1] = a.strides[n0];
result.setIsContiguous();
return result;
}
/**
* Return the number of elements for this typecode (2 if complex, otherwise
* 1).
*/
final static int typeToNElements(final char typecode) {
switch (typecode) {
case 'F':
case 'D':
return 2;
default:
return 1;
}
}
/**
* Return a common typecode given two typecodes a and
* b.
*/
final static char commonType(final char a, final char b) {
if (a == b) { return a; }
final short atype = PyMultiarray.typeToKind(a), btype = PyMultiarray
.typeToKind(b);
final short newtype = (atype > btype) ? atype : btype;
if (newtype == PyMultiarray.PYOBJECT) { return 'O'; }
final short asize = PyMultiarray.typeToNBytes(a), bsize = PyMultiarray
.typeToNBytes(b);
final short newsize = (asize > bsize) ? asize : bsize;
return PyMultiarray.kindAndNBytesToType(newtype, newsize);
}
/**
* Convert a sequence to an array of ints.
*/
static int[] objectToInts(final Object jo, final boolean forgiving) {
if (jo instanceof int[]) { return (int[]) jo; }
if (!(jo instanceof PyObject)) { throw Py
.ValueError("cannot convert argument to array of ints"); }
PyObject o = (PyObject) jo;
if (PyMultiarray.shapeOf(o).length == 0) {
if (forgiving) {
// return new int []
// {asarray(o).__getitem__(Py.Ellipsis).__int__().getValue()};
o = PyMultiarray.asarray(o).__getitem__(Py.Ellipsis);
} else {
throw Py.ValueError("cannot convert argument to array of ints");
}
}
int length;
try {
length = o.__len__();
} catch (final Throwable t) {
return new int[] { Py.py2int(o) };
}
final int[] intArray = new int[length];
for (int i = 0; i < intArray.length; i++) {
final PyObject item = o.__getitem__(i);
if (!forgiving && !(item instanceof PyInteger)) { throw Py
.ValueError("cannot convert argument to array of ints"); }
intArray[i] = Py.py2int(o.__getitem__(i));
}
return intArray;
}
//
// Private methods (I can't see any other classes needing these.)
//
/**
* Return an array of PyObjects that is a flattened version of sequence.
* size is the size of the resulting array (determined
* beforehand using shapeToNItems).
*/
private final static PyObject[] seqToObjects(final PyObject seq, final int size) {
final PyObject[] flat = new PyObject[size];
PyMultiarray._seqToObjects(seq, flat, 0);
return flat;
}
private final static int _seqToObjects(final PyObject seq, final PyObject[] flat, int offset) {
int items;
if (seq instanceof PyString) {
flat[offset] = seq;
return offset + 1;
}
try {
items = seq.__len__();
} catch (final Throwable t) {
flat[offset] = seq;
return offset + 1;
}
for (int i = 0; i < items; i++) {
offset = PyMultiarray._seqToObjects(
seq.__getitem__(i),
flat,
offset);
}
return offset;
}
/**
* Check shape for errors and replace the rubber index with any with an
* appropriate size.
*/
private static int[] fixedShape(int[] shape, final int totalSize) {
shape = shape.clone();
int size = 1;
int rubberAxis = -1;
for (int i = 0; i < shape.length; i++) {
if (shape[i] == -1) {
if (rubberAxis != -1) { throw Py.ValueError("illegal shape"); }
rubberAxis = i;
} else {
size *= shape[i];
}
}
if (rubberAxis != -1) {
shape[rubberAxis] = totalSize / size;
size *= shape[rubberAxis];
}
if (totalSize != size) { throw Py
.ValueError("total size of new array must be unchanged"); }
return shape;
}
/**
* Convert a PyObject into a native Java type based on
* typecode.
* If returnReal is false, the complex part of the given object is returned,
* this defaults to zero if the PyObject is not an instance of PyComplex.
*/
private final static Object objectToJava(PyObject o, final char typecode, final boolean returnReal) {
if (typecode == 'O') { return o; }
if (o instanceof PyComplex) {
o = Py.newFloat(returnReal ? ((PyComplex) o).real
: ((PyComplex) o).imag);
} else if (!returnReal) {
o = Py.Zero;
}
final Object number = o.__tojava__(PyMultiarray.typeToClass(typecode));
if (number == Py.NoConversion) { throw Py.ValueError("coercion error"); }
return number;
}
/**
* Return the appropriate typecode for a PyObject.
*/
private final static char objectToType(final PyObject o) {
if (o instanceof PyInteger) {
return 'i';
}
else if (o instanceof PyFloat) {
return 'd';
}
else if (o instanceof PyComplex) {
return 'D';
}
else {
return 'O';
}
}
/**
* Find an appropriate common type for an array of PyObjects.
*/
private final static char objectsToType(final PyObject[] objects) {
if (objects.length == 0) { return 'i'; }
short new_no, no = -1;
short new_sz, sz = -1;
for (final PyObject o : objects) {
final char _typecode = PyMultiarray.objectToType(o);
new_no = PyMultiarray.typeToKind(_typecode);
new_sz = PyMultiarray.typeToNBytes(_typecode);
no = (no > new_no) ? no : new_no;
sz = (sz > new_sz) ? sz : new_sz;
}
return PyMultiarray.kindAndNBytesToType(no, sz);
}
/**
* Return a Java Class that matches typecode.
*/
private final static Class> typeToClass(final char typecode) {
switch (typecode) {
case '1':
return Byte.TYPE;
case 's':
return Short.TYPE;
case 'i':
return Integer.TYPE;
case 'l':
return Long.TYPE;
case 'f':
case 'F':
return Float.TYPE;
case 'd':
case 'D':
return Double.TYPE;
case 'O':
return PyObject.class;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
/**
* Return a typecode that matches the given Java class
*/
private final static char classToType(final Class> klass) {
if (klass.equals(Byte.TYPE)) { return '1'; }
if (klass.equals(Short.TYPE)) { return 's'; }
if (klass.equals(Integer.TYPE)) { return 'i'; }
if (klass.equals(Long.TYPE)) { return 'l'; }
if (klass.equals(Float.TYPE)) { return 'f'; }
if (klass.equals(Double.TYPE)) { return 'd'; }
if (klass.equals(PyObject.class)) { return 'O'; }
throw Py.ValueError("unknown class in classToType");
}
/**
* Return the number of items of a multiarray based on its shape
* (dimensions).
*/
private final static int shapeToNItems(final int[] shape) {
int size = 1;
for (final int element : shape) {
if (element < 0) { throw Py
.ValueError("negative dimensions are not allowed"); }
size *= element;
}
return size;
}
/**
* Return the strides for a new multiarray based on its shape and the number
* of elements per item.
*/
private final static int[] shapeToStrides(final int[] shape, final int nElements) {
final int[] strides = new int[shape.length];
int stride = nElements;
for (int i = shape.length - 1; i >= 0; i--) {
strides[i] = stride;
stride *= shape[i];
}
return strides;
}
// These enumerate the kinds of types. Lower numbered types can be cast to
// higher, but not vice versa.
private final static short INTEGER = 1;
private final static short FLOATINGPOINT = 2;
private final static short COMPLEX = 3;
private final static short PYOBJECT = 4;
/**
* Return the kind of type this is (INTEGER, FLOATINGPOINT, COMPLEX, or
* PYOBJECT).
*/
private final static short typeToKind(final char typecode) {
switch (typecode) {
case '1':
case 's':
case 'i':
case 'l':
return PyMultiarray.INTEGER;
case 'f':
case 'd':
return PyMultiarray.FLOATINGPOINT;
case 'F':
case 'D':
return PyMultiarray.COMPLEX;
case 'O':
return PyMultiarray.PYOBJECT;
default:
throw Py.ValueError("internal error in typeToKind");
}
}
/**
* Return the number of bytes per element for the given typecode.
*/
private final static short typeToNBytes(final char typecode) {
switch (typecode) {
case '1':
return 1;
case 's':
return 2;
case 'i':
case 'f':
case 'F':
return 4;
case 'l':
case 'd':
case 'D':
return 8;
case 'O':
return 0;
default:
throw Py.ValueError("internal error in typeToNBytes");
}
}
/**
* Return a typecode that matches a given type kind and size (in bytes).
*/
private final static char kindAndNBytesToType(final short kind, final short nbytes) {
switch (kind) {
case INTEGER:
switch (nbytes) {
case 1:
return '1';
case 2:
return 's';
case 4:
return 'i';
case 8:
return 'l';
default:
break;
}
break;
case FLOATINGPOINT:
switch (nbytes) {
case 4:
return 'f';
case 8:
return 'd';
default:
break;
}
break;
case COMPLEX:
switch (nbytes) {
case 4:
return 'F';
case 8:
return 'D';
default:
break;
}
break;
case PYOBJECT:
return 'O';
}
throw Py.ValueError("internal error in kindAndNBytesToType");
}
/**
* Set isContiguous to true if the strides indicate that this array is
* contiguous.
*/
private final void setIsContiguous() {
final int[] contiguousStrides = PyMultiarray.shapeToStrides(
this.dimensions,
PyMultiarray.typeToNElements(this._typecode));
for (int i = 0; i < this.strides.length; i++) {
if (this.strides[i] != contiguousStrides[i]) {
this.isContiguous = false;
break;
}
}
}
/**
* Return an array derived from a whose axes are suitable for
* binary operations.
*/
private final static PyMultiarray stretchAxes(final PyMultiarray a, final PyMultiarray b) {
if (a.dimensions.length > b.dimensions.length) {
final int[] dimensions = a.dimensions.clone();
final int[] strides = a.strides.clone();
final int excess = a.dimensions.length - b.dimensions.length;
for (int i = excess; i < dimensions.length; i++) {
if (dimensions[i] != b.dimensions[i - excess]) {
if (dimensions[i] == 1) {
dimensions[i] = b.dimensions[i - excess];
strides[i] = 0;
}
else if (b.dimensions[i - excess] != 1) { throw Py
.ValueError("matrices not aligned"); }
}
}
return new PyMultiarray(
a.data,
a._typecode,
a.start,
dimensions,
strides);
}
else {
final int[] dimensions = b.dimensions.clone();
final int[] strides = new int[dimensions.length];
final int excess = b.dimensions.length - a.dimensions.length;
for (int i = excess; i < dimensions.length; i++) {
if (dimensions[i] != a.dimensions[i - excess]) {
if (dimensions[i] == 1) {
dimensions[i] = a.dimensions[i - excess];
} else if (a.dimensions[i - excess] == 1) {
continue; // Don't set strides.
} else {
throw Py.ValueError("matrices not aligned");
}
}
strides[i] = a.strides[i - excess];
}
return new PyMultiarray(
a.data,
a._typecode,
a.start,
dimensions,
strides);
}
}
/** Return an array with shape [1] for use when multiplying shape [] arrays. */
private final static PyMultiarray stretchAxes(final PyMultiarray a) {
final int[] dimensions = new int[] { 1 };
final int[] strides = new int[] { 1 };
return new PyMultiarray(
a.data,
a._typecode,
a.start,
dimensions,
strides);
}
/** Return an array for storing the result of a binary operation on a and b. */
private final static PyMultiarray getResultArray(final PyMultiarray a, final PyMultiarray b, char type) {
if (type == '\0') {
type = a._typecode;
}
final int[] dimensions = new int[a.dimensions.length];
for (int i = 0; i < a.dimensions.length; i++) {
dimensions[i] = Math.max(a.dimensions[i], b.dimensions[i]);
}
return PyMultiarray.zeros(dimensions, type);
}
/**
* Check that result is consistent with a and
* b.
*/
private final static void checkResultArray(final PyMultiarray result, final PyMultiarray a, final PyMultiarray b) {
if (result._typecode != a._typecode) { throw Py
.ValueError("return array has incorrect type."); }
if (result.dimensions.length != a.dimensions.length) { throw Py
.ValueError("return array has the wrong number of dimensions"); }
for (int i = 0; i < result.dimensions.length; i++) {
if (result.dimensions[i] != Math.max(
a.dimensions[i],
b.dimensions[i])) { throw Py
.ValueError("return array has incorrect dimensions"); }
}
}
//
// Python special methods.
//
/**
* Convert this to a java object of Class c.
*/
@Override public Object __tojava__(final Class> c) {
final Class> type = PyMultiarray.typeToClass(this._typecode);
if (this.dimensions.length == 0 || this._typecode == 'F'
|| this._typecode == 'D') { return super.__tojava__(c); // Punt!
}
if (c == Object.class
|| (c.isArray() && c.getComponentType().isAssignableFrom(type))) {
final Object jarray = Array.newInstance(type, this.dimensions);
final PyMultiarray contiguous = PyMultiarray.ascontiguous(this);
if (this.dimensions.length == 1) {
for (int i = 0; i < contiguous.__len__(); i++) {
Array.set(
jarray,
i,
Array.get(contiguous.data, contiguous.start + i));
}
return jarray;
}
else {
for (int i = 0; i < contiguous.__len__(); i++) {
final Object subData = this.get(i).__tojava__(c);
Array.set(jarray, i, subData);
}
return jarray;
}
}
return super.__tojava__(c);
}
/**
* Return the length of the array (along the first axis).
*/
@Override public int __len__() {
if (this.dimensions.length == 0) { throw Py
.ValueError("__len__ of zero dimensional array"); }
return this.dimensions[0];
}
/**
* Override PyObject method so that get is invoked instead of __finditem__.
*/
@Override public PyObject __getitem__(final int index) {
return this.get(index);
}
/**
* Disable comparison of Multiarrays
*/
@Override public int __cmp__(final PyObject other) {
final boolean debug_this = false;
if (!(other instanceof PyMultiarray)) { return -2; }
final PyMultiarray o = (PyMultiarray) other;
if (debug_this) {
System.out.println("__cmp__() passed '"
+ other.getClass().getName()
+ "' object with typecode '" + o.typecode() + "': " + o);
System.out.println("Comparing with this: '"
+ this.getClass().getName() + "' " + this);
}
throw Py.TypeError("Comparison of multiarray objects is not implemented.");
}
/**
* Return the subarray or item indicated by indices.
*/
@Override public PyObject __getitem__(final PyObject indices) {
return PyMultiarray.returnValue(this.indicesToStructure(indices));
}
/**
* Set the subarray based on indices to PyValue.
*/
@Override public void __setitem__(final PyObject indices, final PyObject pyValue) {
// Get the shape of the subarray to set.
final PyMultiarray toStructure = this.indicesToStructure(indices);
// Convert value to array.
final PyMultiarray value = PyMultiarray.array(pyValue, this._typecode);
// Check that array shapes are consistent and get new shape for source
// array.
final int[] shape = toStructure.dimensions.clone();
final int[] strides = new int[toStructure.dimensions.length];
final int excess = toStructure.dimensions.length
- value.dimensions.length;
if (toStructure.dimensions.length < value.dimensions.length) { throw Py
.ValueError("object too deep for desired array"); }
for (int i = 0; i < excess; i++) {
shape[i] = toStructure.dimensions[i];
}
for (int i = excess; i < toStructure.dimensions.length; i++) {
shape[i] = value.dimensions[i - excess];
strides[i] = value.strides[i - excess];
}
value.dimensions = shape;
value.strides = strides;
value.setIsContiguous();
PyMultiarray.copyAToB(value, toStructure);
}
// TODO Optimize!!
/**
* Set a slice of a PyObject.
* Changes elements from start up to,
* but not including, stop.
*/
@Override protected void setslice(final int start, final int stop, final int step, final PyObject value) {
final PyObject startObject = (start >= 0) ? Py.newInteger(start)
: Py.None;
final PyObject stopObject = (stop >= 0) ? Py.newInteger(stop) : Py.None;
this.__setitem__(
new PySlice(startObject, stopObject, Py.newInteger(step)),
value);
}
// TODO Optimize!!
/**
* Return a slice of a PyObject.
* Gets elements from start up to,
* but not including, stop
*/
@Override protected PyObject getslice(final int start, final int stop, final int step) {
final PyObject startObject = (start >= 0) ? Py.newInteger(start)
: Py.None;
final PyObject stopObject = (stop >= 0) ? Py.newInteger(stop) : Py.None;
return this.__getitem__(new PySlice(startObject, stopObject, Py
.newInteger(step)));
}
/**
* Return the repr for this Multiarray.
*/
@Override public PyString __repr__() {
return Py.newString(PyMultiarrayPrinter.array2string(
this,
PyMultiarray.maxLineWidth,
PyMultiarray.precision,
PyMultiarray.suppressSmall,
", ",
true));
}
/**
* Return the str for this Multiarray.
*/
@Override public PyString __str__() {
return Py.newString(PyMultiarrayPrinter.array2string(
this,
PyMultiarray.maxLineWidth,
PyMultiarray.precision,
PyMultiarray.suppressSmall,
" ",
false));
}
/**
* Multiarray attributes are found using __findattr__.
*/
@Override public PyObject __findattr_ex__(final String name) {
// if (name == "__class__") return __class__;
if (name == "__doc__") { return Py.newString(this.docString); }
if (name == "shape") { return PyTuple.fromIterable(new PyArray(
int.class,
this.dimensions)); // return __builtin__.tuple(new
// PyArray(int.class, dimensions));
}
if (name == "real") { return this.getReal(); }
if (name == "imag" || name == "imaginary") { return this.getImag(); }
if (name == "flat" && this.isContiguous) { return PyMultiarray.reshape(
this,
new int[] { -1 }); }
if (name == "T" && this.dimensions.length == 2) { return PyMultiarray
.transpose(this, new int[] { 1, 0 }); }
return super.__findattr_ex__(name);
}
/**
* Multiarray attributes are set using __setattr__.
*/
@Override public void __setattr__(final String name, final PyObject value)
throws PyException {
if (name == "shape") {
if (!this.isContiguous) { throw Py
.ValueError("reshape only works on contiguous matrices"); }
final int[] shape = (int[]) value.__tojava__(this.dimensions
.getClass());
this.dimensions = PyMultiarray.fixedShape(
shape,
PyMultiarray.shapeToNItems(this.dimensions));
this.strides = PyMultiarray.shapeToStrides(
shape,
PyMultiarray.typeToNElements(this._typecode));
return;
}
if (name == "imag" || name == "imaginary") {
final PyMultiarray imag = this.getImag();
if (imag != null) {
imag.__setitem__(new PySlice(null, null, null), value);
return;
}
}
if (name == "real") {
this.getReal().__setitem__(new PySlice(null, null, null), value);
return;
}
super.__setattr__(name, value);
}
// The numeric special methods are defined later because they tend to be
// obnoxiously long...
//
// Sequence special methods.
//
protected PyObject get(final int i) {
if (this.dimensions.length < 1) { throw Py
.IndexError("too few dimensions"); }
final int newStart = this.start + this.fixIndex(i, 0) * this.strides[0];
final int[] newDimensions = new int[this.dimensions.length - 1];
final int[] newStrides = new int[this.dimensions.length - 1];
for (int j = 0; j < this.dimensions.length - 1; j++) {
newDimensions[j] = this.dimensions[j + 1];
newStrides[j] = this.strides[j + 1];
}
return PyMultiarray.returnValue(new PyMultiarray(
this.data,
this._typecode,
newStart,
newDimensions,
newStrides));
}
@Override protected PyObject pyget(final int i) {
return this.get(i);
}
@Override protected PyObject repeat(final int count) {
throw Py.TypeError("can't apply '*' to arrays");
}
@Override protected void del(final int i) {
throw Py.TypeError("can't remove from array");
}
protected void delRange(final int start, final int stop, final int step) {
throw Py.TypeError("can't remove from array");
}
protected void set(final int i, final PyObject pyValue) {
if (this.dimensions.length < 1) { throw Py
.IndexError("too few dimensions"); }
final int newStart = this.start + this.fixIndex(i, 0) * this.strides[0];
final int[] newDimensions = new int[this.dimensions.length - 1];
final int[] newStrides = new int[this.dimensions.length - 1];
for (int j = 0; j < this.dimensions.length - 1; j++) {
newDimensions[j] = this.dimensions[j + 1];
newStrides[j] = this.strides[j + 1];
}
PyMultiarray.copyAToB(
PyMultiarray.asarray(pyValue, this._typecode),
new PyMultiarray(
this.data,
this._typecode,
newStart,
newDimensions,
newStrides));
}
/**
* Convert negative indices to positive and throw exception if index out of
* range.
*/
protected int fixIndex(int index, final int axis) {
if (index < 0) {
index += this.dimensions[axis];
}
if (index < 0 || index >= this.dimensions[axis]) {
throw Py.IndexError("index out of range");
} else {
return index;
}
}
/**
* Pulled out of PySequence
*/
private static final int getIndex(final PyObject index, final int defaultValue) {
if (index == Py.None || index == null) { return defaultValue; }
if (!(index instanceof PyInteger)) { throw Py
.TypeError("slice index must be int"); }
return ((PyInteger) index).getValue();
}
/**
* From jython 2.2.1 PySequence
*/
protected static final int getStep1(final PyObject s_step) {
final int step = PyMultiarray.getIndex(s_step, 1);
if (step == 0) { throw Py.TypeError("slice step of zero not allowed"); }
return step;
}
/**
* Should go in PySequence
*/
protected static final int getStart1(final PyObject s_start, final int step, final int length) {
int start;
if (step < 0) {
start = PyMultiarray.getIndex(s_start, length - 1);
if (start < -1) {
start = length + start;
}
if (start < -1) {
start = -1;
}
if (start > length - 1) {
start = length - 1;
}
} else {
start = PyMultiarray.getIndex(s_start, 0);
if (start < 0) {
start = length + start;
}
if (start < 0) {
start = 0;
}
if (start > length) {
start = length;
}
}
return start;
}
protected static final int getStop1(final PyObject s_stop, final int start, final int step, final int length) {
int stop;
if (step < 0) {
stop = PyMultiarray.getIndex(s_stop, -1);
if (stop < -1) {
stop = length + stop;
}
if (stop < -1) {
stop = -1;
}
if (stop > length - 1) {
stop = length - 1;
}
} else {
stop = PyMultiarray.getIndex(s_stop, length);
if (stop < 0) {
stop = length + stop;
}
if (stop < 0) {
stop = 0;
}
if (stop > length) {
stop = length;
}
}
if ((stop - start) * step < 0) {
stop = start;
}
return stop;
}
/**
* Convert a set of indices into a Multiarray object, but do not fill in the
* data.
*/
private final PyMultiarray indicesToStructure(final PyObject pyIndices) {
// Convert the pyIndices into an array of PyObjects.
// RGA PyObject indices[] = (pyIndices instanceof PyTuple) ?
// ((PyTuple)pyIndices).list : new PyObject[] {pyIndices};
final PyObject indices[] = (pyIndices instanceof PyTuple) ? ((PyTuple) pyIndices)
.getArray() : new PyObject[] { pyIndices };
// First pass: determine the size of the new dimensions.
int nDimensions = this.dimensions.length, ellipsisLength = 0, axis = 0;
for (int i = 0; i < indices.length; i++) {
final PyObject index = indices[i];
if (index instanceof PyEllipsis) {
if (ellipsisLength > 0) {
continue;
}
ellipsisLength = this.dimensions.length
- (indices.length - i - 1 + axis);
for (int j = i + 1; j < indices.length; j++) {
if (indices[j] instanceof PyNone) {
ellipsisLength++;
}
}
if (ellipsisLength < 0) { throw Py
.IndexError("too many indices"); }
axis += ellipsisLength;
}
else if (index instanceof PyNone) {
nDimensions++;
} else if (index instanceof PyInteger) {
nDimensions--;
axis++;
}
else if (index instanceof PySlice) {
axis++;
} else {
throw Py.ValueError("invalid index");
}
}
if (axis > this.dimensions.length) { throw Py
.ValueError("invalid index"); }
// Second pass: now generate the dimensions.
int newStart = this.start, newAxis = 0, oldAxis = 0;
final int[] newDimensions = new int[nDimensions], newStrides = new int[nDimensions];
for (final PyObject index : indices) {
if (index instanceof PyEllipsis) {
if (ellipsisLength > 0) {
for (int j = 0; j < ellipsisLength; j++) {
newDimensions[newAxis + j] = this.dimensions[oldAxis
+ j];
newStrides[newAxis + j] = this.strides[oldAxis + j];
}
oldAxis += ellipsisLength;
newAxis += ellipsisLength;
ellipsisLength = 0;
}
}
else if (index instanceof PyNone) {
newDimensions[newAxis] = 1;
newStrides[newAxis] = 0;
newAxis++;
}
else if (oldAxis >= this.dimensions.length) {
throw Py.IndexError("too many dimensions");
} else if (index instanceof PyInteger) {
final PyInteger integer = (PyInteger) index;
newStart += this.fixIndex(integer.getValue(), oldAxis)
* this.strides[oldAxis];
oldAxis++;
}
else if (index instanceof PySlice) {
final PySlice slice = (PySlice) index;
final int sliceStep = PyMultiarray.getStep1(slice.step);
final int sliceStart = PyMultiarray.getStart1(
slice.start,
sliceStep,
this.dimensions[oldAxis]);
final int sliceStop = PyMultiarray.getStop1(
slice.stop,
sliceStart,
sliceStep,
this.dimensions[oldAxis]);
if (sliceStep > 0) {
newDimensions[newAxis] = 1 + (sliceStop - sliceStart - 1)
/ sliceStep;
} else {
newDimensions[newAxis] = 1 - (sliceStart - sliceStop - 1)
/ sliceStep;
}
newStart += sliceStart * this.strides[oldAxis];
newStrides[newAxis] = sliceStep * this.strides[oldAxis];
oldAxis++;
newAxis++;
} else {
throw Py.ValueError("illegal index");
}
}
// Tack any extra indices onto the end.
for (int i = 0; i < nDimensions - newAxis; i++) {
newDimensions[newAxis + i] = this.dimensions[oldAxis + i];
newStrides[newAxis + i] = this.strides[oldAxis + i];
}
return new PyMultiarray(
this.data,
this._typecode,
newStart,
newDimensions,
newStrides);
}
/**
* Return a unless it is zero dimensional, in which case
* convert to a PyObject and return.
*/
static final PyObject returnValue(final PyMultiarray a) {
if (a.dimensions.length == 0) {
if (PyMultiarray.typeToNElements(a._typecode) == 1) {
return Py.java2py(Array.get(a.data, a.start));
} else {
return new PyComplex(
((Number) Array.get(a.data, a.start)).doubleValue(),
((Number) Array.get(a.data, a.start + 1)).doubleValue());
}
}
return a;
}
/**
* Copy the array A to the array B. The arrays must be the same shape.
* (Length 1 axes can be converted to length N axes if the appropriate
* stride is set to zero.)
*/
static void copyAToB(final PyMultiarray a, final PyMultiarray b) {
if (a.dimensions.length != b.dimensions.length) { throw Py
.ValueError("copied matrices must have the same number of dimensions"); }
for (int i = 0; i < a.dimensions.length; i++) {
if (a.dimensions[i] != b.dimensions[i]) { throw Py
.ValueError("matrices not aligned for copy"); }
}
if (a._typecode == b._typecode && a.isContiguous && b.isContiguous) {
System.arraycopy(
a.data,
a.start,
b.data,
b.start,
PyMultiarray.typeToNElements(a._typecode)
* PyMultiarray.shapeToNItems(a.dimensions));
} else if (a.dimensions.length == 0) {
b.__setitem__(Py.Ellipsis, a.__getitem__(Py.Ellipsis));
} else if (a._typecode == b._typecode && a._typecode != 'F'
&& a._typecode != 'D') {
PyMultiarray.copyAxToBx(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
} else if (a._typecode == 'O') {
PyMultiarray.copyAOToB(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b._typecode,
b.dimensions,
0);
} else {
switch (b._typecode) {
case '1':
PyMultiarray.copyAToBb(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
break;
case 's':
PyMultiarray.copyAToBs(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
break;
case 'i':
PyMultiarray.copyAToBi(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
break;
case 'l':
PyMultiarray.copyAToBl(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
break;
case 'f':
PyMultiarray.copyAToBf(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
break;
case 'd':
PyMultiarray.copyAToBd(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
break;
case 'F':
if (a._typecode == 'F' || a._typecode == 'D') {
PyMultiarray.copyAToBF(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
} else {
PyMultiarray.copyAToBf(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
}
break;
case 'D':
if (a._typecode == 'F' || a._typecode == 'D') {
PyMultiarray.copyAToBD(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
} else {
PyMultiarray.copyAToBd(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
}
break;
case 'O':
PyMultiarray.copyAToBO(
a.data,
a.start,
a.strides,
b.data,
b.start,
b.strides,
b.dimensions,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
}
static void copyAxToBx(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAxToBx(
aData,
i,
aStrides,
bData,
j,
bStrides,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.set(bData, j, Array.get(aData, i));
}
}
}
static void copyAOToB(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final char bType, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAOToB(
aData,
i,
aStrides,
bData,
j,
bStrides,
bType,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.set(bData, j, ((PyObject) Array.get(aData, i))
.__tojava__(PyMultiarray.typeToClass(bType)));
}
}
}
static void copyAToBb(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAToBb(
aData,
i,
aStrides,
bData,
j,
bStrides,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.setByte(
bData,
j,
((Number) Array.get(aData, i)).byteValue());
}
}
}
static void copyAToBs(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAToBs(
aData,
i,
aStrides,
bData,
j,
bStrides,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.setShort(
bData,
j,
((Number) Array.get(aData, i)).shortValue());
}
}
}
static void copyAToBi(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAToBi(
aData,
i,
aStrides,
bData,
j,
bStrides,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.setInt(
bData,
j,
((Number) Array.get(aData, i)).intValue());
}
}
}
static void copyAToBl(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAToBl(
aData,
i,
aStrides,
bData,
j,
bStrides,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.setLong(
bData,
j,
((Number) Array.get(aData, i)).longValue());
}
}
}
static void copyAToBf(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAToBf(
aData,
i,
aStrides,
bData,
j,
bStrides,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.setFloat(
bData,
j,
((Number) Array.get(aData, i)).floatValue());
}
}
}
static void copyAToBd(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAToBd(
aData,
i,
aStrides,
bData,
j,
bStrides,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.setDouble(
bData,
j,
((Number) Array.get(aData, i)).doubleValue());
}
}
}
static void copyAToBF(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAToBF(
aData,
i,
aStrides,
bData,
j,
bStrides,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.setFloat(
bData,
j,
((Number) Array.get(aData, i)).floatValue());
Array.setFloat(
bData,
j + 1,
((Number) Array.get(aData, i + 1)).floatValue());
}
}
}
static void copyAToBD(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAToBD(
aData,
i,
aStrides,
bData,
j,
bStrides,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.setDouble(
bData,
j,
((Number) Array.get(aData, i)).doubleValue());
Array.setDouble(
bData,
j + 1,
((Number) Array.get(aData, i + 1)).doubleValue());
}
}
}
static void copyAToBO(final Object aData, final int aStart, final int[] aStrides,
final Object bData, final int bStart, final int[] bStrides, final int[] dimensions, final int depth) {
final int jMax = bStart + dimensions[depth] * bStrides[depth];
if (depth < dimensions.length - 1) {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
PyMultiarray.copyAToBO(
aData,
i,
aStrides,
bData,
j,
bStrides,
dimensions,
depth + 1);
}
} else {
for (int i = aStart, j = bStart; j != jMax; i += aStrides[depth], j += bStrides[depth]) {
Array.set(bData, j, Py.java2py(Array.get(aData, i)));
}
}
}
/**
* This converts data (which must be an array) to an array of bytes.
*/
static byte[] toByteArray(final Object data, final char type) {
try {
final java.io.ByteArrayOutputStream byteStream = new java.io.ByteArrayOutputStream();
final java.io.DataOutputStream dataStream = new java.io.DataOutputStream(
byteStream);
switch (type) {
case '1':
for (int i = 0; i < Array.getLength(data); i++) {
dataStream.writeByte(Array.getByte(data, i));
}
break;
case 's':
for (int i = 0; i < Array.getLength(data); i++) {
dataStream.writeShort(Array.getShort(data, i));
}
break;
case 'i':
for (int i = 0; i < Array.getLength(data); i++) {
dataStream.writeInt(Array.getInt(data, i));
}
break;
case 'l':
for (int i = 0; i < Array.getLength(data); i++) {
dataStream.writeLong(Array.getLong(data, i));
}
break;
case 'f':
case 'F':
for (int i = 0; i < Array.getLength(data); i++) {
dataStream.writeFloat(Array.getFloat(data, i));
}
break;
case 'd':
case 'D':
for (int i = 0; i < Array.getLength(data); i++) {
dataStream.writeDouble(Array.getDouble(data, i));
}
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
return byteStream.toByteArray();
} catch (final java.io.IOException e) {
throw Py.RuntimeError("ioexception:" + e.getMessage());
}
}
static Object fromByteArray(final byte[] bytes, final char type) {
if (bytes.length % PyMultiarray.typeToNBytes(type) != 0) { throw Py
.ValueError("array size must be a multiple of the type size"); }
try {
final java.io.ByteArrayInputStream byteStream = new java.io.ByteArrayInputStream(
bytes);
final java.io.DataInputStream dataStream = new java.io.DataInputStream(
byteStream);
final Object data = Array.newInstance(
PyMultiarray.typeToClass(type),
bytes.length / PyMultiarray.typeToNBytes(type));
switch (type) {
case '1':
for (int i = 0; i < Array.getLength(data); i++) {
Array.setByte(data, i, dataStream.readByte());
}
break;
case 's':
for (int i = 0; i < Array.getLength(data); i++) {
Array.setShort(data, i, dataStream.readShort());
}
break;
case 'i':
for (int i = 0; i < Array.getLength(data); i++) {
Array.setInt(data, i, dataStream.readInt());
}
break;
case 'l':
for (int i = 0; i < Array.getLength(data); i++) {
Array.setLong(data, i, dataStream.readLong());
}
break;
case 'f':
case 'F':
for (int i = 0; i < Array.getLength(data); i++) {
Array.setFloat(data, i, dataStream.readFloat());
}
break;
case 'd':
case 'D':
for (int i = 0; i < Array.getLength(data); i++) {
Array.setDouble(data, i, dataStream.readDouble());
}
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
return data;
} catch (final java.io.IOException e) {
throw Py.RuntimeError("ioexception:" + e.getMessage());
}
}
/**
* Return a string representation of the byte array corresponding to this
* array
*/
@Override public String toString() {
final StringBuffer buf = new StringBuffer("arrayObject(data=[");
final int dataLength = Array.getLength(this.data);
for (int i = 0; i < dataLength - 1; i++) {
buf.append((Array.get(this.data, i)).toString());
buf.append(", ");
}
if (dataLength > 0) {
buf.append((Array.get(this.data, dataLength - 1)).toString());
}
buf.append("], typecode=");
buf.append(this._typecode);
buf.append(", start=");
buf.append((new Integer(this.start)).toString());
buf.append(", dimensions=[");
for (int i = 0; i < this.dimensions.length - 1; i++) {
buf.append((new Integer(this.dimensions[i])).toString());
buf.append(",");
}
if (this.dimensions.length > 0) {
buf.append((new Integer(this.dimensions[this.dimensions.length - 1]))
.toString());
}
buf.append("], strides=[");
for (int i = 0; i < this.strides.length - 1; i++) {
buf.append((new Integer(this.strides[i])).toString());
buf.append(",");
}
if (this.strides.length > 0) {
buf.append((new Integer(this.strides[this.strides.length - 1]))
.toString());
}
buf.append("])");
return buf.toString();
}
//
// Functions used by __add__, etc that are NOT generated.
//
@Override public PyObject __radd__(final PyObject po) {
return this.__add__(po);
}
@Override public PyObject __rsub__(final PyObject po) {
return PyMultiarray.array(po).__sub__(this);
}
@Override public PyObject __rmul__(final PyObject po) {
return this.__mul__(po);
}
@Override public PyObject __rdiv__(final PyObject po) {
return PyMultiarray.array(po).__div__(this);
}
@Override public PyObject __rmod__(final PyObject po) {
return PyMultiarray.array(po).__mod__(this);
}
@Override public PyObject __divmod__(final PyObject po) {
final PyObject mod = this.__mod__(po);
final PyObject div = this.__sub__(mod).__div__(po);
return new PyTuple(new PyObject[] { div, mod });
}
@Override public PyObject __rdivmod__(final PyObject po) {
return PyMultiarray.array(po).__divmod__(this);
}
final static void mulComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
final float re = aData[sa] * bData[sb] - aData[sa + 1]
* bData[sb + 1];
rData[sr + 1] = aData[sa] * bData[sb + 1] + aData[sa + 1]
* bData[sb];
rData[sr] = re;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.mulComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void mulComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
final double re = aData[sa] * bData[sb] - aData[sa + 1]
* bData[sb + 1];
rData[sr + 1] = aData[sa] * bData[sb + 1] + aData[sa + 1]
* bData[sb];
rData[sr] = re;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.mulComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void divComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
final float den = bData[sb] * bData[sb] + bData[sb + 1]
* bData[sb + 1];
final float re = (aData[sa] * bData[sb] + aData[sa + 1]
* bData[sb + 1])
/ den;
rData[sr + 1] = (-aData[sa] * bData[sb + 1] + aData[sa + 1]
* bData[sb])
/ den;
rData[sr] = re;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.divComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void divComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
final double den = bData[sb] * bData[sb] + bData[sb + 1]
* bData[sb + 1];
final double re = (aData[sa] * bData[sb] + aData[sa + 1]
* bData[sb + 1])
/ den;
rData[sr + 1] = (-aData[sa] * bData[sb + 1] + aData[sa + 1]
* bData[sb])
/ den;
rData[sr] = re;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.divComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void addComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = aData[sa] + bData[sb];
rData[sr + 1] = aData[sa + 1] + bData[sb + 1];
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.addComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void addComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = aData[sa] + bData[sb];
rData[sr + 1] = aData[sa + 1] + bData[sb + 1];
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.addComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void subComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = aData[sa] - bData[sb];
rData[sr + 1] = aData[sa + 1] - bData[sb + 1];
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.subComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void subComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = aData[sa] - bData[sb];
rData[sr + 1] = aData[sa + 1] - bData[sb + 1];
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.subComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void modComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
final float reA = aData[sa], imA = aData[sa + 1], reB = bData[sb], imB = bData[sb + 1];
final float den = reB * reB + imB * imB;
final float n = (float) Math.floor((reA * reB + imA * imB)
/ den);
rData[sr] = reA - n * reB;
rData[sr + 1] = imA - n * imB;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.modComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void modComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
final double reA = aData[sa], imA = aData[sa + 1], reB = bData[sb], imB = bData[sb + 1];
final double den = reB * reB + imB * imB;
final double n = Math.floor((reA * reB + imA * imB) / den);
rData[sr] = reA - n * reB;
rData[sr + 1] = imA - n * imB;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.modComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void powComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
final PyComplex Z = (PyComplex) new PyComplex(
aData[sa],
aData[sa + 1]).__pow__(new PyComplex(
bData[sb],
bData[sb + 1]));
rData[sr] = (float) Z.real;
rData[sr + 1] = (float) Z.imag;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.powComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void powComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
final PyComplex Z = (PyComplex) new PyComplex(
aData[sa],
aData[sa + 1]).__pow__(new PyComplex(
bData[sb],
bData[sb + 1]));
rData[sr] = Z.real;
rData[sr + 1] = Z.imag;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.powComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void maxComplexFloat(final int sa, final PyMultiarray a, final int sb, final PyMultiarray b, final int sr, final PyMultiarray r, final int d) {
throw Py.ValueError("cannot perform ordered compare on complex numbers");
}
final static void maxComplexDouble(final int sa, final PyMultiarray a, final int sb, final PyMultiarray b, final int sr, final PyMultiarray r, final int d) {
throw Py.ValueError("cannot perform ordered compare on complex numbers");
}
final static void minComplexFloat(final int sa, final PyMultiarray a, final int sb, final PyMultiarray b, final int sr, final PyMultiarray r, final int d) {
throw Py.ValueError("cannot perform ordered compare on complex numbers");
}
final static void minComplexDouble(final int sa, final PyMultiarray a, final int sb, final PyMultiarray b, final int sr, final PyMultiarray r, final int d) {
throw Py.ValueError("cannot perform ordered compare on complex numbers");
}
final static void eqComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sa] = (aData[sa] == bData[sb] && aData[sa + 1] == bData[sb + 1]) ? 1
: 0;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.eqComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void eqComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sa] = (aData[sa] == bData[sb] && aData[sa + 1] == bData[sb + 1]) ? 1
: 0;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.eqComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void neqComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sa] = (aData[sa] == bData[sb] && aData[sa + 1] == bData[sb + 1]) ? 0
: 1;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.neqComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void neqComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sa] = (aData[sa] == bData[sb] && aData[sa + 1] == bData[sb + 1]) ? 0
: 1;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.neqComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void landComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sa] = ((aData[sa] != 0 || aData[sa + 1] != 0) && (bData[sb] != 0 || bData[sb + 1] != 0)) ? 1
: 0;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.landComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void landComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sa] = ((aData[sa] != 0 || aData[sa + 1] != 0) && (bData[sb] != 0 || bData[sb + 1] != 0)) ? 1
: 0;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.landComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void lorComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sa] = ((aData[sa] != 0 || aData[sa + 1] != 0) || (bData[sb] != 0 || bData[sb + 1] != 0)) ? 1
: 0;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lorComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
final static void lorComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], finalSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sa] = ((aData[sa] != 0 || aData[sa + 1] != 0) || (bData[sb] != 0 || bData[sb + 1] != 0)) ? 1
: 0;
}
} else {
for (; sr != finalSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lorComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lxorComplexFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sa] = ((aData[sa] != 0 || aData[sa + 1] != 0) ^ (bData[sb] != 0 || bData[sb + 1] != 0)) ? 1
: 0;
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lxorComplexFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lxorComplexDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sa] = ((aData[sa] != 0 || aData[sa + 1] != 0) ^ (bData[sb] != 0 || bData[sb + 1] != 0)) ? 1
: 0;
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lxorComplexDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
PyMultiarray absComplexFloat(final PyMultiarray a) {
// Assumes a continuous array.
final int length = PyMultiarray.shapeToNItems(a.dimensions);
final float[] aData = (float[]) a.data;
final float[] result = new float[length];
for (int i = a.start, j = 0; j < length; i += 2, j++) {
result[j] = (float) Math.sqrt(aData[i] * aData[i] + aData[i + 1]
* aData[i + 1]);
}
return new PyMultiarray(
result,
'f',
0,
new int[] { length },
new int[] { 1 });
}
PyMultiarray absComplexDouble(final PyMultiarray a) {
// Assumes a continuous array.
final int length = PyMultiarray.shapeToNItems(a.dimensions);
final double[] aData = (double[]) a.data;
final double[] result = new double[length];
for (int i = a.start, j = 0; j < length; i += 2, j++) {
result[j] = Math.sqrt(aData[i] * aData[i] + aData[i + 1]
* aData[i + 1]);
}
return new PyMultiarray(
result,
'd',
0,
new int[] { length },
new int[] { 1 });
}
PyMultiarray negComplexFloat(final PyMultiarray a) {
final float[] aData = (float[]) a.data;
for (int i = 0; i < aData.length; i++) {
aData[i] = -aData[i];
}
return a;
}
PyMultiarray negComplexDouble(final PyMultiarray a) {
final double[] aData = (double[]) a.data;
for (int i = 0; i < aData.length; i++) {
aData[i] = -aData[i];
}
return a;
}
// These pow routines adopted from CNumeric.
static final long pow(final long x, final long n) {
/* Overflow check: overflow will occur if log2(abs(x)) * n > nbits. */
final int nbits = 63;
long r = 1;
long p = x;
double logtwox;
long mask = 1;
if (n < 0) { throw Py.ValueError("Integer to a negative power"); }
if (x != 0) {
logtwox = Math.log(Math.abs((double) x)) / Math.log(2.0);
if (logtwox * n > nbits) { throw new PyException(
Py.ArithmeticError,
"Integer overflow in power."); }
}
while (mask > 0 && n >= mask) {
if ((n & mask) != 0) {
r *= p;
}
mask <<= 1;
p *= p;
}
return r;
}
static final int pow(final int x, final int n) {
/* Overflow check: overflow will occur if log2(abs(x)) * n > nbits. */
final int nbits = 31;
long r = 1;
long p = x;
double logtwox;
long mask = 1;
if (n < 0) { throw Py.ValueError("Integer to a negative power"); }
if (x != 0) {
logtwox = Math.log(Math.abs((double) x)) / Math.log(2.0);
if (logtwox * n > nbits) { throw new PyException(
Py.ArithmeticError,
"Integer overflow in power."); }
}
while (mask > 0 && n >= mask) {
if ((n & mask) != 0) {
r *= p;
}
mask <<= 1;
p *= p;
}
return (int) r;
}
static final short pow(final short x, final short n) {
/* Overflow check: overflow will occur if log2(abs(x)) * n > nbits. */
final int nbits = 15;
long r = 1;
long p = x;
double logtwox;
long mask = 1;
if (n < 0) { throw Py.ValueError("Integer to a negative power"); }
if (x != 0) {
logtwox = Math.log(Math.abs((double) x)) / Math.log(2.0);
if (logtwox * n > nbits) { throw new PyException(
Py.ArithmeticError,
"Integer overflow in power."); }
}
while (mask > 0 && n >= mask) {
if ((n & mask) != 0) {
r *= p;
}
mask <<= 1;
p *= p;
}
return (short) r;
}
static final byte pow(final byte x, final byte n) {
/* Overflow check: overflow will occur if log2(abs(x)) * n > nbits. */
final int nbits = 7;
long r = 1;
long p = x;
double logtwox;
long mask = 1;
if (n < 0) { throw Py.ValueError("Integer to a negative power"); }
if (x != 0) {
logtwox = Math.log(Math.abs((double) x)) / Math.log(2.0);
if (logtwox * n > nbits) { throw new PyException(
Py.ArithmeticError,
"Integer overflow in power."); }
}
while (mask > 0 && n >= mask) {
if ((n & mask) != 0) {
r *= p;
}
mask <<= 1;
p *= p;
}
return (byte) r;
}
static final double pow(final double x, final double n) {
return Math.pow(x, n);
}
static final float pow(final float x, final float n) {
return (float) Math.pow(x, n);
}
/*
* Generated code.
*/
// Begin generated code (genOps).
private final static void addByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (byte) (aData[sa] + bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.addByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void addShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (short) (aData[sa] + bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.addShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void addInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] + bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.addInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void addLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] + bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.addLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void addFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] + bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.addFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void addDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] + bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.addDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void addObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa]._add(bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.addObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
@Override public PyObject __add__(final PyObject o) {
return this.__add__(o, null);
}
PyObject __add__(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__add__(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.addByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.addShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.addInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.addLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.addFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.addDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.addObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.addComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.addComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void subByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (byte) (aData[sa] - bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.subByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void subShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (short) (aData[sa] - bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.subShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void subInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] - bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.subInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void subLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] - bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.subLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void subFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] - bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.subFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void subDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] - bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.subDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void subObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa]._sub(bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.subObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
@Override public PyObject __sub__(final PyObject o) {
return this.__sub__(o, null);
}
PyObject __sub__(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__sub__(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.subByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.subShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.subInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.subLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.subFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.subDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.subObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.subComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.subComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void mulByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (byte) (aData[sa] * bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.mulByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void mulShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (short) (aData[sa] * bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.mulShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void mulInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] * bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.mulInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void mulLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] * bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.mulLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void mulFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] * bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.mulFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void mulDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] * bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.mulDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void mulObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa]._mul(bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.mulObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
@Override public PyObject __mul__(final PyObject o) {
return this.__mul__(o, null);
}
PyObject __mul__(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__mul__(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.mulByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.mulShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.mulInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.mulLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.mulFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.mulDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.mulObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.mulComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.mulComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void divByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (byte) (aData[sa] / bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.divByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void divShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (short) (aData[sa] / bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.divShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void divInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] / bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.divInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void divLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] / bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.divLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void divFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] / bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.divFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void divDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] / bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.divDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void divObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa]._div(bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.divObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
@Override public PyObject __div__(final PyObject o) {
return this.__div__(o, null);
}
PyObject __div__(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = this.astype(type);
b = b.astype(type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
try {
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__div__(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.divByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.divShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.divInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.divLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.divFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.divDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.divObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.divComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.divComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
} catch (final java.lang.ArithmeticException ex) {
if (ex.getMessage().equals("/ by zero")) { throw Py
.ZeroDivisionError("divide by zero"); }
throw ex;
}
return PyMultiarray.returnValue(result);
}
private final static void modByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (byte) (aData[sa] % bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.modByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void modShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (short) (aData[sa] % bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.modShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void modInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] % bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.modInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void modLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] % bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.modLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void modFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] % bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.modFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void modDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] % bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.modDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void modObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa]._mod(bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.modObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
@Override public PyObject __mod__(final PyObject o) {
return this.__mod__(o, null);
}
PyObject __mod__(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__mod__(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.modByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.modShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.modInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.modLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.modFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.modDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.modObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.modComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.modComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void powByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (PyMultiarray.pow(aData[sa], bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.powByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void powShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (PyMultiarray.pow(aData[sa], bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.powShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void powInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (PyMultiarray.pow(aData[sa], bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.powInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void powLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (PyMultiarray.pow(aData[sa], bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.powLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void powFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (PyMultiarray.pow(aData[sa], bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.powFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void powDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (PyMultiarray.pow(aData[sa], bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.powDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void powObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa]._pow(bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.powObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
@Override public PyObject __pow__(final PyObject o) {
return this.__pow__(o, null);
}
PyObject __pow__(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__pow__(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.powByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.powShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.powInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.powLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.powFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.powDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.powObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.powComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.powComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void maxByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.maxByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void maxShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.maxShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void maxInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.maxInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void maxLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.maxLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void maxFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.maxFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void maxDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.maxDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param a First array
* @param b Second array
* @return Maximum values from the two arrays
*/
public static PyObject myMax(final PyObject a, final PyObject b) {
return b._gt(a).__nonzero__() ? b : a;
}
/**
* @param a First array
* @param b Second array
* @return Minimum values from the two arrays
*/
public static PyObject myMin(final PyObject a, final PyObject b) {
return b._lt(a).__nonzero__() ? b : a;
}
private final static void maxObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr)
{
rData[sr] = PyMultiarray.myMax(aData[sa], bData[sb]); // (PyObject)(__builtin__.max(new
// PyObject
// []
// {aData[sa],
// bData[sb]}));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.maxObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Maximum value from the array
*/
public PyObject __max(final PyObject o) {
return this.__max(o, null);
}
PyObject __max(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(Py.Ellipsis, a
.__max(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.maxByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.maxShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.maxInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.maxLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.maxFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.maxDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.maxObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.maxComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.maxComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void minByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.minByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void minShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.minShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void minInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.minInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void minLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.minLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void minFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final float[] rData = (float[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.minFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void minDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final double[] rData = (double[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? aData[sa] : bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.minDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void minObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr)
{
rData[sr] = PyMultiarray.myMin(aData[sa], bData[sb]); // (PyObject)(__builtin__.min(new
// PyObject
// []
// {aData[sa],
// bData[sb]}));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.minObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Minimum value from the array
*/
public PyObject __min(final PyObject o) {
return this.__min(o, null);
}
PyObject __min(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(Py.Ellipsis, a
.__min(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.minByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.minShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.minInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.minLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.minFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.minDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.minObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.minComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.minComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void eqByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] == bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.eqByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void eqShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] == bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.eqShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void eqInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] == bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.eqInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void eqLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] == bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.eqLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void eqFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] == bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.eqFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void eqDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] == bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.eqDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void eqObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((__builtin__.cmp(aData[sa], bData[sb]) == 0) ? 1
: 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.eqObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Where the two arrays are equal
*/
public PyObject __eq(final PyObject o) {
return this.__eq(o, null);
}
PyObject __eq(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, 'i');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(Py.Ellipsis, a.__eq(PyMultiarray.stretchAxes(b))
.__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.eqByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.eqShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.eqInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.eqLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.eqFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.eqDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.eqObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.eqComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.eqComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void neqByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] != bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.neqByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void neqShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] != bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.neqShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void neqInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] != bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.neqInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void neqLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] != bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.neqLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void neqFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] != bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.neqFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void neqDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] != bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.neqDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void neqObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((__builtin__.cmp(aData[sa], bData[sb]) != 0) ? 1
: 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.neqObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Where the two arrays are not equal
*/
public PyObject __neq(final PyObject o) {
return this.__neq(o, null);
}
PyObject __neq(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, 'i');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(Py.Ellipsis, a
.__neq(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.neqByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.neqShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.neqInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.neqLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.neqFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.neqDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.neqObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.neqComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.neqComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void leByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] <= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.leByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void leShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] <= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.leShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void leInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] <= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.leInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void leLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] <= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.leLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void leFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] <= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.leFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void leDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] <= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.leDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void leObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((__builtin__.cmp(aData[sa], bData[sb]) <= 0) ? 1
: 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.leObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Where less than or equal
*/
public PyObject __le(final PyObject o) {
return this.__le(o, null);
}
PyObject __le(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, 'i');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(Py.Ellipsis, a.__le(PyMultiarray.stretchAxes(b))
.__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.leByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.leShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.leInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.leLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.leFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.leDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.leObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
throw Py.ValueError("le not supported for type ComplexFloat");
case 'D':
throw Py.ValueError("le not supported for type ComplexDouble");
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void ltByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.ltByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void ltShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.ltShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void ltInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.ltInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void ltLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.ltLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void ltFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.ltFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void ltDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] < bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.ltDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void ltObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((__builtin__.cmp(aData[sa], bData[sb]) < 0) ? 1
: 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.ltObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Where less than
*/
public PyObject __lt(final PyObject o) {
return this.__lt(o, null);
}
PyObject __lt(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, 'i');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(Py.Ellipsis, a.__lt(PyMultiarray.stretchAxes(b))
.__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.ltByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.ltShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.ltInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.ltLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.ltFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.ltDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.ltObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
throw Py.ValueError("lt not supported for type ComplexFloat");
case 'D':
throw Py.ValueError("lt not supported for type ComplexDouble");
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void geByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] >= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.geByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void geShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] >= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.geShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void geInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] >= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.geInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void geLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] >= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.geLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void geFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] >= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.geFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void geDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] >= bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.geDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void geObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((__builtin__.cmp(aData[sa], bData[sb]) >= 0) ? 1
: 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.geObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Where greater than or equal
*/
public PyObject __ge(final PyObject o) {
return this.__ge(o, null);
}
PyObject __ge(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, 'i');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(Py.Ellipsis, a.__ge(PyMultiarray.stretchAxes(b))
.__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.geByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.geShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.geInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.geLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.geFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.geDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.geObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
throw Py.ValueError("ge not supported for type ComplexFloat");
case 'D':
throw Py.ValueError("ge not supported for type ComplexDouble");
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void gtByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.gtByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void gtShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.gtShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void gtInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.gtInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void gtLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.gtLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void gtFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.gtFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void gtDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa] > bData[sb]) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.gtDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void gtObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((__builtin__.cmp(aData[sa], bData[sb]) > 0) ? 1
: 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.gtObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Where greater than
*/
public PyObject __gt(final PyObject o) {
return this.__gt(o, null);
}
PyObject __gt(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, 'i');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(Py.Ellipsis, a.__gt(PyMultiarray.stretchAxes(b))
.__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.gtByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.gtShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.gtInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.gtLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.gtFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.gtDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.gtObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
throw Py.ValueError("gt not supported for type ComplexFloat");
case 'D':
throw Py.ValueError("gt not supported for type ComplexDouble");
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void landByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) & (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.landByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void landShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) & (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.landShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void landInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) & (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.landInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void landLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) & (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.landLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void landFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) & (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.landFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void landDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) & (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.landDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void landObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa].__nonzero__() & bData[sb].__nonzero__()) ? 1
: 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.landObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Logical and
*/
public PyObject __land(final PyObject o) {
return this.__land(o, null);
}
PyObject __land(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, 'i');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__land(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.landByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.landShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.landInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.landLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.landFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.landDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.landObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.landComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.landComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void lorByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) | (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lorByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lorShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) | (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lorShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lorInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) | (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lorInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lorLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) | (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lorLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lorFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) | (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lorFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lorDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) | (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lorDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lorObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa].__nonzero__() | bData[sb].__nonzero__()) ? 1
: 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lorObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Logical or
*/
public PyObject __lor(final PyObject o) {
return this.__lor(o, null);
}
PyObject __lor(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, 'i');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(Py.Ellipsis, a
.__lor(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.lorByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.lorShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.lorInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.lorLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.lorFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.lorDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.lorObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.lorComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.lorComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void lxorByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) ^ (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lxorByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lxorShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) ^ (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lxorShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lxorInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) ^ (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lxorInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lxorLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) ^ (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lxorLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lxorFloat(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final float[] aData = (float[]) a.data, bData = (float[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) ^ (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lxorFloat(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lxorDouble(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final double[] aData = (double[]) a.data, bData = (double[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (((aData[sa] != 0) ^ (bData[sb] != 0)) ? 1 : 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lxorDouble(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void lxorObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = ((aData[sa].__nonzero__() ^ bData[sb].__nonzero__()) ? 1
: 0);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.lxorObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
/**
* @param o Input array
* @return Logical exclusive-or
*/
public PyObject __lxor(final PyObject o) {
return this.__lxor(o, null);
}
PyObject __lxor(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, 'i');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__lxor(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.lxorByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.lxorShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.lxorInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.lxorLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
PyMultiarray.lxorFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'd':
PyMultiarray.lxorDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'O':
PyMultiarray.lxorObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
PyMultiarray.lxorComplexFloat(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'D':
PyMultiarray.lxorComplexDouble(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void andByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (byte) (aData[sa] & bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.andByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void andShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (short) (aData[sa] & bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.andShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void andInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] & bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.andInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void andLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] & bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.andLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void andObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa].__and__(bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.andObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
@Override public PyObject __and__(final PyObject o) {
return this.__and__(o, null);
}
PyObject __and__(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__and__(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.andByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.andShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.andInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.andLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
throw Py.ValueError("and not supported for type Float");
case 'd':
throw Py.ValueError("and not supported for type Double");
case 'O':
PyMultiarray.andObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
throw Py.ValueError("and not supported for type ComplexFloat");
case 'D':
throw Py.ValueError("and not supported for type ComplexDouble");
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void orByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (byte) (aData[sa] | bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.orByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void orShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (short) (aData[sa] | bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.orShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void orInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] | bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.orInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void orLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] | bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.orLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void orObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa].__or__(bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.orObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
@Override public PyObject __or__(final PyObject o) {
return this.__or__(o, null);
}
PyObject __or__(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__or__(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.orByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.orShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.orInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.orLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
throw Py.ValueError("or not supported for type Float");
case 'd':
throw Py.ValueError("or not supported for type Double");
case 'O':
PyMultiarray.orObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
throw Py.ValueError("or not supported for type ComplexFloat");
case 'D':
throw Py.ValueError("or not supported for type ComplexDouble");
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
private final static void xorByte(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final byte[] aData = (byte[]) a.data, bData = (byte[]) b.data;
final byte[] rData = (byte[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (byte) (aData[sa] ^ bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.xorByte(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void xorShort(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final short[] aData = (short[]) a.data, bData = (short[]) b.data;
final short[] rData = (short[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (short) (aData[sa] ^ bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.xorShort(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void xorInt(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final int[] aData = (int[]) a.data, bData = (int[]) b.data;
final int[] rData = (int[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] ^ bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.xorInt(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void xorLong(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final long[] aData = (long[]) a.data, bData = (long[]) b.data;
final long[] rData = (long[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa] ^ bData[sb]);
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.xorLong(sa, a, sb, b, sr, r, d + 1);
}
}
}
private final static void xorObject(int sa, final PyMultiarray a, int sb, final PyMultiarray b, int sr, final PyMultiarray r, final int d) {
final int dsa = a.strides[d], dsb = b.strides[d], dsr = r.strides[d], maxSr = sr
+ r.dimensions[d] * r.strides[d];
if (d == r.dimensions.length - 1) {
final PyObject[] aData = (PyObject[]) a.data, bData = (PyObject[]) b.data;
final PyObject[] rData = (PyObject[]) r.data;
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
rData[sr] = (aData[sa].__xor__(bData[sb]));
}
} else {
for (; sr != maxSr; sa += dsa, sb += dsb, sr += dsr) {
PyMultiarray.xorObject(sa, a, sb, b, sr, r, d + 1);
}
}
}
@Override public PyObject __xor__(final PyObject o) {
return this.__xor__(o, null);
}
PyObject __xor__(final PyObject o, PyMultiarray result) {
PyMultiarray a, b = PyMultiarray.asarray(o);
final char type = PyMultiarray.commonType(this._typecode, b._typecode);
a = PyMultiarray.asarray(this, type);
b = PyMultiarray.asarray(b, type);
a = PyMultiarray.stretchAxes(a, b);
b = PyMultiarray.stretchAxes(b, this);
if (result == null) {
result = PyMultiarray.getResultArray(a, b, '\0');
} else {
PyMultiarray.checkResultArray(result, a, b);
}
if (result.dimensions.length == 0) {
result.__setitem__(
Py.Ellipsis,
a.__xor__(PyMultiarray.stretchAxes(b)).__getitem__(0));
} else {
switch (type) {
case '1':
PyMultiarray.xorByte(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 's':
PyMultiarray.xorShort(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'i':
PyMultiarray.xorInt(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'l':
PyMultiarray.xorLong(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'f':
throw Py.ValueError("xor not supported for type Float");
case 'd':
throw Py.ValueError("xor not supported for type Double");
case 'O':
PyMultiarray.xorObject(
a.start,
a,
b.start,
b,
result.start,
result,
0);
break;
case 'F':
throw Py.ValueError("xor not supported for type ComplexFloat");
case 'D':
throw Py.ValueError("xor not supported for type ComplexDouble");
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
}
return PyMultiarray.returnValue(result);
}
@Override public boolean isNumberType() throws PyIgnoreMethodTag {
return true;
} // so abs() will work
@Override public PyObject __abs__() {
return PyMultiarray.returnValue(this.__abs__(PyMultiarray.array(this)));
}
PyMultiarray __abs__(PyMultiarray a) {
if (!a.isContiguous) { throw Py
.ValueError("internal __abs__ requires contiguous matrix as argument"); }
// final int maxI = a.start + PyMultiarray.shapeToNItems(a.dimensions);
switch (a._typecode) {
case '1':
final byte aData1[] = (byte[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aData1[i] = (byte) ((aData1[i] > 0) ? aData1[i] : -aData1[i]);
}
break;
case 's':
final short aDatas[] = (short[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatas[i] = (short) ((aDatas[i] > 0) ? aDatas[i] : -aDatas[i]);
}
break;
case 'i':
final int aDatai[] = (int[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatai[i] = ((aDatai[i] > 0) ? aDatai[i] : -aDatai[i]);
}
break;
case 'l':
final long aDatal[] = (long[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatal[i] = ((aDatal[i] > 0) ? aDatal[i] : -aDatal[i]);
}
break;
case 'f':
final float aDataf[] = (float[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDataf[i] = ((aDataf[i] > 0) ? aDataf[i] : -aDataf[i]);
}
break;
case 'd':
final double aDatad[] = (double[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatad[i] = ((aDatad[i] > 0) ? aDatad[i] : -aDatad[i]);
}
break;
case 'O':
final PyObject aDataO[] = (PyObject[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDataO[i] = (aDataO[i].__abs__());
}
break;
case 'F':
a = this.absComplexFloat(a);
break;
case 'D':
a = this.absComplexDouble(a);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
return a;
}
@Override public PyObject __neg__() {
return PyMultiarray.returnValue(this.__neg__(PyMultiarray.array(this)));
}
PyMultiarray __neg__(PyMultiarray a) {
if (!a.isContiguous) { throw Py
.ValueError("internal __neg__ requires contiguous matrix as argument"); }
// final int maxI = a.start + PyMultiarray.shapeToNItems(a.dimensions);
switch (a._typecode) {
case '1':
final byte aData1[] = (byte[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aData1[i] = (byte) (-aData1[i]);
}
break;
case 's':
final short aDatas[] = (short[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatas[i] = (short) (-aDatas[i]);
}
break;
case 'i':
final int aDatai[] = (int[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatai[i] = (-aDatai[i]);
}
break;
case 'l':
final long aDatal[] = (long[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatal[i] = (-aDatal[i]);
}
break;
case 'f':
final float aDataf[] = (float[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDataf[i] = (-aDataf[i]);
}
break;
case 'd':
final double aDatad[] = (double[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatad[i] = (-aDatad[i]);
}
break;
case 'O':
final PyObject aDataO[] = (PyObject[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDataO[i] = (aDataO[i].__neg__());
}
break;
case 'F':
a = this.negComplexFloat(a);
break;
case 'D':
a = this.negComplexDouble(a);
break;
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
return a;
}
@Override public PyObject __not__() {
return PyMultiarray.returnValue(this.__not__(PyMultiarray.array(this)));
}
PyMultiarray __not__(final PyMultiarray a) {
if (!a.isContiguous) { throw Py
.ValueError("internal __not__ requires contiguous matrix as argument"); }
// final int maxI = a.start + PyMultiarray.shapeToNItems(a.dimensions);
switch (a._typecode) {
case '1':
final byte aData1[] = (byte[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aData1[i] = (byte) (~aData1[i]);
}
break;
case 's':
final short aDatas[] = (short[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatas[i] = (short) (~aDatas[i]);
}
break;
case 'i':
final int aDatai[] = (int[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatai[i] = (~aDatai[i]);
}
break;
case 'l':
final long aDatal[] = (long[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDatal[i] = (~aDatal[i]);
}
break;
case 'f':
throw Py.ValueError("not not supported for type Float");
case 'd':
throw Py.ValueError("not not supported for type Double");
case 'O':
final PyObject aDataO[] = (PyObject[]) a.data;
for (int i = 0; i < Array.getLength(a.data); i++) {
aDataO[i] = (aDataO[i].__not__());
}
break;
case 'F':
throw Py.ValueError("not not supported for type ComplexFloat");
case 'D':
throw Py.ValueError("not not supported for type ComplexDouble");
default:
throw Py.ValueError("typecode must be in [1silfFdDO]");
}
return a;
}
// End generated code (genOps).
}
Ads help maintain this website.