lily/scale.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2006--2011 Han-Wen Nienhuys <hanwen@lilypond.org>
   5       2007--2008 Rune Zedeler
   6       2008       Joe Neeman <joeneeman@gmail.com>
   7
   8   LilyPond is free software: you can redistribute it and/or modify
   9   it under the terms of the GNU General Public License as published by
  10   the Free Software Foundation, either version 3 of the License, or
  11   (at your option) any later version.
  12
  13   LilyPond is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "scale.hh"
  23
  24 #include "ly-smobs.icc"
  25
  26 /*
  27   todo: put string <-> pitch here too.
  28
  29 */
  30 LY_DEFINE (ly_make_scale, "ly:make-scale",
  31            1, 0, 0, (SCM steps),
  32            "Create a scale."
  33            "  The argument is a vector of rational numbers, each of which"
  34            " represents the number of 200 cent tones of a pitch above the"
  35            " tonic.")
  36 {
  37   bool type_ok = scm_is_vector (steps);
  38
  39   vector<Rational> tones;
  40   if (type_ok)
  41     {
  42       int len = scm_c_vector_length (steps);
  43       for (int i = 0 ; i < len; i++)
  44         {
  45           SCM step = scm_c_vector_ref (steps, i);
  46           type_ok = type_ok && scm_is_rational (step);
  47           if (type_ok)
  48             {
  49               Rational from_c (scm_to_int (scm_numerator (step)),
  50                                scm_to_int (scm_denominator (step)));
  51               tones.push_back (from_c);
  52             }
  53         }
  54     }
  55
  56
  57   SCM_ASSERT_TYPE (type_ok, steps, SCM_ARG1, __FUNCTION__, "vector of rational");
  58
  59   Scale *s = new Scale (tones);
  60
  61   SCM retval =  s->self_scm ();
  62   s->unprotect ();
  63
  64   return retval;
  65 }
  66
  67 LY_DEFINE (ly_default_scale, "ly:default-scale",
  68            0, 0, 0, (),
  69            "Get the global default scale.")
  70 {
  71   return default_global_scale
  72     ? default_global_scale->self_scm ()
  73     : SCM_BOOL_F;
  74 }
  75
  76
  77 Scale * default_global_scale = 0;
  78
  79 LY_DEFINE (ly_set_default_scale, "ly:set-default-scale",
  80            1, 0, 0, (SCM scale),
  81            "Set the global default scale. This determines the tuning of"
  82            " pitches with no accidentals or key signatures.  The first"
  83            " pitch is C. Alterations are calculated relative to this"
  84            " scale.  The number of pitches in this scale determines the"
  85            " number of scale steps that make up an octave.  Usually the"
  86            " 7-note major scale.")
  87 {
  88   LY_ASSERT_SMOB (Scale, scale, 1);
  89
  90   Scale *s = Scale::unsmob (scale);
  91   if (default_global_scale)
  92     default_global_scale->unprotect ();
  93   default_global_scale = s;
  94   s->protect ();
  95
  96   return SCM_UNSPECIFIED;
  97 }
  98
  99 int
 100 Scale::step_count () const
 101 {
 102   return step_tones_.size ();
 103 }
 104
 105 Rational
 106 Scale::tones_at_step (int step, int octave) const
 107 {
 108   int normalized_step = normalize_step (step);
 109
 110   octave += (step - normalized_step) / step_count ();
 111
 112   // There are 6 tones in an octave.
 113   return step_tones_[normalized_step] + Rational (octave*6);
 114 }
 115
 116 Rational
 117 Scale::step_size (int step) const
 118 {
 119   int normalized_step = normalize_step (step);
 120
 121   // Wrap around if we are asked for the final note of the
 122   // scale (6 is the number of tones of the octave above the
 123   // first note).
 124   if (normalized_step + 1 == step_count ())
 125     return Rational(6) - step_tones_[normalized_step];
 126
 127   return step_tones_[normalized_step + 1] - step_tones_[normalized_step];
 128 }
 129
 130 int
 131 Scale::normalize_step (int step) const
 132 {
 133   int ret = step % step_count ();
 134   if (ret < 0)
 135     ret += step_count ();
 136
 137   return ret;
 138 }
 139
 140 int
 141 Scale::print_smob (SCM /* x */,
 142                    SCM port,
 143                    scm_print_state *)
 144 {
 145   scm_puts ("#<Scale>", port);
 146   return 1;
 147 }
 148
 149 SCM
 150 Scale::mark_smob (SCM)
 151 {
 152   return SCM_UNSPECIFIED;
 153 }
 154
 155 Scale::Scale (vector<Rational> const &tones)
 156 {
 157   step_tones_ = tones;
 158
 159   smobify_self ();
 160 }
 161
 162 Scale::Scale (Scale const &src)
 163 {
 164   step_tones_ = src.step_tones_;
 165   smobify_self ();
 166 }
 167
 168
 169 Scale::~Scale ()
 170 {
 171 }
 172
 173 IMPLEMENT_SMOBS (Scale);
 174 IMPLEMENT_DEFAULT_EQUAL_P (Scale);