org.apache.uima.cas.DoubleArrayFS Java Examples

/**
 * Convenience constructor which only needs the callback for encountered feature structures.
 *
 * @param featureStructureEncounteredCallback callback for encountered feature structures
 */
FsCopiers(UnaryOperator<FeatureStructure> featureStructureEncounteredCallback) {
  this.featureCopiers = new FeatureCopiers(featureStructureEncounteredCallback);
  this.featureStructureEncounteredCallback = featureStructureEncounteredCallback;

  fsCopiers = new HashMap<>();
  fsCopiers.put(CAS.TYPE_NAME_BOOLEAN_ARRAY, copyArray(BooleanArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_BYTE_ARRAY, copyArray(ByteArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_DOUBLE_ARRAY, copyArray(DoubleArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_FLOAT_ARRAY, copyArray(FloatArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_FS_ARRAY, this::copyFsArray);
  fsCopiers.put(CAS.TYPE_NAME_LONG_ARRAY, copyArray(LongArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_INTEGER_ARRAY, copyArray(IntArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_SHORT_ARRAY, copyArray(ShortArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_STRING_ARRAY, copyArray(StringArrayFS.class));
}
 

public void testDeltaWithDblArrayMod() {
  for (int i = 0; i < 10; i++) {
    TTypeSystem m = getTT(EqTwoTypes);
    remoteCas = setupCas(m);
    loadCas(casSrc, mSrc);
    ReuseInfo[] ri = serializeDeserialize(casSrc, remoteCas, null, null);
    MarkerImpl marker = (MarkerImpl) remoteCas.createMarker();
    lfs = getIndexedFSs(remoteCas, m);
    FeatureStructure fs = lfs.get(10); /* has double array length 2 */
    DoubleArrayFS d = (DoubleArrayFS) maybeGetFeatureKind(fs, m, "Adouble");
    if (d == null) { // could happen because features are randomly omitted
      System.out.println("    Adouble feature omitted, retrying");
    } else if (d.size() == 0) {
      System.out.println("    Adouble feature array has 0 length, retrying");
    } else {
      d.set(0, 12.34D);
      verifyDelta(marker, ri);
      break;
    }
    // setRandom();
    setUp();
    long seed = random.nextLong();
    random.setSeed(seed);
    System.out.println(" testDelta w/ dbl array mod random = " + seed + ", i = " + i);
  }
}
 

/**
 * Convenience constructor which only needs the callback for encountered feature structures.
 *
 * @param featureStructureEncounteredCallback callback for encountered feature structures
 */
FsCopiers(UnaryOperator<FeatureStructure> featureStructureEncounteredCallback,
    FeatureCopiers featureCopiers) {
  this.featureCopiers = featureCopiers;
  this.featureStructureEncounteredCallback = featureStructureEncounteredCallback;

  fsCopiers = new HashMap<>();
  fsCopiers.put(CAS.TYPE_NAME_BOOLEAN_ARRAY, copyArray(BooleanArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_BYTE_ARRAY, copyArray(ByteArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_DOUBLE_ARRAY, copyArray(DoubleArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_FLOAT_ARRAY, copyArray(FloatArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_FS_ARRAY, this::copyFsArray);
  fsCopiers.put(CAS.TYPE_NAME_LONG_ARRAY, copyArray(LongArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_INTEGER_ARRAY, copyArray(IntArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_SHORT_ARRAY, copyArray(ShortArrayFS.class));
  fsCopiers.put(CAS.TYPE_NAME_STRING_ARRAY, copyArray(StringArrayFS.class));
}
 

private DoubleArrayFS randomDoubleA(Random r) {
  int length = r.nextInt(2) + 1;
  DoubleArrayFS fs = createDoubleArrayFS(cas, length);
  for (int i = 0; i < length; i++) {
    fs.set(i, doubleValues[r.nextInt(doubleValues.length)]);
  }
  return fs;
}
 

private ARRAY_TYPE getArrayType(CommonArrayFS c) {
  if (c instanceof ArrayFS) return ARRAY_TYPE.FS; 
  if (c instanceof StringArrayFS) return ARRAY_TYPE.STRING; 
  if (c instanceof BooleanArrayFS) return ARRAY_TYPE.BOOLEAN; 
  if (c instanceof ByteArrayFS) return ARRAY_TYPE.BYTE; 
  if (c instanceof ShortArrayFS) return ARRAY_TYPE.SHORT; 
  if (c instanceof IntArrayFS) return ARRAY_TYPE.INT; 
  if (c instanceof LongArrayFS) return ARRAY_TYPE.LONG; 
  if (c instanceof FloatArrayFS) return ARRAY_TYPE.FLOAT; 
  if (c instanceof DoubleArrayFS) return ARRAY_TYPE.DOUBLE;
  return null;
}
 

private DoubleArrayFS randomDoubleA(CASImpl cas) {
  int length = random.nextInt(2) + 1;
  DoubleArrayFS fs = cas.createDoubleArrayFS(length);
  for (int i = 0; i < length; i++) {
    fs.set(i, doubleValues[random.nextInt(doubleValues.length)]);
  }
  return fs;
}
 

private void createDoubleA(CASImpl cas, TTypeSystem m, FeatureStructure fs, double x) {
  DoubleArrayFS fafs = cas.createDoubleArrayFS(6);
  fafs.set(0, Double.MAX_VALUE - x);
  // fafs.set(1, Double.MIN_NORMAL + x);
  fafs.set(2, Double.MIN_VALUE + x);
  fafs.set(3, Double.NaN);
  fafs.set(4, Double.NEGATIVE_INFINITY);
  fafs.set(5, Double.POSITIVE_INFINITY);
  maybeSetFeatureKind(fs, m, "Adouble", fafs);
}
 

private void createDoubleA(FeatureStructure fs, double x) {
  DoubleArrayFS fafs = createDoubleArrayFS(cas, 6);
  fafs.set(0, Double.MAX_VALUE - x);
  // fafs.set(1, Double.MIN_NORMAL + x);
  fafs.set(2, Double.MIN_VALUE + x);
  fafs.set(3, Double.NaN);
  fafs.set(4, Double.NEGATIVE_INFINITY);
  fafs.set(5, Double.POSITIVE_INFINITY);
  fs.setFeatureValue(akofAdouble, fafs);
}
 

public static DoubleArrayFS fillArrayFS(DoubleArrayFS aArrayFs, Iterable<Double> aValues) {
  int i = 0;
  for (Double fs : aValues) {
    aArrayFs.set(i, fs);
    i++;
  }
  return aArrayFs;
}
 

@Override
public DoubleArrayFS createDoubleArrayFS(int length) throws CASRuntimeException {
  checkArrayPreconditions(length);
  return new DoubleArray(this.getJCas(), length);
}
 

private void createExampleFS(CAS cas) throws Exception {
  // Set the document text
  cas.setDocumentText("this beer is good");

  // create an FS of exampleType and index it
  AnnotationFS fs = cas.createAnnotation(exampleType, 1, 5);
  cas.getIndexRepository().addFS(fs);

  // create Array FSs
  StringArrayFS strArrayFS = cas.createStringArrayFS(5);
  strArrayFS.set(0, "zzzzzz");
  strArrayFS.set(1, "yyyyyy");
  strArrayFS.set(2, "xxxxxx");
  strArrayFS.set(3, "wwwwww");
  strArrayFS.set(4, "vvvvvv");

  IntArrayFS intArrayFS = cas.createIntArrayFS(5);
  intArrayFS.set(0, Integer.MAX_VALUE);
  intArrayFS.set(1, Integer.MAX_VALUE - 1);
  intArrayFS.set(2, 42);
  intArrayFS.set(3, Integer.MIN_VALUE + 1);
  intArrayFS.set(4, Integer.MIN_VALUE);

  FloatArrayFS floatArrayFS = cas.createFloatArrayFS(5);
  floatArrayFS.set(0, Float.MAX_VALUE);
  floatArrayFS.set(1, (float) (Float.MAX_VALUE / 1000.0));
  floatArrayFS.set(2, (float) 42);
  floatArrayFS.set(3, (float) (Float.MIN_VALUE * 1000.0));
  floatArrayFS.set(4, Float.MIN_VALUE);

  ByteArrayFS byteArrayFS = cas.createByteArrayFS(5);
  byteArrayFS.set(0, (byte) 8);
  byteArrayFS.set(1, (byte) 16);
  byteArrayFS.set(2, (byte) 64);
  byteArrayFS.set(3, (byte) 128);
  byteArrayFS.set(4, (byte) 255);

  BooleanArrayFS boolArrayFS = cas.createBooleanArrayFS(8);
  boolean val = false;
  for (int i = 0; i < 8; i++) {
    boolArrayFS.set(i, val = !val);
  }

  ShortArrayFS shortArrayFS = cas.createShortArrayFS(5);
  shortArrayFS.set(0, Short.MAX_VALUE);
  shortArrayFS.set(1, (short) (Short.MAX_VALUE - 1));
  shortArrayFS.set(2, (short) (Short.MAX_VALUE - 2));
  shortArrayFS.set(3, (short) (Short.MAX_VALUE - 3));
  shortArrayFS.set(4, (short) (Short.MAX_VALUE - 4));

  LongArrayFS longArrayFS = cas.createLongArrayFS(5);
  longArrayFS.set(0, Long.MAX_VALUE);
  longArrayFS.set(1, Long.MAX_VALUE - 1);
  longArrayFS.set(2, Long.MAX_VALUE - 2);
  longArrayFS.set(3, Long.MAX_VALUE - 3);
  longArrayFS.set(4, Long.MAX_VALUE - 4);

  DoubleArrayFS doubleArrayFS = cas.createDoubleArrayFS(5);
  doubleArrayFS.set(0, Double.MAX_VALUE);
  doubleArrayFS.set(1, Double.MIN_VALUE);
  doubleArrayFS.set(2, Double.parseDouble("1.5555"));
  doubleArrayFS.set(3, Double.parseDouble("99.000000005"));
  doubleArrayFS.set(4, Double.parseDouble("4.44444444444444444"));

  // set features of fs
  fs.setStringValue(stringFeature, "aaaaaaa");
  fs.setFloatValue(floatFeature, (float) 99.99);

  fs.setFeatureValue(intArrayFeature, intArrayFS);
  fs.setFeatureValue(floatArrayFeature, floatArrayFS);
  fs.setFeatureValue(stringArrayFeature, strArrayFS);

  // fs.setByteValue(byteFeature, Byte.MAX_VALUE);
  fs.setByteValue(byteFeature, (byte) 'z');
  fs.setFeatureValue(byteArrayFeature, byteArrayFS);
  fs.setBooleanValue(booleanFeature, true);
  fs.setFeatureValue(booleanArrayFeature, boolArrayFS);
  fs.setShortValue(shortFeature, Short.MIN_VALUE);
  fs.setFeatureValue(shortArrayFeature, shortArrayFS);
  fs.setLongValue(longFeature, Long.MIN_VALUE);
  fs.setFeatureValue(longArrayFeature, longArrayFS);
  fs.setDoubleValue(doubleFeature, Double.MAX_VALUE);
  fs.setFeatureValue(doubleArrayFeature, doubleArrayFS);

  cas.getIndexRepository().addFS(fs);
}
 

private DoubleArrayFS createDoubleArrayFS(CAS c, int length) {
  return (DoubleArrayFS) createArray(c, ((CASImpl)c).getTypeSystemImpl().doubleArrayType, length);    
}
 

public static DoubleArrayFS fillArrayFS(DoubleArrayFS aArrayFs, double... aValues) {
  aArrayFs.copyFromArray(aValues, 0, 0, aArrayFs.size());
  return aArrayFs;
}
 

public static DoubleArrayFS createDoubleArrayFS(CAS aCas, double... aArray) {
  return fillArrayFS(aCas.createDoubleArrayFS(aArray.length), aArray);
}
 

private FeatureStructure createExampleFS(CAS parmCas) throws Exception {
  // Create a view
  CAS englishView = parmCas.createView("EnglishDocument");
  // Set the document text
  englishView.setDocumentText("this beer is good");

  // create an FS of exampleType and index it
  AnnotationFS fs = englishView.createAnnotation(exampleType, 1, 5);

  // create Array FSs
  StringArrayFS strArrayFS = parmCas.createStringArrayFS(5);
  strArrayFS.set(0, "zzzzzz");
  strArrayFS.set(1, "yyyyyy");
  strArrayFS.set(2, "xxxxxx");
  strArrayFS.set(3, "wwwwww");
  strArrayFS.set(4, "vvvvvv");

  IntArrayFS intArrayFS = parmCas.createIntArrayFS(5);
  intArrayFS.set(0, Integer.MAX_VALUE);
  intArrayFS.set(1, Integer.MAX_VALUE - 1);
  intArrayFS.set(2, 42);
  intArrayFS.set(3, Integer.MIN_VALUE + 1);
  intArrayFS.set(4, Integer.MIN_VALUE);

  FloatArrayFS floatArrayFS = parmCas.createFloatArrayFS(5);
  floatArrayFS.set(0, Float.MAX_VALUE);
  floatArrayFS.set(1, (float) (Float.MAX_VALUE / 1000.0));
  floatArrayFS.set(2, 42);
  floatArrayFS.set(3, (float) (Float.MIN_VALUE * 1000.0));
  floatArrayFS.set(4, Float.MIN_VALUE);

  ByteArrayFS byteArrayFS = parmCas.createByteArrayFS(5);
  byteArrayFS.set(0, (byte) 8);
  byteArrayFS.set(1, (byte) 16);
  byteArrayFS.set(2, (byte) 64);
  byteArrayFS.set(3, (byte) 128);
  byteArrayFS.set(4, (byte) 255);

  BooleanArrayFS boolArrayFS = parmCas.createBooleanArrayFS(20);
  boolean val = false;
  for (int i = 0; i < 20; i++) {
    boolArrayFS.set(i, val = !val);
  }

  ShortArrayFS shortArrayFS = parmCas.createShortArrayFS(5);
  shortArrayFS.set(0, Short.MAX_VALUE);
  shortArrayFS.set(1, (short) (Short.MAX_VALUE - 1));
  shortArrayFS.set(2, (short) (Short.MAX_VALUE - 2));
  shortArrayFS.set(3, (short) (Short.MAX_VALUE - 3));
  shortArrayFS.set(4, (short) (Short.MAX_VALUE - 4));

  LongArrayFS longArrayFS = parmCas.createLongArrayFS(5);
  longArrayFS.set(0, Long.MAX_VALUE);
  longArrayFS.set(1, Long.MAX_VALUE - 1);
  longArrayFS.set(2, Long.MAX_VALUE - 2);
  longArrayFS.set(3, Long.MAX_VALUE - 3);
  longArrayFS.set(4, Long.MAX_VALUE - 4);

  DoubleArrayFS doubleArrayFS = parmCas.createDoubleArrayFS(5);
  doubleArrayFS.set(0, Double.MAX_VALUE);
  doubleArrayFS.set(1, Double.MIN_VALUE);
  doubleArrayFS.set(2, Double.parseDouble("1.5555"));
  doubleArrayFS.set(3, Double.parseDouble("99.000000005"));
  doubleArrayFS.set(4, Double.parseDouble("4.44444444444444444"));

  // set features of fs
  fs.setStringValue(stringFeature, "aaaaaaa");
  fs.setFloatValue(floatFeature, (float) 99.99);

  fs.setFeatureValue(intArrayFeature, intArrayFS);
  fs.setFeatureValue(floatArrayFeature, floatArrayFS);
  fs.setFeatureValue(stringArrayFeature, strArrayFS);

  // fs.setByteValue(byteFeature, Byte.MAX_VALUE);
  fs.setByteValue(byteFeature, (byte) 'z');
  fs.setFeatureValue(byteArrayFeature, byteArrayFS);
  fs.setBooleanValue(booleanFeature, true);
  fs.setFeatureValue(booleanArrayFeature, boolArrayFS);
  fs.setShortValue(shortFeature, Short.MIN_VALUE);
  fs.setFeatureValue(shortArrayFeature, shortArrayFS);
  fs.setLongValue(longFeature, Long.MIN_VALUE);
  fs.setFeatureValue(longArrayFeature, longArrayFS);
  fs.setDoubleValue(doubleFeature, Double.MAX_VALUE);
  fs.setFeatureValue(doubleArrayFeature, doubleArrayFS);
  
  englishView.getIndexRepository().addFS(fs);
  return fs;
}
 

private int compareArrayFSs(TOP arrayFS1fs, Feature feat1, TOP arrayFS2fs, Feature feat2, Set<TOP> visited) {

  CommonArrayFS arrayFS1 = (CommonArrayFS)arrayFS1fs.getFeatureValue(feat1);
  CommonArrayFS arrayFS2 = (CommonArrayFS)arrayFS2fs.getFeatureValue(feat2);
  
  if (null == arrayFS1 && null == arrayFS2)return 0; // are equal
  if (null == arrayFS1) return chkEqual(-1,  "Array FS1 is null, but Array FS2 is not");
  if (null == arrayFS2) return chkEqual(-1,  "Array FS2 is null, but Array FS1 is not");

  int r, len;
  if (0 != (r = Integer.compare(len = arrayFS1.size(), arrayFS2.size()))) {
    return chkEqual(r, "ArrayFSs are different sizes, fs1 size is %d, fs2 size is %d", arrayFS1.size(), arrayFS2.size());
  }
  // are same size
  r = validateSameType(arrayFS1, arrayFS2);
  if (0 != r) return r;
  
  switch(getArrayType(arrayFS1)) {
  case FS:
    for (int j = 0; j < len; j++) {
      if (0 != (r = compare1((TOP)((FSArray)arrayFS1).get(j), (TOP)((FSArray)arrayFS2).get(j), visited))) return r;
    }
    break;
  case BOOLEAN:
    for (int j = 0; j < len; j++) {
      if (0 != (r = compBoolean(((BooleanArrayFS)arrayFS1).get(j), ((BooleanArrayFS)arrayFS2).get(j)))) return r;
    }
    break;
  case BYTE:
    for (int j = 0; j < len; j++) {
      if (0 != (r = compLong(((ByteArrayFS)arrayFS1).get(j), ((ByteArrayFS)arrayFS2).get(j)))) return r;
    }
    break;
  case SHORT:
    for (int j = 0; j < len; j++) {
      if (0 != (r = compLong(((ShortArrayFS)arrayFS1).get(j), ((ShortArrayFS)arrayFS2).get(j)))) return r;
    }
    break;
  case INT:
    for (int j = 0; j < len; j++) {
      if (0 != (r = compLong(((IntArrayFS)arrayFS1).get(j), ((IntArrayFS)arrayFS2).get(j)))) return r;
    }
    break;
  case LONG:
    for (int j = 0; j < len; j++) {
      if (0 != (r = compLong(((LongArrayFS)arrayFS1).get(j), ((LongArrayFS)arrayFS2).get(j)))) return r;
    }
    break;
  case FLOAT:
    for (int j = 0; j < len; j++) {
      if (0 != (r = compDouble(((FloatArrayFS)arrayFS1).get(j), ((FloatArrayFS)arrayFS2).get(j)))) return r;
    }
    break;
  case DOUBLE:
    for (int j = 0; j < len; j++) {
      if (0 != (r = compDouble(((DoubleArrayFS)arrayFS1).get(j), ((DoubleArrayFS)arrayFS2).get(j)))) return r;
    }
    break;
  case STRING:
    for (int j = 0; j < len; j++) {
      if (0 != (r = compStr(((StringArrayFS)arrayFS1).get(j), ((StringArrayFS)arrayFS2).get(j)))) {
        return chkEqual(r, "String miscompare, s1 = %s, s2 = %s", ((StringArrayFS)arrayFS1).get(j), ((StringArrayFS)arrayFS2).get(j));
      }
    }
    break;
  }
  return 0;  // all were equal
}
 

public static DoubleArrayFS createDoubleArrayFS(CAS aCas, Collection<Double> aCollection) {
  return fillArrayFS(aCas.createDoubleArrayFS(aCollection.size()), aCollection);
}
 

public DoubleArrayFS createDoubleArrayFS(int length) throws CASRuntimeException {
  return originalCAS.createDoubleArrayFS(length);
}