Returns the highest note among the notes composing this multi note.
@return The highest note among the notes composing this multi note.
@see #getLowestNote()
@see Note#isHigherThan(Note)
498239
public Note getHighestNote() {
	  Note highestNote = (Note)m_notes.elementAt(0);
	  //short highestHeight = highestNote.getHeight();
	  //short currentNoteLength = 0;
	  for (int i=1; i<m_notes.size(); i++)
		  if (((Note)(m_notes.elementAt(i))).isHigherThan(highestNote))
			  highestNote = (Note)m_notes.elementAt(i);
	  return highestNote;
  }
30578
public T getMaximum() {
        Lock lock = this.lock.readLock();
        lock.lock();
        try {
            return this.maximum;
        } finally {
            lock.unlock();
        }
    }
1204735
public int getMostVisiblePosition() {
        final int firstPosition = getFirstVisiblePosition();
        final int height = getHeight();

        int maxDisplayedHeight = 0;
        int mostVisibleIndex = 0;
        int i = 0;
        int bottom = 0;
        while (bottom < height) {
            View child = getChildAt(i);
            if (child == null) {
                break;
            }
            bottom = child.getBottom();
            int displayedHeight = Math.min(bottom, height) - Math.max(0, child.getTop());
            if (displayedHeight > maxDisplayedHeight) {
                mostVisibleIndex = i;
                maxDisplayedHeight = displayedHeight;
            }
            i++;
        }
        return firstPosition + mostVisibleIndex;
    }
1025384
@java.lang.Deprecated
  public java.util.Map<java.lang.String, io.grafeas.v1beta1.Note> getNotes() {
    return getNotesMap();
  }
1070495
public Collection getNotesBetween(MusicElement elmtBegin,
			MusicElement elmtEnd) throws IllegalArgumentException {
		int idxBegin = indexOf(elmtBegin);
		int idxEnd = this.indexOf(elmtEnd);
		if (idxBegin == -1)
			throw new IllegalArgumentException("Note " + elmtBegin
					+ " hasn't been found in tune");
		if (idxEnd == -1)
			throw new IllegalArgumentException("Note " + elmtEnd
					+ " hasn't been found in tune");
		if (idxBegin > idxEnd)
			throw new IllegalArgumentException("Note " + elmtBegin
					+ " is located after " + elmtEnd + " in the score");
		Collection ret = new Vector();
		MusicElement currentScoreEl;
		for (int i = idxBegin; i <= idxEnd; i++) {
			currentScoreEl = (MusicElement) elementAt(i);
			if (currentScoreEl instanceof NoteAbstract)
				ret.add(currentScoreEl);
		}
		return ret;
	}
1229535
public int getMaximalFrequency()
    {
        int maxfreq = 0;
        for (Map.Entry<T, Integer> entry : styles.entrySet())
        {
            if (entry.getValue() > maxfreq)
                maxfreq = entry.getValue();
        }
        return maxfreq;
    }
546118
@Override
    public Status match(int cc)
    {
        int highest = -1;
        Iterator<Matcher> iterator = active.iterator();
        while (iterator.hasNext())
        {
            Matcher matcher = iterator.next();
            Status s = matcher.match(cc);
            highest = Math.max(highest, s.ordinal());
            switch (s)
            {
                case Match:
                    lastMatched = matcher;
                    clear();
                    return s;
                case WillMatch:
                    lastMatched = matcher;
                    return s;
                case Error:
                    iterator.remove();
                    break;
            }
        }
        if (active.isEmpty())
        {
            clear();
            return Status.Error;
        }
        return Status.values()[highest];
    }
1372014
public int maxValue()
    {
        final int missingValue = this.missingValue;
        int max = size == 0 ? missingValue : Integer.MIN_VALUE;

        final int[] entries = this.entries;
        @DoNotSub final int length = entries.length;

        for (@DoNotSub int valueIndex = 1; valueIndex < length; valueIndex += 2)
        {
            final int value = entries[valueIndex];
            if (value != missingValue)
            {
                max = Math.max(max, value);
            }
        }

        return max;
    }
897342
public int[] next()
    {
        boolean hasNewPerm = false;

        escape:while( level >= 0) {
//            boolean foundZero = false;
            for( int i = iter[level]; i < data.length; i = iter[level] ) {
                iter[level]++;

                if( data[i] == -1 ) {
                    level++;
                    data[i] = level-1;

                    if( level >= data.length ) {
                        // a new permutation has been created return the results.
                        hasNewPerm = true;
                        System.arraycopy(data,0,ret,0,ret.length);
                        level = level-1;
                        data[i] = -1;
                        break escape;
                    } else {
                        valk[level] = i;
                    }
                }
            }

            data[valk[level]] = -1;
            iter[level] = 0;
            level = level-1;

        }

        if( hasNewPerm )
            return ret;
        return null;
    }
106602
private long findHighestId() {
        return this.registeredServices.stream().map(RegisteredService::getId).max(Comparator.naturalOrder()).orElse(0L);
    }
861819
public String getBestLabel(double[] scores) {
		int best = 0;
		double bestScore = 0d;
		for (int d = 0; d < scores.length; d++) {
			if (scores[d] >= bestScore) {
				bestScore = scores[d];
				best = d;
			}
		}
		return this.lexicon.getLabel(best);
	}
468142
public T max() {
        TObjectIntIterator<T> iter = counts.iterator();
        int maxCount = -1;
        T max = null;
        while (iter.hasNext()) {
            iter.advance();
            int count = iter.value();
            if (count > maxCount) {
                max = iter.key();
                maxCount = count;
            }
        }
        return max;
    }
238175
public Note get(long id)
	{
		SingleElementHandler<Note> noteHandler = new SingleElementHandler<>();
		try
		{
			osm.makeAuthenticatedRequest(NOTES + "/" + id, null, new NotesParser(noteHandler));
		}
		catch (OsmNotFoundException e)
		{
			return null;
		}
		return noteHandler.get();
	}
845250
public java.lang.String getGradientFunc() {
    java.lang.Object ref = gradientFunc_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      gradientFunc_ = s;
      return s;
    }
  }
1144883
public Double getMax() {
        String v = input.getElement().getAttribute("max");
        if (v == null || v.isEmpty()) return null;
        return Double.valueOf(v);
    }
779994
public int rank() {
        if (!full) {
            throw new IllegalStateException("This is not a FULL singular value decomposition.");
        }

        int r = 0;
        for (int i = 0; i < s.length; i++) {
            if (s[i] > tol) {
                r++;
            }
        }
        return r;
    }
1307449
public int[] getBestAssignment() {
    double maxValue = Double.NEGATIVE_INFINITY;
    for (int i = 0; i < values.length; i++) if (values[i] > maxValue) {
      maxValue = values[i];
    }

    // OPTIMIZATION:
    // Rather than use the standard iterator, which creates lots of int[] arrays on the heap, which need to be GC'd,
    // we use the fast version that just mutates one array. Since this is read once for us here, this is ideal.

    Iterator<int[]> fastPassByReferenceIterator = fastPassByReferenceIterator();
    do {
      int[] assignment = fastPassByReferenceIterator.next();
      double v = getAssignmentLogValue(assignment);
      if (v == maxValue) return assignment;
    } while (fastPassByReferenceIterator.hasNext());

    throw new IllegalStateException("This is unreachable.");
  }