Used to initialize the ranges.

@param numAtt 	number of attributes in the model
@param ranges 	low, high and width values for all attributes
195596
public void initializeRangesEmpty(int numAtt, double[][] ranges) {
    for (int j = 0; j < numAtt; j++) {
      ranges[j][R_MIN] = Double.POSITIVE_INFINITY;
      ranges[j][R_MAX] = -Double.POSITIVE_INFINITY;
      ranges[j][R_WIDTH] = Double.POSITIVE_INFINITY;
    }
  }
367983
public void minus(Range range) {
		List<Range> newList = new ArrayList<>();
		Range target = range;
		for (Iterator<Range> iterator = this.ranges.iterator(); iterator.hasNext();) {
			Range r = iterator.next();
			if (r.equals(target)) {
				iterator.remove();
			} else if (target.include(r)) {
				iterator.remove();
			} else if (r.include(target)) {
				if (r.getStart() < target.getStart()) {
					newList.add(new Range(r.getStart(), target.getStart() - 1));
				}
				if (r.getEnd() > target.getEnd()) {
					newList.add(new Range(target.getEnd() + 1, r.getEnd()));
				}
				iterator.remove();
			} else if (r.hasIntersection(target)) {
				if (r.include(target.getStart())) {
					newList.add(new Range(r.getStart(), target.getStart() - 1));
				} else {
					newList.add(new Range(target.getEnd() + 1, r.getEnd()));
				}
				iterator.remove();
			}
		}
		ranges.addAll(newList);
	}
306688
public void setGeoMatchSets(java.util.Collection<GeoMatchSetSummary> geoMatchSets) {
        if (geoMatchSets == null) {
            this.geoMatchSets = null;
            return;
        }

        this.geoMatchSets = new java.util.ArrayList<GeoMatchSetSummary>(geoMatchSets);
    }
42237
public void setRange(final double RANGE) {
        this.range = RANGE;
        checkForBlips();
        init(getInnerBounds().width, getInnerBounds().height);
        repaint();
    }
1123719
@Pure
	public static MathFunctionRange[] createDiscreteSet(double... values) {
		final MathFunctionRange[] bounds = new MathFunctionRange[values.length];
		for (int i = 0; i < values.length; ++i) {
			bounds[i] = new MathFunctionRange(values[i]);
		}
		return bounds;
	}
1246329
protected void set(double values[])
    {
        this.nRows  = values.length;
        this.nCols  = 1;
        this.values = new double[nRows][1];

        for (int r = 0; r < nRows; ++r) {
            this.values[r][0] = values[r];
        }
    }
530503
private void setRange(final double RANGE) {
        if (null == range) {
            _range = RANGE;
            setAngleStep(getAngleRange() / RANGE);
        } else {
            range.set(RANGE);
        }
    }
327926
public static List<Long> starts(final Iterable<Range<Long>> ranges) {
        List<Long> starts = new ArrayList<Long>();
        for (Range<Long> range : ranges) {
            checkClosedOpen(range);
            starts.add(range.lowerEndpoint());
        }
        return starts;
    }
1106596
@Override
	protected void initEvalMat() {
		_evalMat.set(_sParam.getRangeStart(), _lParam.getRangeStart(), States.S.ordinal(), 1);
	}
490882
public static List<Range> union(List<Range> ranges){
        ranges = new ArrayList<Range>(ranges);
        Collections.sort(ranges, new Comparator<Range>(){
            @Override
            public int compare(Range r1, Range r2){
                return r1.min-r2.min;
            }
        });
        List<Range> union = new ArrayList<Range>();
        for(Range r: ranges){
            if(union.isEmpty())
                union.add(r);
            else
                CollectionUtil.addAll(union, union.remove(union.size() - 1).union(r));
        }
        return union;
    }
402745
public void setMeshCreatorInputNormals(float[] values) {
        meshCreatorInputNormals = new float[ values.length ];
        for (int i = 0; i < values.length; i++) {
            meshCreatorInputNormals[i] = values[i];
        }
    }
914715
public static <T extends Comparable<T>> RangeSet<T> unionRangeSets(final Iterable<RangeSet<T>> rangeSets)
  {
    final RangeSet<T> rangeSet = TreeRangeSet.create();
    for (RangeSet<T> set : rangeSets) {
      rangeSet.addAll(set);
    }
    return rangeSet;
  }
604255
private void initialize(Integer minimum, Integer maximum) {
    minimumSpanWidth = minimum;
    maximumSpanWidth = maximum;
    spanWidth = (minimum != null && maximum != null && minimum.equals(maximum))
        ? minimum : null;
    singlePositionQuery = spanWidth != null && spanWidth.equals(1);
  }
154325
public double[][] initializeRanges(int[] instList) throws Exception {
    if (m_Data == null)
      throw new Exception("No instances supplied.");
    
    int numAtt = m_Data.numAttributes();
    double[][] ranges = new double [numAtt][3];
    
    if (m_Data.numInstances() <= 0) {
      initializeRangesEmpty(numAtt, ranges);
      return ranges;
    }
    else {
      // initialize ranges using the first instance
      updateRangesFirst(m_Data.instance(instList[0]), numAtt, ranges);
      // update ranges, starting from the second
      for (int i = 1; i < instList.length; i++) {
        updateRanges(m_Data.instance(instList[i]), numAtt, ranges);
      }
    }
    return ranges;
  }
1217078
private void init() {
        if (x == null) {
            x = new double[z[0].length];
            for (int i = 0; i < x.length; i++) {
                x[i] = i + 0.5;
            }
        }

        if (y == null) {
            y = new double[z.length];
            for (int i = 0; i < y.length; i++) {
                y[i] = y.length - i - 0.5;
            }
        }

        // In case of outliers, we use 1% and 99% quantiles as lower and
        // upper limits instead of min and max.
        int n = z.length * z[0].length;
        double[] values = new double[n];
        int i = 0;
        for (double[] zi : z) {
            for (double zij : zi) {
                if (!Double.isNaN(zij)) {
                    values[i++] = zij;
                }
            }
        }
        
        if (i > 0) {
            Arrays.sort(values, 0, i);
            min = values[(int)Math.round(0.01 * i)];
            max = values[(int)Math.round(0.99 * (i-1))];
            width = (max - min) / palette.length;
        }
    }
541076
public void setRangeStartValue(float v) {
    if (Measure_Type.featOkTst && ((Measure_Type)jcasType).casFeat_rangeStartValue == null)
      jcasType.jcas.throwFeatMissing("rangeStartValue", "ch.epfl.bbp.uima.types.Measure");
    jcasType.ll_cas.ll_setFloatValue(addr, ((Measure_Type)jcasType).casFeatCode_rangeStartValue, v);}
1223949
public void setEnumerationValues(java.util.Collection<EnumerationValue> enumerationValues) {
        if (enumerationValues == null) {
            this.enumerationValues = null;
            return;
        }

        this.enumerationValues = new java.util.ArrayList<EnumerationValue>(enumerationValues);
    }