Transpose the note up or down the interval.

        Examples:
        >>> a = Note('A')
        >>> a.transpose('3')
        >>> a
        'C#-5'
        >>> a.transpose('3', False)
        >>> a
        'A-4'
332975
def transpose(self, interval, up=True):
        
        (old, o_octave) = (self.name, self.octave)
        self.name = intervals.from_shorthand(self.name, interval, up)
        if up:
            if self < Note(old, o_octave):
                self.octave += 1
        else:
            if self > Note(old, o_octave):
                self.octave -= 1
625615
public static Note getLowestNote(Note[] notes) {
	  Note lowestNote = notes[0];
	  for (int i=1; i<notes.length; i++)
		  if (notes[i].isLowerThan(lowestNote))
			  lowestNote = notes[i];
	  return lowestNote;
  }
718171
def from_int(self, integer):
        
        self.name = notes.int_to_note(integer % 12)
        self.octave = integer // 12
        return self
1308767
def append_note(self, note, root, scale=0):
        
        root_val = note_to_val(root)
        note_val = note_to_val(note) - root_val + scale * 12
        if note_val not in self.components:
            self.components.append(note_val)
            self.components.sort()
317749
def notes_to_positions(notes, root):
    
    root_pos = note_to_val(root)
    current_pos = root_pos
    positions = []
    for note in notes:
        note_pos = note_to_val(note)
        if note_pos < current_pos:
            note_pos += 12 * ((current_pos - note_pos) // 12 + 1)
        positions.append(note_pos - root_pos)
        current_pos = note_pos
    return positions
994466
def measure(note1, note2):
    
    res = notes.note_to_int(note2) - notes.note_to_int(note1)
    if res < 0:
        return 12 - res * -1
    else:
        return res
1246001
function transpose() {
         var tmp,
             a = this.val;
         tmp = a[1];
         a[1] = a[3];
         a[3] = tmp;
         tmp = a[2];
         a[2] = a[6];
         a[6] = tmp;
         tmp = a[5];
         a[5] = a[7];
         a[7] = tmp;
         return this;
       }
339087
function seventh(note, key) {
	var arr = triad(note, key);
	arr.push(intervals.seventh(note, key));
	return arr;
}
1050467
def augmented_triad(note):
    
    return [note, intervals.major_third(note),
            notes.augment(intervals.major_fifth(note))]
1003933
def seventh(note, key):
    
    return triad(note, key) + [intervals.seventh(note, key)]
550712
function augmented_major_seventh(note) {
	var arr = augmented_triad(note);
	arr.push(intervals.major_seventh(note));
	return arr;
}
1363699
def note_in_range(self, note):
        
        if type(note) == str:
            note = Note(note)
        if not hasattr(note, 'name'):
            raise UnexpectedObjectError("Unexpected object '%s'. "
                    "Expecting a mingus.containers.Note object" % note)
        if note >= self.range[0] and note <= self.range[1]:
            return True
        return False
949203
def place_notes_at(self, notes, at):
        """"""
        for x in self.bar:
            if x[0] == at:
                x[0][2] += notes
1180536
def _get_down_up_string(self):
        
        down_up = ""
        if not (self.down and self.up):
            if self.down:
                down_up = "down"
            elif self.up:
                down_up = "up"
        return down_up
953080
function (obj, octave) {
  var lastNote = obj.chord[0];

  obj.chord = _.map(obj.chord, function (n) {
    // Every time a note is "lower" than the last note, we're in a new octave
    if (n.lowerThan(lastNote)) octave += 1;

    // As a side-effect, update the octaves for root and bass
    if (n.enharmonic(obj.root)) {
      obj.root = obj.root.inOctave(octave);
    }
    if (obj.bass && n.enharmonic(obj.bass)) {
      obj.bass = obj.bass.inOctave(octave);
    }

    lastNote = n;
    return n.inOctave(octave);
  });
}
358430
Rule MidiTranspose() {
		return Sequence(String("transpose"),
				OneOrMore(WSP()),
				Optional('-'),
				OneOrMore(DIGIT()))
			.label(MidiTranspose);
	}
290852
def addinterval(instr, add, interval):
    '''
        
    '''
    if not isinstance(instr, str):
        instr = str(instr)

    return add.join(
        instr[i:i+interval]
        for i in xrange(0,len(instr),interval))