X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lib%2Fduration-convert.cc;h=ac46fd7a608e18a5d4cc185a1712e6b2bfdc1406;hb=3a0e9efb7f067e5b334ba0596b95e15d96d7cc49;hp=b2a71951032b5696ffea33e009e064f4e6caf631;hpb=6a62932652940f4ac2931f75d48796887fbc5fdc;p=lilypond.git

diff --git a/lib/duration-convert.cc b/lib/duration-convert.cc
index b2a7195103..ac46fd7a60 100644
--- a/lib/duration-convert.cc
+++ b/lib/duration-convert.cc
@@ -3,11 +3,12 @@
 
   source file of the LilyPond music typesetter
 
-  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
-	   Jan Nieuwenhuizen <jan@digicash.com>
+  (c)  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+	   Jan Nieuwenhuizen <janneke@gnu.org>
 */
 #include <assert.h>
 #include "duration-convert.hh"
+#include "duration-iter.hh"
 #include "warn.hh"
 
 // statics Duration_convert
@@ -19,285 +20,181 @@ int Duration_convert::no_smaller_than_i_s = 0;
 Array<Duration> Duration_convert::dur_array_s;
 	
 String 
-Duration_convert::dur2_str( Duration dur )
-{
-	if ( dur.ticks_i_ )
-		return String( "["  ) + String( dur.ticks_i_ ) + "]";
-
-	String str( dur.type_i_ );
-	str += String( '.', dur.dots_i_ );
-	if ( dur.plet_b())
-		str += String( "*" ) + String( dur.plet_.iso_i_ )
-			+ String( "/" ) + String( dur.plet_.type_i_ );
-	return str;
+Duration_convert::dur2_str (Duration dur)
+{
+  if (dur.ticks_i_)
+    return String ("[") + to_str (dur.ticks_i_) + "]";
+  
+  String str;
+  if (dur.durlog_i_ >= 0)
+    str = to_str ( type2_i (dur.durlog_i_) );
+  else if (dur.durlog_i_ == -1)
+    str = "\\breve";
+  else if (dur.durlog_i_ == -2)
+    str = "\\longa";
+  str += to_str ('.', dur.dots_i_);
+  if (dur.plet_b ())
+    str += String ("*") + to_str (dur.plet_.iso_i_)
+      + String ("/") + to_str (dur.plet_.type_i_);
+  return str;
 }
 
-#if 0
 int
-Duration_convert::dur2_i( Duration dur, int division_1_i )
+Duration_convert::dur2ticks_i (Duration dur)
 {
-	return dur2_mom( dur ) * Moment( division_1_i );
+  if (dur.ticks_i_)
+    return dur.ticks_i_;
+  return dur2_mom (dur) * Rational (Duration::division_1_i_s);
 }
-#endif
 
 int
-Duration_convert::dur2ticks_i( Duration dur )
+Duration_convert::i2_type (int i)
 {
-	if ( dur.ticks_i_ )
-		return dur.ticks_i_;
-	return dur2_mom( dur ) * Moment( Duration::division_1_i_s );
+  int t=0;
+  while (i && !(i & 1)) {
+    i >>= 1;
+    t++;
+  }
+  return t;
 }
 
-Moment
-Duration_convert::dur2_mom( Duration dur )
-{
-	if ( dur.ticks_i_ )
-		return Moment( dur.ticks_i_, Duration::division_1_i_s );	
-
-	// or simply assert?
-	if ( !dur.type_i_ )
-		return Moment( 0 );
-
-	Moment mom = Moment( 1 , dur.type_i_ );
-
-	Moment delta = mom;
-	while ( dur.dots_i_-- ) {
-		delta /= 2.0;
-		mom += delta;
-	}
-
-	return mom * plet_factor_mom( dur );    
-}
-
-#if 0
-Moment
-Duration_convert::i2_mom( int time_i, int division_1_i )
-{
-	if ( !time_i )
-		return Moment( 0 );
+int
+Duration_convert::type2_i (int type)
+{
+  if (type<0)
+    return 0; 
+  else
+    return 1 << type;
+}
+
+Rational
+Duration_convert::dur2_mom (Duration dur)
+{
+  if (dur.ticks_i_)
+    return Rational (dur.ticks_i_, Duration::division_1_i_s);	
+
+  // or simply assert?
+  if (dur.durlog_i_<-10)
+    return Rational (0);
+  Rational mom;
+  if (dur.durlog_i_<0)
+    mom = Rational (type2_i (-dur.durlog_i_), 1);
+  else
+    mom = Rational (1 , type2_i (dur.durlog_i_));
+
+  Rational delta = mom;
+  while (dur.dots_i_--) 
+    {
+      delta /= 2.0;
+      mom += delta;
+    }
 
-	if ( division_1_i > 0 )
-		return Moment( time_i, division_1_i );
-	else 
-		return Moment( -division_1_i, time_i );
+  return mom * plet_factor_mom (dur);    
 }
-#endif
 
 Duration
-Duration_convert::mom2_dur( Moment mom )
+Duration_convert::mom2_dur (Rational mom)
 {
-    if (!mom) {
-	Duration dur;
-	dur.set_plet(0,1);
-	return dur;
+  if (!mom) 
+    {
+      Duration dur;
+      dur.set_plet (0,1);
+      return dur;
     }
 	
 
-	Duration dur = mom2standardised_dur( mom );
-//	if ( !dur.mom() || ( dur.mom() == mom ) )
-	if ( !dur.length() || ( dur.length() == mom ) )
-		return dur;
-	assert( midi_as_plet_b_s );
+  Duration dur = mom2standardised_dur (mom);
+  //	if (!dur.mom () || (dur.mom () == mom))
+  if (!dur.length_mom () || (dur.length_mom () == mom))
+    return dur;
+  assert (midi_as_plet_b_s);
 
-//	dur.set_plet( type_mom, Duration::division_1_i_s / 4 ); 
+  //	dur.set_plet (type_mom, Duration::division_1_i_s / 4); 
 
-//	Moment as_plet_mom = mom / dur.mom();
-	Moment as_plet_mom = mom / dur.length();
-	as_plet_mom *= dur.plet_.mom();
-	long num = as_plet_mom.numerator().as_long();
-	long den = as_plet_mom.denominator().as_long();
-	dur.set_plet( num, den );
-	return dur;
+  //	Rational as_plet_mom = mom / dur.mom ();
+  Rational as_plet_mom = mom / dur.length_mom ();
+  as_plet_mom *= dur.plet_.mom ();
+  long num = as_plet_mom.num ();
+  long den = as_plet_mom.den ();
+  dur.set_plet (num, den);
+  return dur;
 }
 
 Duration
-Duration_convert::mom2standardised_dur( Moment mom )
-{
-//	if ( !dur_array_s.length_i() )
-	if ( !dur_array_s.size() )
-		set_array();
-	assert( dur_array_s.size() );
-	for ( int i = 0; i < dur_array_s.size() - 1; i++ ) {
-  		Moment lower_mom = dur2_mom( dur_array_s[ i ] );
-		if ( mom <= lower_mom ) {
-			// all arbitrary, but 3/4 will get rid of the noise...
-			// kinda ok
-			if ( i || ( mom / lower_mom > Moment( 3, 4 ) ) )
-				return dur_array_s[ i ];
-			else {
-			    Duration d;
-			    d.type_i_ = 0;
-			    return d;
-			}
-		}
-  		Moment upper_mom = dur2_mom( dur_array_s[ i + 1 ] );
-		if ( ( mom < upper_mom )
-			 && ( ( mom - lower_mom ) / lower_mom
-				< ( upper_mom - mom ) / upper_mom ) )
-			return dur_array_s[ i ];
+Duration_convert::mom2standardised_dur (Rational mom)
+{
+  //	if (!dur_array_s.length_i ())
+  if (!dur_array_s.size ())
+    set_array ();
+  assert (dur_array_s.size ());
+  for (int i = 0; i < dur_array_s.size () - 1; i++) 
+    {
+      Rational lower_mom = dur2_mom (dur_array_s[ i ]);
+      if (mom <= lower_mom) 
+	{
+	  // all arbitrary, but 3/4 will get rid of the noise...
+	  // kinda ok
+	  if (i || (mom / lower_mom > Rational (3, 4)))
+	    return dur_array_s[ i ];
+	  else 
+	    {
+	      Duration d;
+	      d.durlog_i_ = -100;
+	      return d;
+	    }
 	}
-	return dur_array_s[ dur_array_s.size() - 1 ];
+      Rational upper_mom = dur2_mom (dur_array_s[ i + 1 ]);
+      if ((mom < upper_mom)
+	  && ((mom - lower_mom) / lower_mom
+	      < (upper_mom - mom) / upper_mom))
+	return dur_array_s[ i ];
+    }
+  return dur_array_s[ dur_array_s.size () - 1 ];
 }
 
 void
-Duration_convert::set_array()
+Duration_convert::set_array ()
 {
-	dur_array_s.clear();
+  dur_array_s.clear ();
 
-	Duration_iterator iter_dur;
-	assert( iter_dur );
-	while ( iter_dur )
-		dur_array_s.push( iter_dur++ );
+  Duration_iterator iter_dur;
+  assert (iter_dur);
+  while (iter_dur)
+    dur_array_s.push (iter_dur++);
 }
 
 
-Moment
-Duration_convert::plet_factor_mom( Duration dur )
+Rational
+Duration_convert::plet_factor_mom (Duration dur)
 {
-	return dur.plet_.mom();
+  return dur.plet_.mom ();
 }
 
 Real
-Duration_convert::sync_f( Duration dur, Moment mom )
+Duration_convert::sync_f (Duration dur, Rational mom)
 {
-	return mom / dur2_mom( dur );
+  return mom / dur2_mom (dur);
 }
 
 Duration
-Duration_convert::ticks2_dur( int ticks_i )
+Duration_convert::ticks2_dur (int ticks_i)
 {
-//		Duration dur( 4, 0 );
-//		dur.set_plet( ticks_i, Duration::division_1_i_s / 4 ); 
-
-	Moment mom( ticks_i, Duration::division_1_i_s );
-	if ( midi_as_plet_b_s )
-		return mom2_dur( mom );
+  Rational mom (ticks_i, Duration::division_1_i_s);
+  if (midi_as_plet_b_s)
+    return mom2_dur (mom);
 
-	Duration dur = mom2standardised_dur( mom );
+  Duration dur = mom2standardised_dur (mom);
 
-//	if ( dur.mom() == mom )
-	if ( dur.length() == mom )
-		return dur;
+  if (dur.length_mom () == mom)
+    return dur;
 		
-// huh?
-#if 0
-	dur.type_i_ = 0;
-	dur.dots_i_ = 0;
-	dur.set_ticks( ticks_i );
-	return dur;
-#else
-	return mom2_dur( mom );
-#endif
+  return mom2_dur (mom);
 }
 
 Duration
-Duration_convert::ticks2standardised_dur( int ticks_i )
-{
-	Moment mom( ticks_i, Duration::division_1_i_s );
-	Duration dur = mom2standardised_dur( mom );
-	return dur;
-}
-
-Duration_iterator::Duration_iterator()
-{
-	cursor_dur_.type_i_ = 128;
-	if ( Duration_convert::no_smaller_than_i_s )
-		cursor_dur_.type_i_ = Duration_convert::no_smaller_than_i_s;
-//	cursor_dur_.set_plet( 1, 1 );
-}
-
-Duration 
-Duration_iterator::operator ++(int)
-{
-	return forward_dur();
-}
-
-Duration
-Duration_iterator::operator ()()
-{
-	return dur();
-}
-
-Duration_iterator::operator bool()
-{
-	return ok();
-}
-
-Duration
-Duration_iterator::dur()
-{
-	return cursor_dur_;
-}
-
-Duration
-Duration_iterator::forward_dur()
-{
-	/* should do smart table? guessing: 
-		duration wholes
-		16 	0.0625
-		32.. 	0.0703
-		8:2/3	0.0833
-		16.	0.0938
-		8	0.1250
-		16..	0.1406
-		4:2/3	0.1667
-		8.	0.1875
-		
-	*/
-	assert( ok() );
-
-	Duration dur = cursor_dur_;
-
-	if ( !cursor_dur_.dots_i_ && !cursor_dur_.plet_b() ) {
-		cursor_dur_.type_i_ *= 2;
-		cursor_dur_.dots_i_ = 2;
-	}
-	else if ( cursor_dur_.dots_i_ == 2 ) {
-		assert( !cursor_dur_.plet_b() );
-		cursor_dur_.dots_i_ = 0;
-		cursor_dur_.type_i_ /= 4;
-		cursor_dur_.set_plet( 2, 3 );
-	}
-	else if ( cursor_dur_.plet_b() 
-		&& ( cursor_dur_.plet_.iso_i_ == 2 )
-		&& ( cursor_dur_.plet_.type_i_ == 3 ) ) {
-		assert( !cursor_dur_.dots_i_ );
-		cursor_dur_.set_plet( 1, 1 );
-		cursor_dur_.type_i_ *= 2;
-		cursor_dur_.dots_i_ = 1;
-	}
-	else if ( cursor_dur_.dots_i_ == 1 ) {
-		assert( !cursor_dur_.plet_b() );
-		cursor_dur_.dots_i_ = 0;
-		cursor_dur_.type_i_ /= 2;
-	}
-		
-	if ( Duration_convert::no_triplets_b_s
-	     && cursor_dur_.plet_b() && ok() )
-	    forward_dur();
-	if ( Duration_convert::no_double_dots_b_s 
-	     && ( cursor_dur_.dots_i_ == 2 ) && ok() )
-		forward_dur();
-	if ( Duration_convert::no_smaller_than_i_s
-	     && ( cursor_dur_.type_i_ > Duration_convert::no_smaller_than_i_s ) && ok() )
-		forward_dur();
-	if ( Duration_convert::no_smaller_than_i_s
-	     && cursor_dur_.dots_i_
-	     && ( cursor_dur_.type_i_ >= Duration_convert::no_smaller_than_i_s )
-	     && ok() )
-		forward_dur();
-	if ( Duration_convert::no_smaller_than_i_s
-	     && ( cursor_dur_.dots_i_ == 2 )
-	     && ( cursor_dur_.type_i_ >= Duration_convert::no_smaller_than_i_s / 2 )
-	     && ok() )
-		forward_dur();
-
-	return dur;
-}
-
-bool
-Duration_iterator::ok()
+Duration_convert::ticks2standardised_dur (int ticks_i)
 {
-	return ( cursor_dur_.type_i_ 
-		&& !( ( cursor_dur_.type_i_ == 1 ) && ( cursor_dur_.dots_i_ > 2 ) ) );
+  Rational mom (ticks_i, Duration::division_1_i_s);
+  Duration dur = mom2standardised_dur (mom);
+  return dur;
 }