NAME
    MIDI::Praxis::Variation - Interface for variation techniques commonly
    used in music composition.

SYNOPSIS
      use MIDI::Praxis::Variation

DESCRIPTION
    Melodic variation techniques, as implemented here, expect an array of
    MIDI::Simple style note names as input. They return an array of Midi
    note numbers. These returned note representations can be printed
    directly or used, perhaps in MIDI::Simple fashion, as input to
    functions/methods that accept midi note number input.

BUGS
    Any that still exist have eluded our testing. This software is supplied
    as is with no representations as to its fitness for use. Use it at your
    own risk. If your system, your data, or all the forces of good in the
    universe are corrupted or destroyed as a result of your use of this
    software -- so it goes.

SUPPORT
    None

AUTHOR
            Craig Bourne
            cbourne@cpan.org

COPYRIGHT
    Copyright (c) Craig Bourne 2004 All rights reserved

    This program is free software; you can redistribute it and/or modify it
    under the same terms as Perl itself.

    The full text of the license can be found in the LICENSE file included
    with this module.

SEE ALSO
    MIDI::Simple(3).

  note_name_to_number
     Usage     : note_name_to_number($note_name)
     Purpose   : Map a single note name to a midi note number.
     Returns   : An equivalent midi note number.

     Comments  : Expects to see a MIDI::Simple style note name.

  original
     Usage     : original(@array)
     Purpose   : Map note names to midi note numbers.
     Returns   : An equivalent array of midi note numbers.

     Argument  : @array -  an array of note names.

     Comments  : Expects to see a an array of MIDI::Simple style note names,
               : e.g.,  C5, Fs6, Bf3. It returns equivilent midi note
               : numbers leaving the array of note names untouched.

  retrograde
     Usage     : retrograde(@array)
     Purpose   : Form the retrograde of an array of note names.
     Returns   : The retrograde equivalent array as midi note numbers.

     Argument  : @array -  an array of note names.

     Comments  : Expects to see a an array of MIDI::Simple style note names.
                                         
  transposition
     Usage     : transposition($distance, @array)
     Purpose   : Form the transposition of an array of notes.
     Returns   : Midi note numbers equivalent by transposition to
               : an array of note names.

     Arguments : $distance - an integer giving distance and direction.
               : @array    - an array of note names. 

     Comments  : Expects to see an integer followed an array of
               : MIDI::Simple style note names. The integer specifies
               : the direction and distance of transposition. For
               : example, 8 indicates 8 semitones up while -7 asks
               : for 7 semitones down. The array argument specifies
               : the notes to be transposed.
                                         
  inversion
     Usage     : inversion($axis, @array)
     Purpose   : Form the inversion of an array of notes.
     Returns   : Midi note numbers equivalent by inversion to
               : an array of note names.

     Arguments : $axis  -  a note to use as the axis of this inversion.
               : @array -  an array of note names. 

     Comments  : Expects to see a MIDI::Simple style note name.
               : followed by an array of such names. These give
               : the axis of inversion and the notes to be inverted.
                                         
  retrograde_inversion
     Usage     : retrograde_inversion($axis, @array)
     Purpose   : Form the retrograde inversion of an array of notes.
     Returns   : Midi note numbers equivalent by retrograde inversion to
               : an array of note names.

     Argument  : @array -  an array of note names.

     Comments  : Expects to see a an array of MIDI::Simple style note names.
               : Inverts about the supplied $axis.

  dur
     Usage     : dur($dur_or_len)
     Purpose   : Compute duration of a note.
     Returns   : Duration as an integer.

     Argument  : $dur_or_len - a string consisting of a numeric MIDI::Simple
               : style numeric duration spec ( e.g., d48, or d60 ) or length
               : spec ( e.g., qn or dhn )

     Comments  : Note that string input is expected and integer output
               : is returned.

  tye
     Usage     : tye($dur_or_len)
     Purpose   : Compute the sum of the durations of notes. As with a tie
               : in music notation. This odd spelling is used to avoid
               : conflict with the perl reserved word tie.

     Returns   : Duration as an integer.

     Argument  : $dur_or_len - a string consisting of a numeric MIDI::Simple
               : style numeric duration spec ( e.g., d48, or d60 ) or length
               : spec ( e.g., qn or dhn )

     Comments  : Note that string input is expected and integer output
               : is returned.

  raugmentation
     Usage     : raugmentation($ratio, $dur_or_len)
     Purpose   : Augment duration of a note multiplying it by $ratio.
     Returns   : Duration as an integer.

     Argument  : $ratio      - an integer multiplier
               : $dur_or_len - a string consisting of a numeric MIDI::Simple
               : style numeric duration spec ( e.g., d48, or d60 ) or length
               : spec ( e.g., qn or dhn )

     Comments  : Note that string input is expected for $dur_or_len and
               : integer output is returned.

  rdiminution
     Usage     : rdiminution($ratio, $dur_or_len)
     Purpose   : Diminish duration of a note dividing it by $ratio.
     Returns   : Duration as an integer.

     Argument  : $ratio      - an integer divisor
               : $dur_or_len - a string consisting of a numeric MIDI::Simple
               : style numeric duration spec ( e.g., d48, or d60 ) or length
               : spec ( e.g., qn or dhn )

     Comments  : Note that string input is expected for $dur_or_len and
               : integer output is returned. This integer is the aproximate
               : result of dividing the original duration by $ratio.

  augmentation
     Usage     : augmentation($dur_or_len)
     Purpose   : Augment duration of a note multiplying it by 2,
               : (i.e., double it).
     Returns   : Duration as an integer.

     Argument  : $dur_or_len - a string consisting of a numeric MIDI::Simple
               : style numeric duration spec ( e.g., d48, or d60 ) or length
               : spec ( e.g., qn or dhn )

     Comments  : Note that string input is expected for $dur_or_len and
               : integer output is returned.

  diminution
     Usage     : diminution($dur_or_len)
     Purpose   : Diminish duration of a note dividing it by 2,
               : (i.e., halve it).
     Returns   : Duration as an integer.

     Argument  : $dur_or_len - a string consisting of a numeric MIDI::Simple
               : style numeric duration spec ( e.g., d48, or d60 ) or length
               : spec ( e.g., qn or dhn )

     Comments  : Note that string input is expected for $dur_or_len and
               : integer output is returned. This integer is the aproximate
               : result of dividing the original duration by 2.

  ntup
     Usage     : ntup($nelem, @subject)
     Purpose   : Catalog tuples of length $nelem in @subject.
     Returns   : An array of tuples of length $nelem.

     Argument  : $nelem      - number of elements in each tuple
               : @subject    - subject array to be scanned for tuples

     Comments  : Scan begins with the 0th element of @subject looking for
               : a tuple of length $nelem. Scan advances by one until it
               : has found all tuples of length $nelem. For example:
               : given the array @ar = qw( 1 2 3 4 ) and $nelem = 2 
               : ntup(2, @ar) would return @ret = qw( 1 2 2 3 3 4 ). Note
               : that for $nelem == any of -1, 0, 5 using the same @ar as
               : its subject array ntup returns qw();

