home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 611.lha / AlgoRhythms_v2.0 / Source.LZH / Source / Scales.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-22  |  8.5 KB  |  280 lines
  1. /* Scales.c
  2.    Copyright (c) 1990,1991,1992 by Thomas E. Janzen
  3.    All Rights Reserved
  4.  
  5.    THIS SOFTWARE IS FURNISHED FREE OF CHARGE FOR STUDY AND USE AND MAY
  6.    BE COPIED ONLY FOR PERSONAL USE OR COMPLETELY AS OFFERED WITH NO
  7.    CHANGES FOR FREE DISTRIBUTION.  NO TITLE TO AND OWNERSHIP OF THE
  8.    SOFTWARE IS HEREBY TRANSFERRED.  THOMAS E. JANZEN ASSUMES NO 
  9.    RESPONSBILITY FOR THE USE OR RELIABILITY OF THIS SOFTWARE.
  10.    
  11.    Thomas E. Janzen
  12.    58A School St. Apt. 2-L
  13.    Hudson, MA 01749
  14.    (508)562-1295
  15. */
  16. /*
  17. **  FACILITY:
  18. **
  19. **    AlgoRhythms music improviser on Commodore (TM) Amiga (TM)
  20. **    compiled with SAS/C V5.10b
  21. **
  22. **  ABSTRACT:
  23. **
  24. **    Scales.c creates and manages musical scales.
  25. **
  26. **  AUTHORS: Thomas E. Janzen
  27. **
  28. **  CREATION DATE:    26-MAR-1990
  29. **
  30. **  MODIFICATION HISTORY:
  31. **    DATE    NAME    DESCRIPTION
  32. **    7 Dec 90 T. Janzen Procedurized filling octave-repeating scales
  33. **  4 Jan 92 TEJ  last changes for 2.0
  34. **--
  35. */
  36. #include <stdlib.h>  /* needed for ANSI abs () */
  37. #include <math.h>
  38.  
  39. #define CHROMATIC       1
  40. #define SHORTPENTATONIC 2
  41. #define HIRA            3
  42. #define KUMOI           4
  43. #define KOKIN           5
  44. #define WHOLETONE       6
  45. #define DIATONIC        7
  46. #define HARMONIC        8
  47. #define HUNGARIAN       9
  48. #define DIMINISHED      10
  49. #define LONGPENTATONIC  11
  50. #define MODE3           12 /* Messiaen Art of My Musical Language*/
  51. #define MODE4           13
  52. #define MODE5           14
  53. #define MODE6           15
  54. #define MODE7           16
  55. #define MTSsel          17 /*minr thrd, majr secnd, non-octave repeating*/
  56. #define M3M2            18 /*major third, minor second */
  57. #define QUARTAL         19
  58. #define QUINTAL         20
  59.  
  60. #define NUMOCTAVES      7
  61. #define BOTTOMOCT       2
  62. #define CHROMNUM        12
  63. #define SHRTPENTANUM    13
  64. #define HIRANUM         12
  65. #define KUMOINUM        12
  66. #define KOKINNUM        11
  67. #define WHOLENUM        6
  68. #define DIANUM          7
  69. #define HARMONNUM       7
  70. #define HUNGARNUM       7
  71. #define DIMINISHNUM     8
  72. #define LONGPENTANUM    5
  73. #define MODE3NUM        9 /*Messiaen  Art of My Musical Language*/
  74. #define MODE4NUM        8
  75. #define MODE5NUM        6
  76. #define MODE6NUM        8
  77. #define MODE7NUM        10
  78. #define MTSNUM          30 /*minr thrd, majr secnd, non-octave repeating*/
  79. #define M3M2NUM         29 /*major third,  minor second */
  80. #define QUARTALNUM      20 /* fourths if starts from low c 12 */
  81. #define QUINTALNUM      14 /* fifths if starts from low c 12 */
  82.  
  83. static int OctaveRepeatingScale  (  const char OneOctaveScale[], 
  84.                                     int scale[], 
  85.                                     const int ScaleOctaveLen);
  86.  
  87. extern int InstallScale  (const int Select, int scale[]) 
  88. {
  89.     const char  chromatic[CHROMNUM]  =  /* chromatic */
  90.                  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, 
  91.                 lucy[SHRTPENTANUM]   =  /* Short Pentatonic */
  92.                  {48, 50, 53, 55, 58, 60, 62, 65, 67, 70, 72, 74, 77},
  93.                 hira[HIRANUM]        =  /* hira joshi koto */
  94.                  {57, 59, 60, 64, 65, 69, 71, 72, 76, 77, 81, 83},
  95.                kumoi[KUMOINUM]      =  /* kumoi joshi koto */
  96.                  {57, 58, 62, 64, 65, 69, 70, 74, 76, 77, 81, 83},
  97.                kokin[KOKINNUM]      =  /* kokin joshi koto */
  98.                  {59, 62, 64, 65, 69, 71, 74, 76, 77, 81, 83},   
  99.                 wholetone[WHOLENUM]  =  /* whole tone scale */
  100.                {0, 2, 4, 6, 8, 10},
  101.                 Diatonic[DIANUM]     =  /* diatonic scale */ 
  102.                {0, 2, 4, 5, 7, 9, 11},
  103.                 HarmMinor[HARMONNUM] =  /* harmonic minor scale */
  104.                {0, 2, 3, 5, 7, 8, 11},
  105.                 HungMinor[HUNGARNUM] =  /* Hungarian minor */
  106.                {0, 2, 3, 6, 7, 8, 11},
  107.                 diminished[DIMINISHNUM] = /* diminished scale */
  108.                {0, 2, 3, 5, 6, 8, 9, 11},
  109.                 pentatonic[LONGPENTANUM] = /* long pentatonic scale */
  110.                {0, 2, 4, 7, 9},
  111.                 Mode3[MODE3NUM] =       /* Messiaen mode 3 */
  112.                {0, 2, 3, 4, 6, 7, 8, 10, 11},
  113.                 Mode4[MODE4NUM] =       /* Messiaen mode 4 */
  114.                {0, 1, 2, 5, 6, 7, 8, 11},
  115.                 Mode5[MODE5NUM] =       /* Messiaen mode 5 */
  116.                {0, 1, 5, 6, 7, 11},
  117.                 Mode6[MODE6NUM] =       /* Messiaen mode 6 */
  118.                {0, 2, 4, 5, 6, 8, 10, 11},
  119.                 Mode7[MODE7NUM] =       /* Messiaen mode 7 */
  120.                {0, 1, 2, 3, 5, 6, 7, 8, 9, 11},
  121.                 /* scale alternating minor third, major second; 
  122.                does not repeat octaves */
  123.                 MTS[MTSNUM] = {24, 26, 29, 31, 34, 36, 39, 41, 
  124.                                    44, 46, 49, 51, 54, 56, 59, 61, 
  125.                                    64, 66, 69, 71, 74, 76, 79, 81, 
  126.                                    84, 86, 89, 91, 94, 96},
  127.                 /* scale alternating major third minor second; 
  128.                   does not repeat octaves */
  129.                 M3m2[32] = {24, 28, 29, 33, 34, 38, 39, 43, 
  130.                                44, 48, 49, 53, 54, 58, 59, 63, 
  131.                                64, 68, 69, 73, 74, 78, 79, 83, 
  132.                                84, 88, 89, 93, 94}, /* 29 notes */
  133.                Quartal[QUARTALNUM] = { 12, 17, 23, 28, 33, 38, 43, 48, 53,
  134.                                        58, 63, 68, 73, 78, 83, 88, 93, 98, 
  135.                                        103, 108},
  136.                Quintal[QUINTALNUM] = { 12, 19, 26, 33, 40, 47, 54, 61, 68,
  137.                                        75, 82, 89, 96, 103};
  138.     register int      i;
  139.     
  140.     switch (Select) 
  141.    {
  142.         case CHROMATIC: /*chromatic*/
  143.             return OctaveRepeatingScale (chromatic, scale, CHROMNUM);
  144.             break;
  145.         case SHORTPENTATONIC: /*Pentatonic (Lucy) */
  146.             for (i = 0; i < SHRTPENTANUM; i++)
  147.             {
  148.                 scale[i] = (int)lucy[i];
  149.             }
  150.             return SHRTPENTANUM;
  151.             break;
  152.         case HIRA:
  153.             for (i = 0; i < HIRANUM; i++)
  154.             {
  155.                 scale[i] = (int)hira[i];
  156.             }
  157.             return HIRANUM;
  158.             break;
  159.         case KUMOI:
  160.             for (i = 0; i < KUMOINUM; i++)
  161.             {
  162.                 scale[i] = (int)kumoi[i];
  163.             }
  164.             return KUMOINUM;
  165.             break;
  166.         case KOKIN:
  167.             for (i = 0; i < KOKINNUM; i++)
  168.             {
  169.                 scale[i] = (int)kokin[i];
  170.             }
  171.             return KOKINNUM;
  172.             break;
  173.         case WHOLETONE: /*whole tone*/
  174.             return OctaveRepeatingScale (wholetone, scale, WHOLENUM);
  175.             break;
  176.         case DIATONIC: /*diatonic*/
  177.             return OctaveRepeatingScale (Diatonic, scale, DIANUM);
  178.             break;
  179.         case HARMONIC: /* harmonic minor */
  180.             return OctaveRepeatingScale (HarmMinor, scale, HARMONNUM);
  181.             break;
  182.         case HUNGARIAN: /* hungarian minor */
  183.             return OctaveRepeatingScale (HungMinor, scale, HUNGARNUM);
  184.             break;
  185.         case DIMINISHED: /*diminished scale */
  186.             return OctaveRepeatingScale (diminished, scale, DIMINISHNUM);
  187.             break;
  188.         case LONGPENTATONIC: /*long pentatonic scale */
  189.             return OctaveRepeatingScale (pentatonic, scale, LONGPENTANUM);
  190.             break;
  191.         case MODE3: /*Olivier Messiaen mode from Technique
  192.                 of my Musical Language*/
  193.             return OctaveRepeatingScale (Mode3, scale, MODE3NUM);
  194.             break;
  195.         case MODE4: /*Olivier Messiaen mode from Technique
  196.                 of my Musical Language*/
  197.             return OctaveRepeatingScale (Mode4, scale, MODE4NUM);
  198.             break;
  199.         case MODE5: /*Olivier Messiaen mode from Technique
  200.                 of my Musical Language*/
  201.             return OctaveRepeatingScale (Mode5, scale, MODE5NUM);
  202.             break;
  203.         case MODE6: /*Olivier Messiaen mode from Technique
  204.                 of my Musical Language*/
  205.             return OctaveRepeatingScale (Mode6, scale, MODE6NUM);
  206.             break;
  207.         case MODE7: /*Olivier Messiaen mode from Technique
  208.                 of my Musical Language*/
  209.             return OctaveRepeatingScale (Mode7, scale, MODE7NUM);
  210.             break;
  211.         case MTSsel:
  212.                 for (i = 0; i < 30; i++)
  213.                 {
  214.                     scale[i] = MTS[i];
  215.                 }
  216.             return MTSNUM;
  217.             break;
  218.         case M3M2:
  219.                 for (i = 0; i < M3M2NUM; i++)
  220.                 {
  221.                     scale[i] = M3m2[i];
  222.                 }
  223.             return M3M2NUM;
  224.             break;
  225.         case QUARTAL:
  226.                 for (i = 0; i < QUARTALNUM; i++)
  227.                 {
  228.                     scale[i] = Quartal[i];
  229.                 }
  230.             return QUARTALNUM;
  231.             break;
  232.         case QUINTAL:
  233.                 for (i = 0; i < QUINTALNUM; i++)
  234.                 {
  235.                     scale[i] = Quintal[i];
  236.                 }
  237.             return QUINTALNUM;
  238.             break;
  239.         default:
  240.             for (i = 0; i < SHRTPENTANUM; i++)
  241.             {
  242.                 scale[i] = lucy[i];
  243.             }
  244.             return SHRTPENTANUM;
  245.             break;
  246.         }
  247. }
  248.  
  249. extern void TransposeScale (  const int transpose, int *scale, 
  250.                               const int range) 
  251. {
  252.     register int i;
  253.    
  254.     if (abs(transpose)<CHROMNUM) 
  255.    {
  256.         for (i = 0; i < range; i++)
  257.     {
  258.             scale[i] = scale[i] + transpose;
  259.         }
  260.     }
  261. }
  262.  
  263. static int OctaveRepeatingScale (const char OneOctaveScale[], 
  264.                                 int scale[], 
  265.                                 const int ScaleOctaveLen)
  266. {
  267.          int oct,
  268.              i;
  269.  
  270.             for (oct = 0; oct < NUMOCTAVES; oct++)
  271.             {
  272.                 for (i = 0; i < ScaleOctaveLen; i++)
  273.                 {
  274.                     scale[i + (oct * ScaleOctaveLen)]   
  275.                = (int)OneOctaveScale[i] + ((oct + BOTTOMOCT) * CHROMNUM);
  276.                 }
  277.             }
  278.             return (NUMOCTAVES * ScaleOctaveLen);
  279. }
  280.