Java ConditionOp类代码示例

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
@Test
public void testConditionalReplaceValueTransform() {
    Schema schema = getSchema(ColumnType.Integer);

    Condition condition = new IntegerColumnCondition("column", ConditionOp.LessThan, 0);
    condition.setInputSchema(schema);

    Transform transform = new ConditionalReplaceValueTransform("column", new IntWritable(0), condition);
    transform.setInputSchema(schema);

    assertEquals(Collections.singletonList((Writable) new IntWritable(10)),
                    transform.map(Collections.singletonList((Writable) new IntWritable(10))));
    assertEquals(Collections.singletonList((Writable) new IntWritable(1)),
                    transform.map(Collections.singletonList((Writable) new IntWritable(1))));
    assertEquals(Collections.singletonList((Writable) new IntWritable(0)),
                    transform.map(Collections.singletonList((Writable) new IntWritable(0))));
    assertEquals(Collections.singletonList((Writable) new IntWritable(0)),
                    transform.map(Collections.singletonList((Writable) new IntWritable(-1))));
    assertEquals(Collections.singletonList((Writable) new IntWritable(0)),
                    transform.map(Collections.singletonList((Writable) new IntWritable(-10))));
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
@Test
public void testConditionalReplaceValueTransformWithDefault() {
    Schema schema = getSchema(ColumnType.Integer);

    Condition condition = new IntegerColumnCondition("column", ConditionOp.LessThan, 0);
    condition.setInputSchema(schema);

    Transform transform = new ConditionalReplaceValueTransformWithDefault("column", new IntWritable(0), new IntWritable(1), condition);
    transform.setInputSchema(schema);

    assertEquals(Collections.singletonList((Writable) new IntWritable(1)),
            transform.map(Collections.singletonList((Writable) new IntWritable(10))));
    assertEquals(Collections.singletonList((Writable) new IntWritable(1)),
            transform.map(Collections.singletonList((Writable) new IntWritable(1))));
    assertEquals(Collections.singletonList((Writable) new IntWritable(1)),
            transform.map(Collections.singletonList((Writable) new IntWritable(0))));
    assertEquals(Collections.singletonList((Writable) new IntWritable(0)),
            transform.map(Collections.singletonList((Writable) new IntWritable(-1))));
    assertEquals(Collections.singletonList((Writable) new IntWritable(0)),
            transform.map(Collections.singletonList((Writable) new IntWritable(-10))));
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
/**
 * Constructor for operations such as less than, equal to, greater than, etc.
 *
 * @param column                Column to check for the condition
 * @param sequenceConditionMode Mode for handling sequence data
 * @param op                    Operation (<, >=, !=, etc)
 * @param value                 Value to use in the condition
 */
public IntegerColumnCondition(String column, SequenceConditionMode sequenceConditionMode, ConditionOp op,
                int value) {
    super(column, sequenceConditionMode);
    if (op == ConditionOp.InSet || op == ConditionOp.NotInSet) {
        throw new IllegalArgumentException(
                        "Invalid condition op: cannot use this constructor with InSet or NotInSet ops");
    }
    this.op = op;
    this.value = value;
    this.set = null;
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
/**
 * Constructor for operations such as less than, equal to, greater than, etc.
 *
 * @param column                Column to check for the condition
 * @param sequenceConditionMode Mode for handling sequence data
 * @param op                    Operation (<, >=, !=, etc)
 * @param value                 Time value (in epoch millisecond format) to use in the condition
 */
public TimeColumnCondition(String column, SequenceConditionMode sequenceConditionMode, ConditionOp op, long value) {
    super(column, sequenceConditionMode);
    if (op == ConditionOp.InSet || op == ConditionOp.NotInSet) {
        throw new IllegalArgumentException(
                        "Invalid condition op: cannot use this constructor with InSet or NotInSet ops");
    }
    this.op = op;
    this.value = value;
    this.set = null;
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
/**
 * Constructor for operations such as less than, equal to, greater than, etc.
 *
 * @param column                Column to check for the condition
 * @param sequenceConditionMode Mode for handling sequence data
 * @param op                    Operation (<, >=, !=, etc)
 * @param value                 Value to use in the condition
 */
public LongColumnCondition(String column, SequenceConditionMode sequenceConditionMode, ConditionOp op, long value) {
    super(column, sequenceConditionMode);
    if (op == ConditionOp.InSet || op == ConditionOp.NotInSet) {
        throw new IllegalArgumentException(
                        "Invalid condition op: cannot use this constructor with InSet or NotInSet ops");
    }
    this.op = op;
    this.value = value;
    this.set = null;
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
/**
 * Constructor for conditions equal or not equal
 *
 * @param columnName            Column to check for the condition
 * @param sequenceConditionMode Mode for handling sequence data
 * @param op                    Operation (== or != only)
 * @param value                 Value to use in the condition
 */
public CategoricalColumnCondition(String columnName, SequenceConditionMode sequenceConditionMode, ConditionOp op,
                String value) {
    super(columnName, sequenceConditionMode);
    if (op != ConditionOp.Equal && op != ConditionOp.NotEqual) {
        throw new IllegalArgumentException(
                        "Invalid condition op: can only use this constructor with Equal or NotEqual conditions");
    }
    this.op = op;
    this.value = value;
    this.set = null;
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
/**
 * Constructor for conditions equal or not equal
 *
 * @param column                Column to check for the condition
 * @param sequenceConditionMode Mode for handling sequence data
 * @param op                    Operation (== or != only)
 * @param value                 Value to use in the condition
 */
public StringColumnCondition(String column, SequenceConditionMode sequenceConditionMode, ConditionOp op,
                String value) {
    super(column, sequenceConditionMode);
    if (op != ConditionOp.Equal && op != ConditionOp.NotEqual) {
        throw new IllegalArgumentException(
                        "Invalid condition op: can only use this constructor with Equal or NotEqual conditions");
    }
    this.op = op;
    this.value = value;
    this.set = null;
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
/**
 * Constructor for operations such as less than, equal to, greater than, etc.
 *
 * @param column                Column to check for the condition
 * @param sequenceConditionMode Mode for handling sequence data
 * @param op                    Operation (<, >=, !=, etc)
 * @param value                 Value to use in the condition
 */
public DoubleColumnCondition(String column, SequenceConditionMode sequenceConditionMode, ConditionOp op,
                double value) {
    super(column, sequenceConditionMode);
    if (op == ConditionOp.InSet || op == ConditionOp.NotInSet) {
        throw new IllegalArgumentException(
                        "Invalid condition op: cannot use this constructor with InSet or NotInSet ops");
    }
    this.op = op;
    this.value = value;
    this.set = null;
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
private SequenceLengthCondition(@JsonProperty("op") ConditionOp op, @JsonProperty("length") Integer length,
                @JsonProperty("set") Set<Integer> set) {
    if (set != null & op != ConditionOp.InSet && op != ConditionOp.NotInSet) {
        throw new IllegalArgumentException(
                        "Invalid condition op: can only use this constructor with InSet or NotInSet ops");
    }
    this.op = op;
    this.length = length;
    this.set = set;
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
@Test
public void testConditionalCopyValueTransform() {
    Schema schema = new Schema.Builder().addColumnsString("first", "second", "third").build();

    Condition condition = new StringColumnCondition("third", ConditionOp.Equal, "");
    Transform transform = new ConditionalCopyValueTransform("third", "second", condition);
    transform.setInputSchema(schema);

    List<Writable> list = Arrays.asList((Writable) new Text("first"), new Text("second"), new Text("third"));
    assertEquals(list, transform.map(list));

    list = Arrays.asList((Writable) new Text("first"), new Text("second"), new Text(""));
    List<Writable> exp = Arrays.asList((Writable) new Text("first"), new Text("second"), new Text("second"));
    assertEquals(exp, transform.map(list));
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
@Test
public void testConditionFilter() {
    Schema schema = new Schema.Builder().addColumnInteger("column").build();

    Condition condition = new IntegerColumnCondition("column", ConditionOp.LessThan, 0);
    condition.setInputSchema(schema);

    Filter filter = new ConditionFilter(condition);

    assertFalse(filter.removeExample(Collections.singletonList((Writable) new IntWritable(10))));
    assertFalse(filter.removeExample(Collections.singletonList((Writable) new IntWritable(1))));
    assertFalse(filter.removeExample(Collections.singletonList((Writable) new IntWritable(0))));
    assertTrue(filter.removeExample(Collections.singletonList((Writable) new IntWritable(-1))));
    assertTrue(filter.removeExample(Collections.singletonList((Writable) new IntWritable(-10))));
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
@Test
public void testFilters() {
    Filter[] filters = new Filter[] {new FilterInvalidValues("A", "B"),
                    new ConditionFilter(new DoubleColumnCondition("Col", ConditionOp.GreaterOrEqual, 10.0))};

    for (Filter f : filters) {
        String yaml = y.serialize(f);
        String json = j.serialize(f);

        //            System.out.println(yaml);
        //            System.out.println(json);
        //            System.out.println();

        Filter t2 = y.deserializeFilter(yaml);
        Filter t3 = j.deserializeFilter(json);
        assertEquals(f, t2);
        assertEquals(f, t3);
    }

    String arrAsYaml = y.serialize(filters);
    String arrAsJson = j.serialize(filters);
    String listAsYaml = y.serializeFilterList(Arrays.asList(filters));
    String listAsJson = j.serializeFilterList(Arrays.asList(filters));

    //        System.out.println("\n\n\n\n");
    //        System.out.println(listAsYaml);

    List<Filter> lFromYaml = y.deserializeFilterList(listAsYaml);
    List<Filter> lFromJson = j.deserializeFilterList(listAsJson);

    assertEquals(Arrays.asList(filters), y.deserializeFilterList(arrAsYaml));
    assertEquals(Arrays.asList(filters), j.deserializeFilterList(arrAsJson));
    assertEquals(Arrays.asList(filters), lFromYaml);
    assertEquals(Arrays.asList(filters), lFromJson);
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
@Test
public void testDataAction() {
    DataAction[] dataActions = new DataAction[] {new DataAction(new CategoricalToIntegerTransform("Col")),
                    new DataAction(new ConditionFilter(new DoubleColumnCondition("Col", ConditionOp.Equal, 1))),
                    new DataAction(new ConvertToSequence("KeyCol", new NumericalColumnComparator("Col", true))),
                    new DataAction(new ConvertFromSequence()),
                    new DataAction(new SequenceSplitTimeSeparation("TimeCol", 1, TimeUnit.HOURS)),
                    new DataAction(new Reducer.Builder(ReduceOp.TakeFirst).build()),
                    new DataAction(new CalculateSortedRank("NewCol", "SortCol", new DoubleWritableComparator()))};

    for (DataAction f : dataActions) {
        String yaml = y.serialize(f);
        String json = j.serialize(f);

        //            System.out.println(yaml);
        //            System.out.println(json);
        //            System.out.println();

        DataAction t2 = y.deserializeDataAction(yaml);
        DataAction t3 = j.deserializeDataAction(json);
        assertEquals(f, t2);
        assertEquals(f, t3);
    }

    String arrAsYaml = y.serialize(dataActions);
    String arrAsJson = j.serialize(dataActions);
    String listAsYaml = y.serializeDataActionList(Arrays.asList(dataActions));
    String listAsJson = j.serializeDataActionList(Arrays.asList(dataActions));

    //        System.out.println("\n\n\n\n");
    //        System.out.println(listAsYaml);

    List<DataAction> lFromYaml = y.deserializeDataActionList(listAsYaml);
    List<DataAction> lFromJson = j.deserializeDataActionList(listAsJson);

    assertEquals(Arrays.asList(dataActions), y.deserializeDataActionList(arrAsYaml));
    assertEquals(Arrays.asList(dataActions), j.deserializeDataActionList(arrAsJson));
    assertEquals(Arrays.asList(dataActions), lFromYaml);
    assertEquals(Arrays.asList(dataActions), lFromJson);
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
@Override
public String toString() {
    return "IntegerColumnCondition(columnName=\"" + columnName + "\"," + op + ","
                    + (op == ConditionOp.NotInSet || op == ConditionOp.InSet ? set : value) + ")";
}
 

import org.datavec.api.transform.condition.ConditionOp; //导入依赖的package包/类
@Override
public String toString() {
    return "TimeColumnCondition(columnName=\"" + columnName + "\"," + op + ","
                    + (op == ConditionOp.NotInSet || op == ConditionOp.InSet ? set : value) + ")";
}