libcruft-util/rational.hpp

75 lines
2.1 KiB
C++
Raw Normal View History

2014-07-02 15:49:27 +10:00
/*
2015-04-13 18:05:28 +10:00
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
2014-07-02 15:49:27 +10:00
*
2015-04-13 18:05:28 +10:00
* http://www.apache.org/licenses/LICENSE-2.0
2014-07-02 15:49:27 +10:00
*
2015-04-13 18:05:28 +10:00
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
2014-07-02 15:49:27 +10:00
*
2015-09-21 16:35:31 +10:00
* Copyright 2014-2015 Danny Robson <danny@nerdcruft.net>
2014-07-02 15:49:27 +10:00
*/
#ifndef __UTIL_RATIONAL_HPP
#define __UTIL_RATIONAL_HPP
2015-07-13 16:27:07 +10:00
#include <type_traits>
2014-07-02 15:49:27 +10:00
namespace util {
template <typename T>
struct rational {
2015-07-13 16:27:07 +10:00
static_assert (std::is_integral<T>::value, "only defined for integer types");
rational (const rational&) = default;
2015-07-13 16:27:07 +10:00
rational (T n, T d);
explicit rational (T);
2014-07-02 15:49:27 +10:00
2015-07-13 16:27:07 +10:00
bool operator== (rational) const;
bool operator!= (rational) const;
bool operator< (rational) const;
bool operator>= (rational) const;
2014-07-02 15:49:27 +10:00
explicit operator float (void) const;
explicit operator double (void) const;
2015-09-21 16:35:31 +10:00
explicit operator int (void) const;
2015-07-13 16:27:07 +10:00
rational<T> reduced (void) const;
rational<T> inverse (void) const;
rational<T>& invert (void);
2015-07-13 16:27:07 +10:00
rational<T> operator+ (T) const;
rational<T> operator- (T) const;
rational<T> operator* (T) const;
rational<T> operator/ (T) const;
2014-07-02 15:49:27 +10:00
T n;
T d;
};
///////////////////////////////////////////////////////////////////////////
template <typename T, typename U>
rational<typename std::common_type<T,U>::type>
operator/ (U lhs, rational<T> rhs)
{
return rhs.inverse () * lhs;
}
//-------------------------------------------------------------------------
template <typename T, typename U>
rational<typename std::common_type<T,U>::type>
operator* (U lhs, rational<T> rhs)
{
return rhs * lhs;
}
};
2014-07-02 15:49:27 +10:00
2014-07-02 15:49:27 +10:00
#endif