Namespaces
namespace	ballistics

namespace	odometry

namespace	transforms

Classes
class	Angle

class	Butterworth

struct	CMSISMat

class	DiscreteFilter
	DiscreteFilter class implements a discrete-time filter using the finite difference equation. More...

class	ExtendedKalman

class	FuzzyPD

struct	FuzzyPDConfig
	Specifies Fuzzy-specific configurable parameters in the PD controller. More...

class	FuzzyPDRuleTable

class	FuzzyRuleTableInterface

class	KalmanFilter

class	LinearInterpolationPredictor

class	LinearInterpolationPredictorWrapped

class	Ramp

class	SmoothPid

struct	SmoothPidConfig

class	WrappedFloat

Enumerations
enum	FilterType : uint8_t { LOWPASS = 0b00 , HIGHPASS = 0b01 , BANDPASS = 0b10 , BANDSTOP = 0b11 }

Functions
constexpr std::complex< double >	s2z (std::complex< double > s, double Ts)

template<uint8_t ORDER>
constexpr std::array< double, ORDER+1 >	expandPolynomial (std::array< std::complex< double >, ORDER > zeros)

template<uint8_t ORDER>
constexpr std::complex< double >	evaluateFrequencyResponse (const std::array< double, ORDER+1 > &b, const std::array< double, ORDER+1 > &a, double w, double Ts)

constexpr double	complex_abs (std::complex< double > z)

constexpr std::complex< double >	complex_sqrt (std::complex< double > z)

template<uint16_t A_ROWS, uint16_t A_COLS, uint16_t B_ROWS, uint16_t B_COLS>
CMSISMat< A_ROWS, A_COLS >	operator+ (const CMSISMat< A_ROWS, A_COLS > &a, const CMSISMat< B_ROWS, B_COLS > &b)

template<uint16_t A_ROWS, uint16_t A_COLS, uint16_t B_ROWS, uint16_t B_COLS>
CMSISMat< A_ROWS, A_COLS >	operator- (const CMSISMat< A_ROWS, A_COLS > &a, const CMSISMat< B_ROWS, B_COLS > &b)

template<uint16_t ROWS, uint16_t COLS>
CMSISMat< ROWS, COLS >	operator- (const CMSISMat< ROWS, COLS > &a)

template<uint16_t A_ROWS, uint16_t A_COLS, uint16_t B_ROWS, uint16_t B_COLS>
CMSISMat< A_ROWS, B_COLS >	operator* (const CMSISMat< A_ROWS, A_COLS > &a, const CMSISMat< B_ROWS, B_COLS > &b)

template<uint16_t ROWS, uint16_t COLS>
CMSISMat< ROWS, COLS >	operator* (const CMSISMat< ROWS, COLS > &a, float b)

template<uint16_t ROWS, uint16_t COLS>
CMSISMat< ROWS, COLS >	operator* (float b, const CMSISMat< ROWS, COLS > &a)

template<uint16_t ROWS, uint16_t COLS>
CMSISMat< ROWS, COLS >	operator/ (const CMSISMat< ROWS, COLS > &a, float b)

uint8_t	calculateCRC8 (const uint8_t *message, uint32_t messageLength, uint8_t initCRC8)

uint16_t	calculateCRC16 (const uint8_t *message, uint32_t messageLength, uint16_t initCRC16)

float	computeGain (const array< float, FuzzyPDRuleTable::NUM_FUZZY_MEMBERS > &weights, const array< float, FuzzyPDRuleTable::NUM_FUZZY_MEMBERS > &values)

bool	compareFloatClose (float val1, float val2, float epsilon)

template<typename T >
T	limitVal (T val, T min, T max)

float	lowPassFilter (float prevValue, float newValue, float alpha)

template<typename From , typename To >
To	reinterpretCopy (From from)

float	fastInvSqrt (float x)

CMSISMat< 3, 1 >	cross (const CMSISMat< 3, 1 > &a, const CMSISMat< 3, 1 > &b)

CMSISMat< 3, 3 >	fromEulerAngles (const float roll, const float pitch, const float yaw)

void	rotateVector (float x, float y, float radians)

constexpr int32_t	ceil (float num)

modm::Vector3f	eulerAnglesFromQuaternion (modm::Quaternion< float > &q)

template<typename T >
int	getSign (T val)

template<typename T , size_t xSize, size_t ySize>
float	interpolateLinear2D (const std::array< std::array< T, ySize >, xSize > &values, const float xMin, const float xMax, const float dx, const float yMin, const float yMax, const float dy, float xDes, float yDes)
	Bilinear Interpolation of a regularly-spaced grid of values. Let x = dimension 1 and y = dimension 2 of the 2D array of values.

Variables
const uint8_t	CRC8Table [256]

const uint16_t	CRC16Table [256]

Enumeration Type Documentation

◆ FilterType

enum tap::algorithms::FilterType : uint8_t

Enumerator
LOWPASS
HIGHPASS
BANDPASS
BANDSTOP

Function Documentation

◆ calculateCRC16()

uint16_t tap::algorithms::calculateCRC16	(	const uint8_t *	message,
		uint32_t	messageLength,
		uint16_t	initCRC16 = `CRC16_INIT`
	)

Fast crc16 calculation using a lookup table.

See also: calculateCRC8

Parameters

[in]	message	the message to be used for calculation.
[in]	messageLength	the number of bytes to look at when calculating the crc.
[in]	initCRC8	normally leave as CRC8_INIT.

Returns: the calculated crc.

◆ calculateCRC8()

uint8_t tap::algorithms::calculateCRC8	(	const uint8_t *	message,
		uint32_t	messageLength,
		uint8_t	initCRC8 = `CRC8_INIT`
	)

Fast crc8 calculation using a lookup table. The crc looks at messageLength bytes in the message to calculate the crc.

Parameters

[in]	message	the message to be used for calculation.
[in]	messageLength	the number of bytes to look at when calculating the crc.
[in]	initCRC8	normally leave as CRC8_INIT.

Returns: the calculated crc.

◆ ceil()

constexpr int32_t tap::algorithms::ceil ( float num )

constexpr

Constexpr ceil (https://stackoverflow.com/questions/31952237/looking-for-a-constexpr-ceil-function).

◆ compareFloatClose()

bool tap::algorithms::compareFloatClose	(	float	val1,
		float	val2,
		float	epsilon
	)

inline

Use this instead of the == operator when asserting equality for floats. Performs

fabsf(val1-val2)<=epsilon

Parameters

[in]	val1	the first value to compare.
[in]	val2	the second value to compare.
[in]	epsilon	the floating point equality tolerance, for equality a recommended epsilon is 1E-6, though any small epsilon will do.

Returns: true if val1 and val2 are equal within some epsilon tolerance, false otherwise.

◆ complex_abs()

constexpr double tap::algorithms::complex_abs ( std::complex< double > z )

constexpr

used to calculate the magnitude of a complex number, created for constexpr useage

Parameters

[in] z the complex number to calculate the magnitude of

Returns: the magnitude of the complex number

◆ complex_sqrt()

constexpr std::complex< double > tap::algorithms::complex_sqrt ( std::complex< double > z )

constexpr

used to calculate the square root of a complex number, created for constexpr useage

Parameters

[in] z the complex number to calculate the square root of

Returns: the square root of the complex number

◆ computeGain()

float tap::algorithms::computeGain	(	const array< float, FuzzyPDRuleTable::NUM_FUZZY_MEMBERS > &	weights,
		const array< float, FuzzyPDRuleTable::NUM_FUZZY_MEMBERS > &	values
	)

inline

Computes dot product of weights and values, in essence computing the weighted gain, a linear combination of the values

◆ cross()

tap::algorithms::CMSISMat< 3, 1 > tap::algorithms::cross	(	const CMSISMat< 3, 1 > &	a,
		const CMSISMat< 3, 1 > &	b
	)

Compute the cross product of two 3x1 matrices

◆ eulerAnglesFromQuaternion()

modm::Vector3f tap::algorithms::eulerAnglesFromQuaternion ( modm::Quaternion< float > & q )

Returns <roll, pitch, yaw> decoded from q

◆ evaluateFrequencyResponse()

template<uint8_t ORDER>

constexpr std::complex< double > tap::algorithms::evaluateFrequencyResponse	(	const std::array< double, ORDER+1 > &	b,
		const std::array< double, ORDER+1 > &	a,
		double	w,
		double	Ts
	)

constexpr

used to evaluate the frequency response of a filter at a given frequency

Parameters

[in]	b	the numerator coefficients of the filter
[in]	a	the denominator coefficients of the filter
[in]	w	the frequency to evaluate at in rad/s
[in]	Ts	the sample time

Returns: the frequency response of the filter at the given frequency

◆ expandPolynomial()

template<uint8_t ORDER>

constexpr std::array< double, ORDER+1 > tap::algorithms::expandPolynomial ( std::array< std::complex< double >, ORDER > zeros )

constexpr

used to multiply out a series of zeros to obtain a list of coefficients

Parameters

[in] zeros a vector of complex poles or zeros to multiply out, works for any polynomial in the form of (x - z1)(x - z2)...(x - zn) where z1, z2, ... zn are the value of zeros.

Returns: a vector of coefficients for the polynomial with the 0th index being the constant term and the last index being the leading coefficient

Note: the coefficients are returned as doubles, the imaginary part of the complex number is ignored

◆ fastInvSqrt()

float tap::algorithms::fastInvSqrt ( float x )

Fast inverse square-root, to calculate 1/Sqrt(x).

Parameters

[in] input:x

Return values

1/Sqrt(x)

◆ fromEulerAngles()

tap::algorithms::CMSISMat< 3, 3 > tap::algorithms::fromEulerAngles	(	const float	roll,
		const float	pitch,
		const float	yaw
	)

Generates a 3x3 rotation matrix from euler angles (in radians)

◆ getSign()

template<typename T >

int tap::algorithms::getSign ( T val )

Returns the sign of the value passed in. Either -1, 0, or 1. Works for all base types and any types that implement construction from an int. Faster than copysign.

◆ interpolateLinear2D()

template<typename T , size_t xSize, size_t ySize>

float tap::algorithms::interpolateLinear2D	(	const std::array< std::array< T, ySize >, xSize > &	values,
		const float	xMin,
		const float	xMax,
		const float	dx,
		const float	yMin,
		const float	yMax,
		const float	dy,
		float	xDes,
		float	yDes
	)

Bilinear Interpolation of a regularly-spaced grid of values. Let x = dimension 1 and y = dimension 2 of the 2D array of values.

Parameters

values 2D-array pointer of f(x,y) values

Returns: approximation of values at (xdes,ydes)

◆ limitVal()

template<typename T >

T tap::algorithms::limitVal	(	T	val,
		T	min,
		T	max
	)

inline

Limits the value between some min an max (between [min, max]).

Template Parameters

T	the type you would like to limit.

Parameters

[in]	val	the value to limit.
[in]	min	the min that val will be limited to.
[in]	max	the max that val will be limited to.

Returns: the limited value.

◆ lowPassFilter()

float tap::algorithms::lowPassFilter	(	float	prevValue,
		float	newValue,
		float	alpha
	)

inline

A simple floating point low pass filter, e.g. $y_{filtered} = \alpha \cdot y_{n+1} + (1-\alpha) \cdot y_n$

Here is a simple use case. To use the low pass filter, pass in the val you are low passing in as the first parameter and have that value accept what lowPassFilter returns.

val = lowPassFilter(val, newValue, 0.1f);

tap::algorithms::lowPassFilter

float lowPassFilter(float prevValue, float newValue, float alpha)

Definition math_user_utils.hpp:113

Note: Only use this if you are willing to introduce some lag into your system, and be careful if you do.

Parameters

[in]	prevValue	The previous low passed value.
[in]	newValue	The new data to be passed into the low pass filter.
[in]	alpha	The amount of smoothing. The larger the alpha, the less smoothing occurs. An alpha of 1 means that you want to favor the newValue and thus is not doing any filtering. Must be between [0, 1].

Returns: The newly low passed filter data.

◆ operator*() [1/3]

template<uint16_t A_ROWS, uint16_t A_COLS, uint16_t B_ROWS, uint16_t B_COLS>

CMSISMat< A_ROWS, B_COLS > tap::algorithms::operator*	(	const CMSISMat< A_ROWS, A_COLS > &	a,
		const CMSISMat< B_ROWS, B_COLS > &	b
	)

inline

◆ operator*() [2/3]

template<uint16_t ROWS, uint16_t COLS>

CMSISMat< ROWS, COLS > tap::algorithms::operator*	(	const CMSISMat< ROWS, COLS > &	a,
		float	b
	)

inline

◆ operator*() [3/3]

template<uint16_t ROWS, uint16_t COLS>

CMSISMat< ROWS, COLS > tap::algorithms::operator*	(	float	b,
		const CMSISMat< ROWS, COLS > &	a
	)

inline

◆ operator+()

template<uint16_t A_ROWS, uint16_t A_COLS, uint16_t B_ROWS, uint16_t B_COLS>

CMSISMat< A_ROWS, A_COLS > tap::algorithms::operator+	(	const CMSISMat< A_ROWS, A_COLS > &	a,
		const CMSISMat< B_ROWS, B_COLS > &	b
	)

inline

◆ operator-() [1/2]

template<uint16_t A_ROWS, uint16_t A_COLS, uint16_t B_ROWS, uint16_t B_COLS>

CMSISMat< A_ROWS, A_COLS > tap::algorithms::operator-	(	const CMSISMat< A_ROWS, A_COLS > &	a,
		const CMSISMat< B_ROWS, B_COLS > &	b
	)

inline

◆ operator-() [2/2]

template<uint16_t ROWS, uint16_t COLS>

CMSISMat< ROWS, COLS > tap::algorithms::operator- ( const CMSISMat< ROWS, COLS > & a )

inline

◆ operator/()

template<uint16_t ROWS, uint16_t COLS>

CMSISMat< ROWS, COLS > tap::algorithms::operator/	(	const CMSISMat< ROWS, COLS > &	a,
		float	b
	)

inline

◆ reinterpretCopy()

template<typename From , typename To >

To tap::algorithms::reinterpretCopy ( From from )

◆ rotateVector()

void tap::algorithms::rotateVector	(	float *	x,
		float *	y,
		float	radians
	)

Performs a rotation matrix on the given x and y components of a vector.

Parameters

x	the x component of the vector to be rotated.
y	the y component of the vector to be rotated.
angle	the angle by which to rotate the vector <x, y>, in radians.

Return values

none.

◆ s2z()

constexpr std::complex< double > tap::algorithms::s2z	(	std::complex< double >	s,
		double	Ts
	)

constexpr

used to transform poles from the laplace domain to the Z domain for discrete time using the bilinear transform

Parameters

[in]	s	a pole or zero from the laplace domain
[in]	Ts	the sample time

Returns: a complex number corresponding to the Z domain location

Variable Documentation

◆ CRC16Table

const uint16_t tap::algorithms::CRC16Table[256]

Initial value:

= {
    0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 0x8c48, 0x9dc1, 0xaf5a, 0xbed3,
    0xca6c, 0xdbe5, 0xe97e, 0xf8f7, 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
    0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, 0x2102, 0x308b, 0x0210, 0x1399,
    0x6726, 0x76af, 0x4434, 0x55bd, 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
    0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 0xbdcb, 0xac42, 0x9ed9, 0x8f50,
    0xfbef, 0xea66, 0xd8fd, 0xc974, 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
    0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 0x5285, 0x430c, 0x7197, 0x601e,
    0x14a1, 0x0528, 0x37b3, 0x263a, 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
    0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 0xef4e, 0xfec7, 0xcc5c, 0xddd5,
    0xa96a, 0xb8e3, 0x8a78, 0x9bf1, 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
    0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 0x8408, 0x9581, 0xa71a, 0xb693,
    0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
    0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 0x18c1, 0x0948, 0x3bd3, 0x2a5a,
    0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
    0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 0xb58b, 0xa402, 0x9699, 0x8710,
    0xf3af, 0xe226, 0xd0bd, 0xc134, 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
    0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 0x4a44, 0x5bcd, 0x6956, 0x78df,
    0x0c60, 0x1de9, 0x2f72, 0x3efb, 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
    0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 0xe70e, 0xf687, 0xc41c, 0xd595,
    0xa12a, 0xb0a3, 0x8238, 0x93b1, 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
    0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 0x7bc7, 0x6a4e, 0x58d5, 0x495c,
    0x3de3, 0x2c6a, 0x1ef1, 0x0f78}

◆ CRC8Table

const uint8_t tap::algorithms::CRC8Table[256]

Initial value:

= {
    0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41,
    0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e, 0x5f, 0x01, 0xe3, 0xbd, 0x3e, 0x60, 0x82, 0xdc,
    0x23, 0x7d, 0x9f, 0xc1, 0x42, 0x1c, 0xfe, 0xa0, 0xe1, 0xbf, 0x5d, 0x03, 0x80, 0xde, 0x3c, 0x62,
    0xbe, 0xe0, 0x02, 0x5c, 0xdf, 0x81, 0x63, 0x3d, 0x7c, 0x22, 0xc0, 0x9e, 0x1d, 0x43, 0xa1, 0xff,
    0x46, 0x18, 0xfa, 0xa4, 0x27, 0x79, 0x9b, 0xc5, 0x84, 0xda, 0x38, 0x66, 0xe5, 0xbb, 0x59, 0x07,
    0xdb, 0x85, 0x67, 0x39, 0xba, 0xe4, 0x06, 0x58, 0x19, 0x47, 0xa5, 0xfb, 0x78, 0x26, 0xc4, 0x9a,
    0x65, 0x3b, 0xd9, 0x87, 0x04, 0x5a, 0xb8, 0xe6, 0xa7, 0xf9, 0x1b, 0x45, 0xc6, 0x98, 0x7a, 0x24,
    0xf8, 0xa6, 0x44, 0x1a, 0x99, 0xc7, 0x25, 0x7b, 0x3a, 0x64, 0x86, 0xd8, 0x5b, 0x05, 0xe7, 0xb9,
    0x8c, 0xd2, 0x30, 0x6e, 0xed, 0xb3, 0x51, 0x0f, 0x4e, 0x10, 0xf2, 0xac, 0x2f, 0x71, 0x93, 0xcd,
    0x11, 0x4f, 0xad, 0xf3, 0x70, 0x2e, 0xcc, 0x92, 0xd3, 0x8d, 0x6f, 0x31, 0xb2, 0xec, 0x0e, 0x50,
    0xaf, 0xf1, 0x13, 0x4d, 0xce, 0x90, 0x72, 0x2c, 0x6d, 0x33, 0xd1, 0x8f, 0x0c, 0x52, 0xb0, 0xee,
    0x32, 0x6c, 0x8e, 0xd0, 0x53, 0x0d, 0xef, 0xb1, 0xf0, 0xae, 0x4c, 0x12, 0x91, 0xcf, 0x2d, 0x73,
    0xca, 0x94, 0x76, 0x28, 0xab, 0xf5, 0x17, 0x49, 0x08, 0x56, 0xb4, 0xea, 0x69, 0x37, 0xd5, 0x8b,
    0x57, 0x09, 0xeb, 0xb5, 0x36, 0x68, 0x8a, 0xd4, 0x95, 0xcb, 0x29, 0x77, 0xf4, 0xaa, 0x48, 0x16,
    0xe9, 0xb7, 0x55, 0x0b, 0x88, 0xd6, 0x34, 0x6a, 0x2b, 0x75, 0x97, 0xc9, 0x4a, 0x14, 0xf6, 0xa8,
    0x74, 0x2a, 0xc8, 0x96, 0x15, 0x4b, 0xa9, 0xf7, 0xb6, 0xe8, 0x0a, 0x54, 0xd7, 0x89, 0x6b, 0x35,
}

Namespaces

Classes

Enumerations

Functions

Variables

Enumeration Type Documentation

◆ FilterType

Function Documentation

◆ calculateCRC16()

◆ calculateCRC8()

◆ ceil()

◆ compareFloatClose()

◆ complex_abs()

◆ complex_sqrt()

◆ computeGain()

◆ cross()

◆ eulerAnglesFromQuaternion()

◆ evaluateFrequencyResponse()

◆ expandPolynomial()

◆ fastInvSqrt()

◆ fromEulerAngles()

◆ getSign()

◆ interpolateLinear2D()

◆ limitVal()

◆ lowPassFilter()

◆ operator*() [1/3]

◆ operator*() [2/3]

◆ operator*() [3/3]

◆ operator+()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator/()

◆ reinterpretCopy()

◆ rotateVector()

◆ s2z()

Variable Documentation

◆ CRC16Table

◆ CRC8Table