include/basegfx/numeric/ftools.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #pragma once
  21
  22 #include <rtl/math.h>
  23 #include <cmath>
  24 #include <math.h>
  25 #include <basegfx/basegfxdllapi.h>
  26 #include <limits>
  27 #include <algorithm>
  28
  29
  30 // fTools defines
  31
  32 namespace basegfx
  33 {
  34     /** Round double to nearest integer
  35
  36         @return the nearest integer
  37     */
  38     inline sal_Int32 fround( double fVal )
  39     {
  40         if (fVal >= 0.0)
  41         {
  42             if (fVal >= std::numeric_limits<sal_Int32>::max() - .5)
  43                 return std::numeric_limits<sal_Int32>::max();
  44             return static_cast<sal_Int32>(fVal + .5);
  45         }
  46         if (fVal <= std::numeric_limits<sal_Int32>::min() + .5)
  47             return std::numeric_limits<sal_Int32>::min();
  48         return static_cast<sal_Int32>(fVal - .5);
  49     }
  50
  51     /** Round double to nearest integer
  52
  53         @return the nearest 64 bit integer
  54     */
  55     inline sal_Int64 fround64( double fVal )
  56     {
  57         return fVal > 0.0 ? static_cast<sal_Int64>( fVal + .5 ) : -static_cast<sal_Int64>( -fVal + .5 );
  58     }
  59
  60     /** Prune a small epsilon range around zero.
  61
  62         Use this method e.g. for calculating scale values. There, it
  63         is usually advisable not to set a scaling to 0.0, because that
  64         yields singular transformation matrices.
  65
  66         @param fVal
  67         An arbitrary, but finite and valid number
  68
  69         @return either fVal, or a small value slightly above (when
  70         fVal>0) or below (when fVal<0) zero.
  71      */
  72     inline double pruneScaleValue( double fVal )
  73     {
  74         if(fVal < 0.0)
  75             return std::min(fVal, -0.00001);
  76         else
  77             return std::max(fVal, 0.00001);
  78     }
  79
  80     /** Convert value from degrees to radians
  81      */
  82     template <int DegMultiple = 1> constexpr double deg2rad( double v )
  83     {
  84         // divide first, to get exact values for v being a multiple of
  85         // 90 degrees
  86         return v / (90.0 * DegMultiple) * M_PI_2;
  87     }
  88
  89     /** Convert value radians to degrees
  90      */
  91     template <int DegMultiple = 1> constexpr double rad2deg( double v )
  92     {
  93         // divide first, to get exact values for v being a multiple of
  94         // pi/2
  95         return v / M_PI_2 * (90.0 * DegMultiple);
  96     }
  97
  98     /** Snap v to nearest multiple of fStep, from negative and
  99         positive side.
 100
 101         Examples:
 102
 103         snapToNearestMultiple(-0.1, 0.5) = 0.0
 104         snapToNearestMultiple(0.1, 0.5) = 0.0
 105         snapToNearestMultiple(0.25, 0.5) = 0.0
 106         snapToNearestMultiple(0.26, 0.5) = 0.5
 107      */
 108     BASEGFX_DLLPUBLIC double snapToNearestMultiple(double v, const double fStep);
 109
 110     /** Snap v to the range [0.0 .. fWidth] using modulo
 111      */
 112     BASEGFX_DLLPUBLIC double snapToZeroRange(double v, double fWidth);
 113
 114     /** Snap v to the range [fLow .. fHigh] using modulo
 115      */
 116     double snapToRange(double v, double fLow, double fHigh);
 117
 118     /** return fValue with the sign of fSignCarrier, thus evtl. changed
 119     */
 120     inline double copySign(double fValue, double fSignCarrier)
 121     {
 122 #ifdef _WIN32
 123         return _copysign(fValue, fSignCarrier);
 124 #else
 125         return copysign(fValue, fSignCarrier);
 126 #endif
 127     }
 128
 129     /** RotateFlyFrame3: Normalize to range defined by [0.0 ... fRange[, independent
 130         if v is positive or negative.
 131
 132         Examples:
 133
 134         normalizeToRange(0.5, -1.0) = 0.0
 135         normalizeToRange(0.5, 0.0) = 0.0
 136         normalizeToRange(0.5, 1.0) = 0.5
 137         normalizeToRange(-0.5, 1.0) = 0.5
 138         normalizeToRange(-0.3, 1.0) = 0.7
 139         normalizeToRange(-0.7, 1.0) = 0.3
 140         normalizeToRange(3.5, 1.0) = 0.5
 141         normalizeToRange(3.3, 1.0) = 0.3
 142         normalizeToRange(3.7, 1.0) = 0.7
 143         normalizeToRange(-3.5, 1.0) = 0.5
 144         normalizeToRange(-3.3, 1.0) = 0.7
 145         normalizeToRange(-3.7, 1.0) = 0.3
 146      */
 147     BASEGFX_DLLPUBLIC double normalizeToRange(double v, const double fRange);
 148
 149     namespace fTools
 150     {
 151         /// Get threshold value for equalZero and friends
 152         inline double getSmallValue() { return 0.000000001f; }
 153
 154         /// Compare against small value
 155         template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 156         inline bool equalZero(const T& rfVal)
 157         {
 158             return (fabs(rfVal) <= getSmallValue());
 159         }
 160
 161         /// Compare against given small value
 162         template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 163         inline bool equalZero(const T& rfVal, const T& rfSmallValue)
 164         {
 165             return (fabs(rfVal) <= rfSmallValue);
 166         }
 167
 168         template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 169         inline bool equal(T const& rfValA, T const& rfValB)
 170         {
 171             // changed to approxEqual usage for better numerical correctness
 172             return rtl_math_approxEqual(rfValA, rfValB);
 173         }
 174
 175         template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 176         inline bool equal(const T& rfValA, const T& rfValB, const T& rfSmallValue)
 177         {
 178             return (fabs(rfValA - rfValB) <= rfSmallValue);
 179         }
 180
 181         template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 182         inline bool less(const T& rfValA, const T& rfValB)
 183         {
 184             return (rfValA < rfValB && !equal(rfValA, rfValB));
 185         }
 186
 187         template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 188         inline bool lessOrEqual(const T& rfValA, const T& rfValB)
 189         {
 190             return (rfValA < rfValB || equal(rfValA, rfValB));
 191         }
 192
 193         template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 194         inline bool more(const T& rfValA, const T& rfValB)
 195         {
 196             return (rfValA > rfValB && !equal(rfValA, rfValB));
 197         }
 198
 199         template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 200         inline bool moreOrEqual(const T& rfValA, const T& rfValB)
 201         {
 202             return (rfValA > rfValB || equal(rfValA, rfValB));
 203         }
 204
 205         template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
 206         inline bool betweenOrEqualEither(const T& rfValA, const T& rfValB, const T& rfValC)
 207         {
 208             return (rfValA > rfValB && rfValA < rfValC) || equal(rfValA, rfValB) || equal(rfValA, rfValC);
 209         }
 210     };
 211 } // end of namespace basegfx
 212
 213 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */