lib/number/round.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2011, 2012 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, version 3, as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/ac/assert.h>
#include <lib/ac/math.h>

#include <lib/number.h>


number
number::round_up(int preferred_decimal)
    const
{
    if (has_overflowed())
        return *this;

    // Strictly speaking, this rounds away from zero; it does not round
    // towards positive infinity, like ANSI C ceil(3) does.
    assert(preferred_decimal >= 0);
    assert(preferred_decimal < 16);
    if (decimal == (unsigned)preferred_decimal)
        return *this;

    if (decimal < (unsigned)preferred_decimal)
    {
        size_t more = preferred_decimal - decimal;
        return number(value.shift_left(more), preferred_decimal, negative);
    }

    number_z n(value);
    size_t dump = decimal - preferred_decimal;
    assert(dump > 0);

    // <question>
    // When rounding UP to zero decimals, does 2.01 become 2 or 3?  This
    // is a question of does it only consult the first decimal, or all
    // the decimals to be round up?  (One is fast, the other is accurate.)
    // </question>
#if 1
    bool nudge = (n % (number_z::one().shift_left(dump))).is_not_zero();
#else
    bool nudge = (n.get(dump - 1) != 0);
#endif

    n = n.shift_right(dump);
    if (nudge)
        n += number_z::one();

    return number(n, preferred_decimal, negative);
}


number
number::round_off(int preferred_decimal)
    const
{
    if (has_overflowed())
        return *this;

    assert(preferred_decimal >= 0);
    assert(preferred_decimal < 16);
    if (decimal == (unsigned)preferred_decimal)
        return *this;

    if (decimal < (unsigned)preferred_decimal)
    {
        size_t more = preferred_decimal - decimal;
        return number(value.shift_left(more), preferred_decimal, negative);
    }

    number_z n(value);
    size_t dump = decimal - preferred_decimal;
    assert(dump > 0);

    bool nudge = (n.get(dump - 1) >= 5);

    n = n.shift_right(dump);
    if (nudge)
        n += number_z::one();

    return number(n, preferred_decimal, negative);
}


number
number::round_down(int preferred_decimal)
    const
{
    if (has_overflowed())
        return *this;

    // Strictly speaking, this rounds towards zero; it does not round
    // towards negative infinity, like ANSI C floor(3) does.
    assert(preferred_decimal >= 0);
    assert(preferred_decimal < 16);
    if (decimal == (unsigned)preferred_decimal)
        return *this;

    if (decimal < (unsigned)preferred_decimal)
    {
        size_t more = preferred_decimal - decimal;
        return number(value.shift_left(more), preferred_decimal, negative);
    }

    size_t dump = decimal - preferred_decimal;
    assert(dump > 0);

    return number(value.shift_right(dump), preferred_decimal, negative);
}


// vim: set ts=8 sw=4 et :