CODEWITHSUNDEEP
c++typesfractions
john smith
john smith

Reputation: 649

Converting variable type (or workaround)

The class below is supposed to represent a musical note. I want to be able to store the length of the note (e.g. 1/2 note, 1/4 note, 3/8 note, etc.) using only integers. However, I also want to be able to store the length using a floating point number for the rare case that I deal with notes of irregular lengths.

class note{
    string tone;
    int length_numerator;
    int length_denominator;
public:
    set_length(int numerator, int denominator){
        length_numerator=numerator;
        length_denominator=denominator;
    }
    set_length(double d){
        length_numerator=d; // unfortunately truncates everything past decimal point
        length_denominator=1;
    }
}

The reason it is important for me to be able to use integers rather than doubles to store the length is that in my past experience with floating point numbers, sometimes the values are unexpectedly inaccurate. For example, a number that is supposed to be 16 occasionally gets mysteriously stored as 16.0000000001 or 15.99999999999 (usually after enduring some operations) with floating point, and this could cause problems when testing for equality (because 16!=15.99999999999).

Is it possible to convert a variable from int to double (the variable, not just its value)? If not, then what else can I do to be able to store the note's length using either an integer or a double, depending on the what I need the type to be?

Upvotes: 2

Views: 661

Answers (6)

James Kanze
James Kanze

Reputation: 153929

I see several possible solutions: the first is just to use double. It's true that extended computations may result in inaccurate results, but in this case, your divisors are normally powers of 2, which will give exact results (at least on all of the machines I've seen); you only risk running into problems when dividing by some unusual value (which is the case where you'll have to use double anyway).

You could also scale the results, e.g. representing the notes as multiples of, say 64th notes. This will mean that most values will be small integers, which are guaranteed exact in double (again, at least in the usual representations). A number that is supposed to be 16 does not get stored as 16.000000001 or 15.99999999 (but a number that is supposed to be .16 might get stored as .1600000001 or .1599999999). Before the appearance of long long, decimal arithmetic classes often used double as a 52 bit integral type, ensuring at each step that the actual value was exactly an integer. (Only division might cause a problem.)

Or you could use some sort of class representing rational numbers. (Boost has one, for example, and I'm sure there are others.) This would allow any strange values (5th notes, anyone?) to remain exact; it could also be advantageous for human readable output, e.g. you could test the denominator, and then output something like "3 quarter notes", or the like. Even something like "a 3/4 note" would be more readable to a musician than "a .75 note".

Upvotes: 3

Seb Holzapfel
Seb Holzapfel

Reputation: 3873

If it were me, I would just use an enum. To turn something into a note would be pretty simple using this system also. Here's a way you could do it:

class Note {
public:
    enum Type {
        // In this case, 16 represents a whole note, but it could be larger
        // if demisemiquavers were used or something.
        Semiquaver = 1,
        Quaver = 2,
        Crotchet = 4,
        Minim = 8,
        Semibreve = 16
    };


    static float GetNoteLength(const Type &note) 
        { return static_cast<float>(note)/16.0f; }

    static float TieNotes(const Type &note1, const Type &note2)
        { return GetNoteLength(note1)+GetNoteLength(note2); }
};

int main()
{
    // Make a semiquaver
    Note::Type sq = Note::Semiquaver;
    // Make a quaver
    Note::Type q = Note::Quaver;
    // Dot it with the semiquaver from before
    float dottedQuaver = Note::TieNotes(sq, q);

    std::cout << "Semiquaver is equivalent to: " << Note::GetNoteLength(sq) << " beats\n";
    std::cout << "Dotted quaver is equivalent to: " << dottedQuaver << " beats\n";
    return 0;
}

Those 'Irregular' notes you speak of can be retrieved using TieNotes

Upvotes: 0

PierreBdR
PierreBdR

Reputation: 43264

Given you have a set_length(double d), my guess is that you actually need doubles. Note that the conversion from double to a fraction of integer is fragile and complexe, and will most probably not solve your equality problems (is 0.24999999 equal to 1/4 ?). It would be better for you to either choose to always use fractions, or always doubles. Then, just learn how to use them. I must say, for music, it make sense to have fractions as it is even how notes are being described.

Upvotes: 0

Gilad Naor
Gilad Naor

Reputation: 21516

If your only problem is comparing floats for equality, then I'd say to use floats, but read "Comparing floating point numbers" / Bruce Dawson first. It's not long, and it explains how to compare two floating numbers correctly (by checking the absolute and relative difference).

When you have more time, you should also look at "What Every Computer Scientist Should Know About Floating Point Arithmetic" to understand why 16 occasionally gets "mysteriously" stored as 16.0000000001 or 15.99999999999.

Attempts to use integers for rational numbers (or for fixed point arithmetic) are rarely as simple as they look.

Upvotes: 4

Tobias Langner
Tobias Langner

Reputation: 10808

This is normal behavior for floating point variables. They are always rounded and the last digits may change valued depending on the operations you do. I suggest reading on floating points somewhere (e.g. http://floating-point-gui.de/) - especially about comparing fp values.

I normally subtract them, take the absolute value and compare this against an epsilon, e.g. if (abs(x-y)

Upvotes: 0

john
john

Reputation: 87957

It is not possible to convert a variable from int to double, it is possible to convert a value from int to double. I'm not completely certain which you are asking for but maybe you are looking for a union

union DoubleOrInt
{
  double d;
  int i;
};

DoubleOrInt length_numerator;
DoubleOrInt length_denominator;

Then you can write

set_length(int numerator, int denominator){
    length_numerator.i=numerator;
    length_denominator.i=denominator;
}
set_length(double d){
    length_numerator.d=d;
    length_denominator.d=1.0;
}

The problem with this approach is that you absolutely must keep track of whether you are currently storing ints or doubles in your unions. Bad things will happen if you store an int and then try to access it as a double. Preferrably you would do this inside your class.

Upvotes: 2

Related Questions