Java Index.incr方法代码示例

import ucar.ma2.Index; //导入方法依赖的package包/类
/**
 * Set section
 *
 * @param a Array a
 * @param ranges Ranges
 * @param v Array value
 * @return Result array
 * @throws InvalidRangeException
 */
public static Array setSection(Array a, List<Range> ranges, Array v) throws InvalidRangeException {
    Array r = a.section(ranges);
    IndexIterator iter = r.getIndexIterator();
    //int[] current;
    Index index = v.getIndex();
    while (iter.hasNext()) {
        iter.next();
        //current = iter.getCurrentCounter();
        //index.set(current);
        iter.setObjectCurrent(v.getObject(index));
        index.incr();
    }
    r = Array.factory(a.getDataType(), a.getShape(), r.getStorage());
    return r;
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
/**
 * Returns an estimate of the pth percentile of the values in the array along an axis.
 * @param a Input array
 * @param p The percentile value to compute
 * @param axis The axis
 * @return The pth percentile
 * @throws InvalidRangeException 
 */
public static Array percentile(Array a, double p, int axis) throws InvalidRangeException{
    int[] dataShape = a.getShape();
    int[] shape = new int[dataShape.length - 1];
    int idx;
    for (int i = 0; i < dataShape.length; i++) {
        idx = i;
        if (idx == axis) {
            continue;
        } else if (idx > axis) {
            idx -= 1;
        }
        shape[idx] = dataShape[i];
    }
    Array r = Array.factory(DataType.DOUBLE, shape);
    Index indexr = r.getIndex();
    int[] current;
    for (int i = 0; i < r.getSize(); i++) {
        current = indexr.getCurrentCounter();
        List<Range> ranges = new ArrayList<>();
        for (int j = 0; j < dataShape.length; j++) {
            if (j == axis) {
                ranges.add(new Range(0, dataShape[j] - 1, 1));
            } else {
                idx = j;
                if (idx > axis) {
                    idx -= 1;
                }
                ranges.add(new Range(current[idx], current[idx], 1));
            }
        }
        Array aa = ArrayMath.section(a, ranges);
        double[] v = (double[])aa.get1DJavaArray(Double.class);
        double q = StatUtils.percentile(v, p);
        r.setDouble(i, q);
        indexr.incr();
    }

    return r;
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
/**
 * Concatenate two arrays to one array along a axis
 *
 * @param a Array a
 * @param b Array b
 * @param axis The axis
 * @return Concatenated array
 * @throws ucar.ma2.InvalidRangeException
 */
public static Array concatenate(Array a, Array b, Integer axis) throws InvalidRangeException {
    int n = a.getRank();
    int[] shape = a.getShape();
    if (axis == -1) {
        axis = n - 1;
    }
    int nn = shape[axis];
    int[] bshape = b.getShape();
    int[] nshape = new int[n];
    for (int i = 0; i < n; i++) {
        if (i == axis) {
            nshape[i] = shape[i] + bshape[i];
        } else {
            nshape[i] = shape[i];
        }
    }
    Array r = Array.factory(a.getDataType(), nshape);
    Index indexr = r.getIndex();
    Index indexa = a.getIndex();
    Index indexb = b.getIndex();
    int[] current;
    for (int i = 0; i < r.getSize(); i++) {
        current = indexr.getCurrentCounter();
        if (current[axis] < nn) {
            indexa.set(current);
            r.setObject(indexr, a.getObject(indexa));
        } else {
            current[axis] = current[axis - nn];
            indexb.set(current);
            r.setObject(indexr, b.getObject(indexb));
        }
        indexr.incr();
    }

    return r;
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
private static Array addInt_bak(Array a, Array b) {
    int broadcast = broadcastCheck(a, b);
    if (broadcast != -1) {
        int[] shape;
        if (broadcast == 0) {
            shape = a.getShape();
        } else {
            shape = broadcast(a, b);
        }
        Array r = Array.factory(DataType.INT, shape);
        Index index = r.getIndex();
        Index aindex = a.getIndex();
        Index bindex = b.getIndex();
        int n = r.getRank();
        int na = a.getRank();
        int nb = b.getRank();
        int[] current;
        for (int i = 0; i < r.getSize(); i++) {
            current = index.getCurrentCounter();
            setIndex(broadcast, aindex, bindex, current, n, na, nb);
            if (a.getInt(aindex) == Integer.MIN_VALUE || b.getInt(bindex) == Integer.MIN_VALUE) {
                r.setInt(i, Integer.MIN_VALUE);
            } else {
                r.setInt(i, a.getInt(aindex) + b.getInt(bindex));
            }
            index.incr();
        }
        return r;
    } else {
        return null;
    }
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
private static Array addInt(Array a, Array b) {
    int broadcast = broadcastCheck(a, b);
    switch (broadcast) {
        case 0:
            Array r = Array.factory(DataType.INT, a.getShape());
            for (int i = 0; i < a.getSize(); i++) {
                if (a.getInt(i) == Integer.MIN_VALUE || b.getInt(i) == Integer.MIN_VALUE) {
                    r.setInt(i, Integer.MIN_VALUE);
                } else {
                    r.setInt(i, a.getInt(i) + b.getInt(i));
                }
            }
            return r;
        case 1:
            int[] shape = broadcast(a, b);
            r = Array.factory(DataType.INT, shape);
            Index index = r.getIndex();
            Index aindex = a.getIndex();
            Index bindex = b.getIndex();
            int n = r.getRank();
            int na = a.getRank();
            int nb = b.getRank();
            int[] current;
            for (int i = 0; i < r.getSize(); i++) {
                current = index.getCurrentCounter();
                setIndex(aindex, bindex, current, n, na, nb);
                if (a.getInt(aindex) == Integer.MIN_VALUE || b.getInt(bindex) == Integer.MIN_VALUE) {
                    r.setInt(i, Integer.MIN_VALUE);
                } else {
                    r.setInt(i, a.getInt(aindex) + b.getInt(bindex));
                }
                index.incr();
            }
            return r;
        default:
            return null;
    }
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
private static Array addFloat(Array a, Array b) {
    int broadcast = broadcastCheck(a, b);
    switch (broadcast) {
        case 0:
            Array r = Array.factory(DataType.FLOAT, a.getShape());
            for (int i = 0; i < a.getSize(); i++) {
                if (Float.isNaN(a.getFloat(i)) || Float.isNaN(b.getFloat(i))) {
                    r.setFloat(i, Float.NaN);
                } else {
                    r.setFloat(i, a.getFloat(i) + b.getFloat(i));
                }
            }
            return r;
        case 1:
            int[] shape = broadcast(a, b);
            r = Array.factory(DataType.FLOAT, shape);
            Index index = r.getIndex();
            Index aindex = a.getIndex();
            Index bindex = b.getIndex();
            int n = r.getRank();
            int na = a.getRank();
            int nb = b.getRank();
            int[] current;
            for (int i = 0; i < r.getSize(); i++) {
                current = index.getCurrentCounter();
                setIndex(aindex, bindex, current, n, na, nb);
                if (Float.isNaN(a.getFloat(aindex)) || Float.isNaN(b.getFloat(bindex))) {
                    r.setFloat(i, Float.NaN);
                } else {
                    r.setFloat(i, a.getFloat(aindex) + b.getFloat(bindex));
                }
                index.incr();
            }
            return r;
        default:
            return null;
    }
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
/**
 * Compute standard deviation value of an array along an axis (dimension)
 *
 * @param a Array a
 * @param axis Axis
 * @return Standard deviation value array
 * @throws ucar.ma2.InvalidRangeException
 */
public static Array std(Array a, int axis) throws InvalidRangeException {
    int[] dataShape = a.getShape();
    int[] shape = new int[dataShape.length - 1];
    int idx;
    for (int i = 0; i < dataShape.length; i++) {
        idx = i;
        if (idx == axis) {
            continue;
        } else if (idx > axis) {
            idx -= 1;
        }
        shape[idx] = dataShape[i];
    }
    Array r = Array.factory(DataType.DOUBLE, shape);
    double mean;
    Index indexr = r.getIndex();
    int[] current;
    for (int i = 0; i < r.getSize(); i++) {
        current = indexr.getCurrentCounter();
        List<Range> ranges = new ArrayList<>();
        for (int j = 0; j < dataShape.length; j++) {
            if (j == axis) {
                ranges.add(new Range(0, dataShape[j] - 1, 1));
            } else {
                idx = j;
                if (idx > axis) {
                    idx -= 1;
                }
                ranges.add(new Range(current[idx], current[idx], 1));
            }
        }
        mean = std(a, ranges);
        r.setDouble(i, mean);
        indexr.incr();
    }

    return r;
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
/**
 * Compute median value of an array along an axis (dimension)
 *
 * @param a Array a
 * @param axis Axis
 * @return Median value array
 * @throws ucar.ma2.InvalidRangeException
 */
public static Array median(Array a, int axis) throws InvalidRangeException {
    int[] dataShape = a.getShape();
    int[] shape = new int[dataShape.length - 1];
    int idx;
    for (int i = 0; i < dataShape.length; i++) {
        idx = i;
        if (idx == axis) {
            continue;
        } else if (idx > axis) {
            idx -= 1;
        }
        shape[idx] = dataShape[i];
    }
    Array r = Array.factory(DataType.DOUBLE, shape);
    double mean;
    Index indexr = r.getIndex();
    int[] current;
    for (int i = 0; i < r.getSize(); i++) {
        current = indexr.getCurrentCounter();
        List<Range> ranges = new ArrayList<>();
        for (int j = 0; j < dataShape.length; j++) {
            if (j == axis) {
                ranges.add(new Range(0, dataShape[j] - 1, 1));
            } else {
                idx = j;
                if (idx > axis) {
                    idx -= 1;
                }
                ranges.add(new Range(current[idx], current[idx], 1));
            }
        }
        mean = median(a, ranges);
        r.setDouble(i, mean);
        indexr.incr();
    }

    return r;
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
private static Array subDouble(Array a, Array b) {
    int broadcast = broadcastCheck(a, b);
    switch (broadcast) {
        case 0:
            Array r = Array.factory(DataType.DOUBLE, a.getShape());
            for (int i = 0; i < a.getSize(); i++) {
                if (Double.isNaN(a.getDouble(i)) || Double.isNaN(b.getDouble(i))) {
                    r.setDouble(i, Double.NaN);
                } else {
                    r.setDouble(i, a.getDouble(i) - b.getDouble(i));
                }
            }
            return r;
        case 1:
            int[] shape = broadcast(a, b);
            r = Array.factory(DataType.DOUBLE, shape);
            Index index = r.getIndex();
            Index aindex = a.getIndex();
            Index bindex = b.getIndex();
            int n = r.getRank();
            int na = a.getRank();
            int nb = b.getRank();
            int[] current;
            for (int i = 0; i < r.getSize(); i++) {
                current = index.getCurrentCounter();
                setIndex(aindex, bindex, current, n, na, nb);
                if (Double.isNaN(a.getDouble(aindex)) || Double.isNaN(b.getDouble(bindex))) {
                    r.setDouble(i, Double.NaN);
                } else {
                    r.setDouble(i, a.getDouble(aindex) - b.getDouble(bindex));
                }
                index.incr();
            }
            return r;
        default:
            return null;
    }                
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
private static Array mulInt(Array a, Array b) {
    int broadcast = broadcastCheck(a, b);
    switch (broadcast) {
        case 0:
            Array r = Array.factory(DataType.INT, a.getShape());
            for (int i = 0; i < a.getSize(); i++) {
                if (a.getInt(i) == Integer.MIN_VALUE || b.getInt(i) == Integer.MIN_VALUE) {
                    r.setInt(i, Integer.MIN_VALUE);
                } else {
                    r.setInt(i, a.getInt(i) * b.getInt(i));
                }
            }
            return r;
        case 1:
            int[] shape = broadcast(a, b);
            r = Array.factory(DataType.INT, shape);
            Index index = r.getIndex();
            Index aindex = a.getIndex();
            Index bindex = b.getIndex();
            int n = r.getRank();
            int na = a.getRank();
            int nb = b.getRank();
            int[] current;
            for (int i = 0; i < r.getSize(); i++) {
                current = index.getCurrentCounter();
                setIndex(aindex, bindex, current, n, na, nb);
                if (a.getInt(aindex) == Integer.MIN_VALUE || b.getInt(bindex) == Integer.MIN_VALUE) {
                    r.setInt(i, Integer.MIN_VALUE);
                } else {
                    r.setInt(i, a.getInt(aindex) * b.getInt(bindex));
                }
                index.incr();
            }
            return r;
        default:
            return null;
    }        
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
private static Array mulFloat(Array a, Array b) {
    int broadcast = broadcastCheck(a, b);
    switch (broadcast) {
        case 0:
            Array r = Array.factory(DataType.FLOAT, a.getShape());
            for (int i = 0; i < a.getSize(); i++) {
                if (Float.isNaN(a.getFloat(i)) || Float.isNaN(b.getFloat(i))) {
                    r.setFloat(i, Float.NaN);
                } else {
                    r.setFloat(i, a.getFloat(i) * b.getFloat(i));
                }
            }
            return r;
        case 1:
            int[] shape = broadcast(a, b);
            r = Array.factory(DataType.FLOAT, shape);
            Index index = r.getIndex();
            Index aindex = a.getIndex();
            Index bindex = b.getIndex();
            int n = r.getRank();
            int na = a.getRank();
            int nb = b.getRank();
            int[] current;
            for (int i = 0; i < r.getSize(); i++) {
                current = index.getCurrentCounter();
                setIndex(aindex, bindex, current, n, na, nb);
                if (Float.isNaN(a.getFloat(aindex)) || Float.isNaN(b.getFloat(bindex))) {
                    r.setFloat(i, Float.NaN);
                } else {
                    r.setFloat(i, a.getFloat(aindex) * b.getFloat(bindex));
                }
                index.incr();
            }
            return r;
        default:
            return null;
    }        
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
private static Array mulDouble(Array a, Array b) {
    int broadcast = broadcastCheck(a, b);
    switch (broadcast) {
        case 0:
            Array r = Array.factory(DataType.DOUBLE, a.getShape());
            for (int i = 0; i < a.getSize(); i++) {
                if (Double.isNaN(a.getDouble(i)) || Double.isNaN(b.getDouble(i))) {
                    r.setDouble(i, Double.NaN);
                } else {
                    r.setDouble(i, a.getDouble(i) * b.getDouble(i));
                }
            }
            return r;
        case 1:
            int[] shape = broadcast(a, b);
            r = Array.factory(DataType.DOUBLE, shape);
            Index index = r.getIndex();
            Index aindex = a.getIndex();
            Index bindex = b.getIndex();
            int n = r.getRank();
            int na = a.getRank();
            int nb = b.getRank();
            int[] current;
            for (int i = 0; i < r.getSize(); i++) {
                current = index.getCurrentCounter();
                setIndex(aindex, bindex, current, n, na, nb);
                if (Double.isNaN(a.getDouble(aindex)) || Double.isNaN(b.getDouble(bindex))) {
                    r.setDouble(i, Double.NaN);
                } else {
                    r.setDouble(i, a.getDouble(aindex) * b.getDouble(bindex));
                }
                index.incr();
            }
            return r;
        default:
            return null;
    }          
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
private static Array divInt(Array a, Array b) {
    int broadcast = broadcastCheck(a, b);
    switch (broadcast) {
        case 0:
            Array r = Array.factory(DataType.INT, a.getShape());
            for (int i = 0; i < a.getSize(); i++) {
                if (a.getInt(i) == Integer.MIN_VALUE || b.getInt(i) == Integer.MIN_VALUE) {
                    r.setInt(i, Integer.MIN_VALUE);
                } else {
                    r.setInt(i, a.getInt(i) / b.getInt(i));
                }
            }
            return r;
        case 1:
            int[] shape = broadcast(a, b);
            r = Array.factory(DataType.INT, shape);
            Index index = r.getIndex();
            Index aindex = a.getIndex();
            Index bindex = b.getIndex();
            int n = r.getRank();
            int na = a.getRank();
            int nb = b.getRank();
            int[] current;
            for (int i = 0; i < r.getSize(); i++) {
                current = index.getCurrentCounter();
                setIndex(aindex, bindex, current, n, na, nb);
                if (a.getInt(aindex) == Integer.MIN_VALUE || b.getInt(bindex) == Integer.MIN_VALUE) {
                    r.setInt(i, Integer.MIN_VALUE);
                } else {
                    r.setInt(i, a.getInt(aindex) / b.getInt(bindex));
                }
                index.incr();
            }
            return r;
        default:
            return null;
    }
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
/**
 * Performs a centered difference operation on a grid data along one
 * dimension direction
 *
 * @param data The grid data
 * @param dimIdx Direction dimension index
 * @return Result grid data
 */
public static Array cdiff(Array data, int dimIdx) {
    Array r = Array.factory(DataType.DOUBLE, data.getShape());
    Index index = data.getIndex();
    Index indexr = r.getIndex();
    int[] shape = data.getShape();
    int[] current, cc;
    double a, b;
    for (int i = 0; i < r.getSize(); i++) {
        current = indexr.getCurrentCounter();
        if (current[dimIdx] == 0 || current[dimIdx] == shape[dimIdx] - 1) {
            r.setDouble(indexr, Double.NaN);
        } else {
            cc = Arrays.copyOf(current, current.length);
            cc[dimIdx] = cc[dimIdx] - 1;
            index.set(cc);
            a = data.getDouble(index);
            cc[dimIdx] = cc[dimIdx] + 2;
            index.set(cc);
            b = data.getDouble(index);
            if (Double.isNaN(a) || Double.isNaN(b)) {
                r.setDouble(indexr, Double.NaN);
            } else {
                r.setDouble(indexr, a - b);
            }
        }
        indexr.incr();
    }

    return r;
}
 

import ucar.ma2.Index; //导入方法依赖的package包/类
private static Array divDouble(Array a, Array b) {
    int broadcast = broadcastCheck(a, b);
    switch (broadcast) {
        case 0:
            Array r = Array.factory(DataType.DOUBLE, a.getShape());
            for (int i = 0; i < a.getSize(); i++) {
                if (Double.isNaN(a.getDouble(i)) || Double.isNaN(b.getDouble(i))) {
                    r.setDouble(i, Double.NaN);
                } else {
                    r.setDouble(i, a.getDouble(i) / b.getDouble(i));
                }
            }
            return r;
        case 1:
            int[] shape = broadcast(a, b);
            r = Array.factory(DataType.DOUBLE, shape);
            Index index = r.getIndex();
            Index aindex = a.getIndex();
            Index bindex = b.getIndex();
            int n = r.getRank();
            int na = a.getRank();
            int nb = b.getRank();
            int[] current;
            for (int i = 0; i < r.getSize(); i++) {
                current = index.getCurrentCounter();
                setIndex(aindex, bindex, current, n, na, nb);
                if (Double.isNaN(a.getDouble(aindex)) || Double.isNaN(b.getDouble(bindex))) {
                    r.setDouble(i, Double.NaN);
                } else {
                    r.setDouble(i, a.getDouble(aindex) / b.getDouble(bindex));
                }
                index.incr();
            }
            return r;
        default:
            return null;
    }             
}