RMath

Class in Math Module
Header: #include <src/core/math/RMath.h>

Description

Math functions.

Scriptable: This class is available in script environments.

Static Public Functions

static int	absmod(int a, int b)
static QString	angleToString(double a) Converts the given angle in rad to the given angle format.
static bool	containsFuzzy(const QList< double > &values, double v, double tol=RS::PointTolerance)
static double	deg2rad(double a) Converts degrees to radians.
static double	eval(const QString &expression, bool *ok=NULL) Evaluates the given mathematical expression and returns the result.
static bool	fuzzyAngleCompare(double v1, double v2, double tolerance=RS::AngleTolerance)
static bool	fuzzyCompare(double v1, double v2, double tolerance=RS::PointTolerance)
static double	getAngleDifference(double a1, double a2)
static double	getAngleDifference180(double a1, double a2)
static void	getBiQuadRoots(double p[], double r[][5])
static void	getCubicRoots(double p[], double r[][5])
static QString	getError()
static int	getGcd(int a, int b) Finds greatest common divider using Euclid’s algorithm.
static QString	getMd5Hash(const QString &data)
static double	getNormalizedAngle(double a) Gets the normalized angle from a.
static void	getQuadRoots(double p[], double r[][5])
static double	getRelativeAngle(double a, double baseAngle)
static double	gra2deg(double a) Converts grads to degrees.
static bool	hasError()
static void	init()
static bool	isAngleBetween(double a, double a1, double a2, bool reversed) Tests if angle a is between a1 and a2.
static bool	isAngleReadable(double angle, double tolerance=0.01)
static bool	isBetween(double value, double limit1, double limit2, bool inclusive, double tolerance=RS::PointTolerance)
static bool	isInf(double v)
static bool	isNaN(double v)
static bool	isNormal(double v)
static bool	isSameDirection(double dir1, double dir2, double tol=RS::AngleTolerance) Tests if two angels point approximately in the same direction.
static bool	isSane(double v)
static double	makeAngleReadable(double angle, bool readable=true, bool *corrected=NULL) Adds 180° to the given angle if a text constructed with that angle otherwise wouldn’t be readable.
static int	mround(double v) Rounds the given double to the next int.
static RVector	parseCoordinate(const QString &coordinateString, const RVector &relativeZero) Parses the given string as coordinate.
static double	parseScale(const QString &scaleString)
static double	pow(double x, double y) Safe pow function.
static double	rad2deg(double a) Converts radians to degrees.
static double	rad2gra(double a) Converts radians to gradians.
static void	simplify(int numerator, int denominator, int &numeratorRes, int &denominatorRes)
static void	swap(T &a, T &b) Swaps two given values.
static void	toFraction(double v, int maxDenominator, int &number, int &numerator, int &denominator)
static QString	toFractionString(double v, int maxDenominator)
static QString	trimTrailingZeroes(const QString &s)
static double	trunc(double v)
static void	uninit()

Static Private Attributes

static QString	lastError
static QString	mathExt

Member Documentation

absmod

static int RMath::absmod(int a, int b)

static

Returns: Absolute modulus.

angleToString

static QString RMath::angleToString(double a)

static

Converts the given angle in rad to the given angle format.

containsFuzzy

static bool RMath::containsFuzzy(const QList< double > &values, double v, double tol=RS::PointTolerance)

static

deg2rad

static double RMath::deg2rad(double a)

static

Converts degrees to radians.

Parameters:

• a: angle in degrees

eval

static double RMath::eval(const QString &expression, bool *ok=NULL)

static

Evaluates the given mathematical expression and returns the result.

Angles may be expressed in degrees (default), rad (#r), gon (#g) or as surveyors angles (N#d#’#“E).

fuzzyAngleCompare

static bool RMath::fuzzyAngleCompare(double v1, double v2, double tolerance=RS::AngleTolerance)

static

fuzzyCompare

static bool RMath::fuzzyCompare(double v1, double v2, double tolerance=RS::PointTolerance)

static

Returns: True if the difference between v1 and v2 is less then the given tolerance.

getAngleDifference

static double RMath::getAngleDifference(double a1, double a2)

static

Parameters:

• a1: first angle in rad
• a2: second angle in rad

Returns: The angle that needs to be added to a1 to reach a2. Always positive and less than 2*pi.

getAngleDifference180

static double RMath::getAngleDifference180(double a1, double a2)

static

Parameters:

• a1: first angle in rad
• a2: s second angle in rad

Returns: The angle that needs to be added to a1 to reach a2. Always between -pi and pi.

getBiQuadRoots

static void RMath::getBiQuadRoots(double p[], double r[][5])

static

Non-Scriptable: This function is not available in script environments.

getCubicRoots

static void RMath::getCubicRoots(double p[], double r[][5])

static

Non-Scriptable: This function is not available in script environments.

getError

static QString RMath::getError()

static

Returns: Last error encountered by a math function.

getGcd

static int RMath::getGcd(int a, int b)

static

Finds greatest common divider using Euclid’s algorithm.

See also: http://en.wikipedia.org/wiki/Greatest_common_divisor

Parameters:

• a: the first number
• b: the second number

Returns: The greatest common divisor of a and b.

getMd5Hash

static QString RMath::getMd5Hash(const QString &data)

static

Returns: MD5 hash of given string as hex encoded string.

getNormalizedAngle

static double RMath::getNormalizedAngle(double a)

static

Gets the normalized angle from a.

Used to make sure that an angle is in the range between 0 and 2 pi.

Parameters:

• a: the unnormalized angle, e.g. 8

Returns: The angle a normalized to the range of $ 0 \ldots 2\pi $, e.g. normalized angle from 8 is 1.716.

getQuadRoots

static void RMath::getQuadRoots(double p[], double r[][5])

static

Non-Scriptable: This function is not available in script environments.

getRelativeAngle

static double RMath::getRelativeAngle(double a, double baseAngle)

static

Returns: Angle a as angle relative to baseAngle. Result is in range -PI < result < PI.

gra2deg

static double RMath::gra2deg(double a)

static

Converts grads to degrees.

Parameters:

• a: angle in grad (gon)

hasError

static bool RMath::hasError()

static

Returns: True if an error was encountered since the last check.

init

static void RMath::init()

static

isAngleBetween

static bool RMath::isAngleBetween(double a, double a1, double a2, bool reversed)

static

Tests if angle a is between a1 and a2.

a, a1 and a2 must be in the range between 0 and 2*PI. All angles in rad.

Parameters:

• a: the test angle
• a1: the lower limiting angle
• a2: the upper limiting angle
• reversed: True for clockwise testing. False for ccw testing.

Returns: true if the angle a is between a1 and a2.

isAngleReadable

static bool RMath::isAngleReadable(double angle, double tolerance=0.01)

static

Parameters:

• angle: The text angle in rad
• tolerance: The tolerance by which the angle still maybe in the unreadable range.

Returns: true: If the given angle is in a range that is readable for texts created with that angle.

isBetween

static bool RMath::isBetween(double value, double limit1, double limit2, bool inclusive, double tolerance=RS::PointTolerance)

static

Returns: True if the given value is between the given limits.

Parameters:

• inclusive: True to accept values close to the limits within the given tolerance.

isInf

static bool RMath::isInf(double v)

static

Returns: true if v is Inf.

isNaN

static bool RMath::isNaN(double v)

static

Returns: true if v is non NaN and not Inf.

Returns: true if v is NaN.

isNormal

static bool RMath::isNormal(double v)

static inline

isSameDirection

static bool RMath::isSameDirection(double dir1, double dir2, double tol=RS::AngleTolerance)

static

Tests if two angels point approximately in the same direction.

Parameters:

• dir1: first direction
• dir2: second direction
• tolerance: Tolerance in rad.

Return values:

• true: The two angles point in the same direction.
• false: The difference between the two angles is at least tolerance radians.

isSane

static bool RMath::isSane(double v)

static inline

Returns: True if v is neither NaN nor Inf.

Inline: this is called for every coordinate of every path of every frame. std::isfinite is exactly the condition of !isNaN(v) && !isInf(v) for all platform variants of those two.

makeAngleReadable

static double RMath::makeAngleReadable(double angle, bool readable=true, bool *corrected=NULL)

static

Adds 180° to the given angle if a text constructed with that angle otherwise wouldn’t be readable.

Used for dimension texts and for mirroring texts.

Parameters:

• angle: the original angle
• readable: true: make angle readable, false: unreadable
• corrected: Pointer to boolean that will point to true if the given angle was corrected, false otherwise, or null.

Returns: The given angle or the given angle + pi, depending which one is readable from the bottom or right.

mround

static int RMath::mround(double v)

static inline

Rounds the given double to the next int.

parseCoordinate

static RVector RMath::parseCoordinate(const QString &coordinateString, const RVector &relativeZero)

static

Parses the given string as coordinate.

Parameters:

• relativeZero: RVector position of relative zero point.
• str: String to parse (e.g. “34,15.6” or “@10,30” or “50<60”, …)

Returns: undefined if the string is not a coordinate, an invalid RVector if str is an invalid coordinate or the RVector result.

parseScale

static double RMath::parseScale(const QString &scaleString)

static

Returns: Value given as drawing scale (#:#).

pow

static double RMath::pow(double x, double y)

static

Safe pow function.

Parameters:

• x: the base
• y: the exponent

Returns: The value of x raised to the power of y.

rad2deg

static double RMath::rad2deg(double a)

static

Converts radians to degrees.

Parameters:

• a: angle in radians

rad2gra

static double RMath::rad2gra(double a)

static

Converts radians to gradians.

Parameters:

• a: angle in radians

simplify

static void RMath::simplify(int numerator, int denominator, int &numeratorRes, int &denominatorRes)

static

Returns: Simplified fraction for the given fraction (numerator/denomiator).

swap

template <class T>
static void RMath::swap(T &a, T &b)

static inline

Swaps two given values.

Non-Scriptable: This function is not available in script environments.

toFraction

static void RMath::toFraction(double v, int maxDenominator, int &number, int &numerator, int &denominator)

static

Returns: Representation of the given number as fraction (number numerator/denominator). Rounding occurs to satisfy the use of maxDenominator as maximum value for denominator.

toFractionString

static QString RMath::toFractionString(double v, int maxDenominator)

static

Returns: String representing the given number, expressed as fraction (# #/#).

trimTrailingZeroes

static QString RMath::trimTrailingZeroes(const QString &s)

static

trunc

static double RMath::trunc(double v)

static

Returns: v truncated (cut off) at decimal point.

uninit

static void RMath::uninit()

static

lastError

static QString RMath::lastError = ""

static private

All rights reserved.

This file is part of the QCAD project.

QCAD is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

QCAD 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 QCAD. Last error encountered.

mathExt

static QString RMath::mathExt = QString()

static private