Calculates and returns the maximum path from time zero to the start of an
interval.

@return a <code>Weight</code> object.
544952
synchronized Weight getMaximumStart() {
        if (calcMaxStart == null) {
            // Find the longest distance from time zero to a start.
            Weight result = WeightFactory.POS_INFINITY;
            if (shortestDistancesFromTimeZeroSource == null) {
                shortestDistancesFromTimeZeroSource = BellmanFord.calcShortestDistances(timeZero, directedGraph,
                        BellmanFord.Mode.SOURCE);

                if (shortestDistancesFromTimeZeroSource == null) {
                    throw new IllegalStateException("Negative cycle detected!");
                }
            }
            for (int i = 0, n = intervals.size(); i < n; i++) {
                Object start = intervals.get(i).getStart();
                result = Weight.min(result,
                        (Weight) shortestDistancesFromTimeZeroSource.get(start));
            }
            calcMaxStart = result;
        }

        return calcMaxStart;
    }
683906
public double getMax() {
        double max = s.minValue();
        for (int c = 0; c < this.values.length; c++) {
            if (s.gte(values[c], max)) {
                max = values[c];
            }
        }
        return max;
    }
401187
@Override
    public Long getMinimumFinish() {
        calculator();
        if (simple) {
            return v[2];
        } else {
            Weight minFinish = cn.getMinimumFinish();
            return minFinish.isInfinity() ? null : minFinish.value();
        }
    }
271787
public int max() {
    int max = Integer.MIN_VALUE;
    for (E key : map.keySet()) {
      max = Math.max(max, getIntCount(key));
    }
    return max;
  }
934426
int getLongestChainLength() {
		int maxLen = 0;

		for (Entry<?, ?> entry : table) {
			int thisLen = 0;
			while (entry != null) {
				thisLen++;
				entry = entry.next;
			}
			maxLen = Math.max(maxLen, thisLen);
		}

		return maxLen;
	}
527092
public Integer getMaxIdleTime()
   {
      if (childNode.getTextValueForPatternName("max-idle-time") != null && !childNode.getTextValueForPatternName("max-idle-time").equals("null")) {
         return Integer.valueOf(childNode.getTextValueForPatternName("max-idle-time"));
      }
      return null;
   }
806289
@Override
    public <V> V getMaximum(ChronoElement<V> element) {

        V max;

        if (this.timestamp.contains(element)) {
            max = this.timestamp.getMaximum(element);
        } else {
            max = this.moment.getMaximum(element);
        }

        if (
            (element == SECOND_OF_MINUTE)
            && (this.timestamp.getYear() >= 1972)
        ) {
            PlainTimestamp ts = this.timestamp.with(element, max);

            if (!this.zone.isInvalid(ts, ts)) {
                Moment transformed = ts.in(this.zone);
                Moment test = transformed.plus(1, SI.SECONDS);

                if (test.isLeapSecond()) {
                    return element.getType().cast(Integer.valueOf(60));
                }
            }
        }

        return max;

    }
382372
synchronized Weight getMinimumStart() {
        if (calcMinStart == null) {
            // Find the shortest distance from a start to time zero.
            Weight result = WeightFactory.NEG_INFINITY;
            if (shortestDistancesFromTimeZeroDestination == null) {
                shortestDistancesFromTimeZeroDestination = BellmanFord.calcShortestDistances(timeZero, directedGraph,
                        BellmanFord.Mode.DESTINATION);

                if (shortestDistancesFromTimeZeroDestination == null) {
                    throw new IllegalStateException("Negative cycle detected!");
                }
            }
            for (int i = 0, n = intervals.size(); i < n; i++) {
                Object start = intervals.get(i).getStart();
                result = Weight.max(result,
                        (Weight) shortestDistancesFromTimeZeroDestination.get(start));
            }
            calcMinStart = result.invertSign();
        }

        return calcMinStart;
    }
474891
public static Timecode max(final Timecode... timecodes)
	{
		Timecode max = null;

		for (Timecode timecode : timecodes)
			if (max == null || lt(max, timecode))
				max = timecode;

		return max;
	}
151168
private int getMaxHeight() {
        int result = 0;
        for (int i = 0; i < segmentCount; i++) {
            result = Math.max(result, segmentHeight(i, false));
        }
        return result;
    }
1169924
public com.google.protobuf.Duration getMaxPendingLatency() {
    return maxPendingLatency_ == null ? com.google.protobuf.Duration.getDefaultInstance() : maxPendingLatency_;
  }
185806
public TreeSet<TrajectoryEnvelope> getGroundEnvelopes() {
		TreeSet<TrajectoryEnvelope> ret = new TreeSet<TrajectoryEnvelope>(new Comparator<TrajectoryEnvelope>() {
			@Override
			public int compare(TrajectoryEnvelope o1, TrajectoryEnvelope o2) {
				Bounds o1b = new Bounds(o1.getTemporalVariable().getEST(),o1.getTemporalVariable().getEET());
				Bounds o2b = new Bounds(o2.getTemporalVariable().getEST(),o2.getTemporalVariable().getEET());
				if (o2b.min-o1b.min > 0) return -1;
				else if (o2b.min-o1b.min == 0) return 0;
				return 1;
			}
		});			
		if (this.getSubEnvelopes() != null) {
			for (TrajectoryEnvelope te : this.getSubEnvelopes()) {
				ret.addAll(te.getGroundEnvelopes());
			}
		}
		else ret.add(this);
		return ret;
	}
348270
public Duration getUptime()
	{
		final DateTime startup = getStartupDate();
		if (null != startup)
		{
			return Duration.elapsed(Time.valueOf(startup.toDate()));
		}
		return Duration.NONE;
	}
744337
public double getMeanThp() {
    if (getCount() == 0) {
      return 0.0;
    } else {
      final double elapsed = getTick() - startTime;
      return getCount() / elapsed * TimeUnit.SECONDS.toNanos(1);
    }
  }
1038606
@Override
  public double getWeight(double distance, double max, double stddev) {
    if(max <= 0) {
      return 1.0;
    }
    double relativedistance = distance / max;
    // -2.303 is log(.1) to suit the intended range of 1.0-0.1
    return FastMath.exp(-2.3025850929940455 * relativedistance * relativedistance);
  }
397453
public MachineTime<TimeUnit> getSimpleDuration() {

        Moment tsp = this.getTemporalOfOpenEnd();
        boolean max = (tsp == null);

        if (max) { // max reached
            tsp = this.getEnd().getTemporal();
        }

        MachineTime<TimeUnit> result =
            MachineTime.ON_POSIX_SCALE.between(
                this.getTemporalOfClosedStart(),
                tsp);

        if (max) {
            return result.plus(1, TimeUnit.NANOSECONDS);
        }

        return result;

    }
953832
public long getRangeFrom() {
		final long limit = (liveUpdated ? database.getStorage().getClusterDataRange(current.clusterId)[1] : firstClusterPosition) - 1;
		if (rangeFrom > -1)
			return Math.max(rangeFrom, limit);
		return limit;
	}