import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
/**
 * And over the whole ndarray given some condition
 *
 * @param n    the ndarray to test
 * @param cond the condition to test against
 * @return true if all of the elements meet the specified
 * condition false otherwise
 */
public static boolean and(final INDArray n, final Condition cond) {
    if (cond instanceof BaseCondition) {
        long val = (long) Nd4j.getExecutioner().exec(new MatchCondition(n, cond), Integer.MAX_VALUE).getDouble(0);

        if (val == n.lengthLong())
            return true;
        else
            return false;

    } else {
        boolean ret = true;
        final AtomicBoolean a = new AtomicBoolean(ret);
        Shape.iterate(n, new CoordinateFunction() {
            @Override
            public void process(int[]... coord) {
                if (a.get())
                    a.compareAndSet(true, a.get() && cond.apply(n.getDouble(coord[0])));
            }
        });

        return a.get();
    }
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
/**
 * Or over the whole ndarray given some condition, with respect to dimensions
 *
 * @param n    the ndarray to test
 * @param condition the condition to test against
 * @return true if all of the elements meet the specified
 * condition false otherwise
 */
public static boolean[] or(final INDArray n, final Condition condition, int... dimension) {
    if (!(condition instanceof BaseCondition))
        throw new UnsupportedOperationException("Only static Conditions are supported");

    MatchCondition op = new MatchCondition(n, condition);
    INDArray arr = Nd4j.getExecutioner().exec(op, dimension);
    boolean[] result = new boolean[arr.length()];

    for (int i = 0; i < arr.length(); i++) {
        if (arr.getDouble(i) > 0)
            result[i] = true;
        else
            result[i] = false;
    }

    return result;
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
@Override
public INDArray condi(Condition condition) {
    INDArray linear = linearView();
    for(int i = 0 ;i < length(); i++) {
        boolean met = condition.apply(linear.getDouble(i));
        linear.putScalar(i,met ? 1 : 0);
    }
    return this;
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
@Override
public IComplexNDArray condi(Condition condition) {
    IComplexNDArray linear = linearView();
    for(int i = 0 ;i < length(); i++) {
        boolean met = condition.apply(linear.getComplex(i));
        IComplexNumber put = Nd4j.createComplexNumber(met ? 1 : 0, 0);
        linear.putScalar(i,put);
    }
    return this;
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
/**
 * And
 * @param n
 * @param cond
 * @return
 */
public static boolean and(IComplexNDArray n,Condition cond) {
    boolean ret = true;
    IComplexNDArray linear = n.linearView();
    for(int i = 0; i < linear.length(); i++) {
        ret = ret && cond.apply(linear.getComplex(i));
    }

    return ret;
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
/**
 * Or over the whole ndarray given some condition
 * @param n
 * @param cond
 * @return
 */
public static boolean or(IComplexNDArray n,Condition cond) {
    boolean ret = true;
    IComplexNDArray linear = n.linearView();
    for(int i = 0; i < linear.length(); i++) {
        ret = ret || cond.apply(linear.getComplex(i));
    }

    return ret;
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
/**
 * Based on the matching elements
 * transform to based on condition to with function function
 * @param to the ndarray to transform
 * @param condition  the condition on transform
 * @param function the function to apply the transform to
 */
public static void applyWhere(INDArray to,Condition condition,Function<Number,Number> function) {
    INDArray linear = to.linearView();
    for(int i = 0; i < linear.linearView().length(); i++) {
        if(linear.data().dataType().equals(DataBuffer.FLOAT)) {
            if (condition.apply(linear.getFloat(i))) {
                linear.putScalar(i, function.apply(linear.getFloat(i)).floatValue());
            }
        }
        else  if(condition.apply(linear.getDouble(i)))
            linear.putScalar(i,function.apply(linear.getDouble(i)).doubleValue());


    }
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
@Test
public void testAbsValueGreaterThan() {
    final double threshold = 2;

    Condition absValueCondition = new AbsValueGreaterThan(threshold);
    Function<Number, Number> clipFn = new Function<Number, Number>() {
        @Override
        public Number apply(Number number) {
            System.out.println("Number: " + number.doubleValue());
            return (number.doubleValue() > threshold ? threshold : -threshold);
        }
    };

    Nd4j.getRandom().setSeed(12345);
    INDArray orig = Nd4j.rand(1, 20).muli(6).subi(3); //Random numbers: -3 to 3
    INDArray exp = orig.dup();
    INDArray after = orig.dup();

    for (int i = 0; i < exp.length(); i++) {
        double d = exp.getDouble(i);
        if (d > threshold) {
            exp.putScalar(i, threshold);
        } else if (d < -threshold) {
            exp.putScalar(i, -threshold);
        }
    }

    BooleanIndexing.applyWhere(after, absValueCondition, clipFn);

    System.out.println(orig);
    System.out.println(exp);
    System.out.println(after);

    assertEquals(exp, after);
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
public CompareAndSet(INDArray x, double compare, double set, double eps, Condition condition) {
    super(x);
    this.compare = compare;
    this.set = set;
    this.eps = eps;
    if (condition == null)
        this.mode = 0;
    else
        this.mode = condition.condtionNum();

    init(x, null, x, x.length());
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
public MatchConditionTransform(INDArray x, INDArray z, double eps, @NonNull Condition condition) {
    super(x, null, z, z.lengthLong());

    this.compare = condition.getValue();
    this.mode = condition.condtionNum();
    this.eps = eps;

    this.extraArgs = new Object[] {compare, eps, (double) mode};
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
public FirstIndex(SameDiff sameDiff, SDVariable i_v, int[] dimensions, Condition condition, double compare, double eps, int mode) {
    super(sameDiff, i_v, dimensions);
    this.condition = condition;
    this.compare = compare;
    this.eps = eps;
    this.mode = mode;
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
public LastIndex(SameDiff sameDiff, SDVariable i_v, int[] dimensions, Condition condition, double compare, double eps, int mode) {
    super(sameDiff, i_v, dimensions);
    this.condition = condition;
    this.compare = compare;
    this.eps = eps;
    this.mode = mode;
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
public MatchCondition(INDArray x, double eps, Condition condition) {
    super(x);
    this.compare = condition.getValue();
    this.mode = condition.condtionNum();
    this.eps = eps;

    this.extraArgs = new Object[] {compare, eps, (double) mode};
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
@Override
public INDArray condi(Condition condition) {
    Nd4j.getCompressor().autoDecompress(this);
    INDArray linear = this;
    for (int i = 0; i < length(); i++) {
        boolean met = condition.apply(linear.getDouble(i));
        linear.putScalar(i, met ? 1 : 0);
    }
    return this;
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
@Override
public IComplexNDArray condi(Condition condition) {
    IComplexNDArray linear = linearView();
    for (int i = 0; i < length(); i++) {
        boolean met = condition.apply(linear.getComplex(i));
        IComplexNumber put = Nd4j.createComplexNumber(met ? 1 : 0, 0);
        linear.putScalar(i, put);
    }
    return this;
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
/**
 * Based on the matching elements
 * op to based on condition to with function function
 *
 * @param to        the ndarray to op
 * @param condition the condition on op
 * @param function  the function to apply the op to
 */
public static void applyWhere(final INDArray to, final Condition condition,
                final Function<Number, Number> function) {
    // keep original java implementation for dynamic

    Shape.iterate(to, new CoordinateFunction() {
        @Override
        public void process(int[]... coord) {
            if (condition.apply(to.getDouble(coord[0])))
                to.putScalar(coord[0], function.apply(to.getDouble(coord[0])).doubleValue());

        }
    });
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
/**
 * This method does element-wise assing for 2 equal-sized matrices, for each element that matches Condition
 *
 * @param to
 * @param from
 * @param condition
 */
public static void assignIf(@NonNull INDArray to, @NonNull INDArray from, @NonNull Condition condition) {
    if (!(condition instanceof BaseCondition))
        throw new UnsupportedOperationException("Only static Conditions are supported");

    if (to.lengthLong() != from.lengthLong())
        throw new IllegalStateException("Mis matched length for to and from");

    Nd4j.getExecutioner().exec(new CompareAndSet(to, from, condition));
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
/**
 * This method does element-wise assing for 2 equal-sized matrices, for each element that matches Condition
 *
 * @param to
 * @param from
 * @param condition
 */
public static void replaceWhere(@NonNull INDArray to, @NonNull INDArray from, @NonNull Condition condition) {
    if (!(condition instanceof BaseCondition))
        throw new UnsupportedOperationException("Only static Conditions are supported");

    if (to.lengthLong() != from.lengthLong())
        throw new IllegalStateException("Mis matched length for to and from");

    Nd4j.getExecutioner().exec(new CompareAndReplace(to, from, condition));
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
public INDArray assignIf(final INDArray arr, final Condition condition) {
    // TODO Auto-generated method stub
    return null;
}
 

import org.nd4j.linalg.indexing.conditions.Condition; //导入依赖的package包/类
public INDArray cond(final Condition condition) {
    // TODO Auto-generated method stub
    return null;
}