mass.c File Reference

#include <assert.h>
#include <float.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include "pico/types.h"
#include "../include/mass.h"

Go to the source code of this file.

Functions
const char *const	mass_unit_to_string (const mass_unit_t u)
	Returns a pointer to char with the textual representation of the unit. More...
const double *const	mass_unit_to_ratio (const mass_unit_t u)
	Returns a pointer to a double with the number of micrograms per unit. More...
void	mass_convert (const double *const fromAmount, double *const toAmount, const mass_unit_t fromUnit, const mass_unit_t toUnit)
	Converts a floating point value from one unit to another. More...
void	mass_init (mass_t *const m, const mass_unit_t unit, const double val)
	Initialises a mass_t with the given unit and value. More...
void	mass_get_value (const mass_t *const m, double *const val)
	Sets val to the value representing the mass_t according to its unt. More...
void	mass_add (const mass_t *const lhs, const mass_t *const rhs, mass_t *const res)
	Add lhs to rhs and store result in res. More...
void	mass_sub (const mass_t *const lhs, const mass_t *const rhs, mass_t *const res)
	Substract rhs from lhs and store result in res. More...
void	mass_mul (const mass_t *const lhs, const mass_t *const rhs, mass_t *const res)
	Multiply lhs by rhs and store result in res. More...
bool	mass_div (const mass_t *const lhs, const mass_t *const rhs, mass_t *const res)
	Divide lhs by rhs and store result in res, returns false if rhs is 0. More...
void	mass_addeq (mass_t *const self, const mass_t *const rhs)
	Add rhs to self. More...
void	mass_subeq (mass_t *const self, const mass_t *const rhs)
	Subtract rhs from self. More...
void	mass_muleq (mass_t *const self, const mass_t *const rhs)
	Multiply self by rhs. More...
bool	mass_diveq (mass_t *const self, const mass_t *const rhs)
	Divide self by rhs, returns false if rhs is 0. More...
bool	mass_eq (const mass_t *const lhs, const mass_t *const rhs)
	Returns true if lhs equals rhs. More...
bool	mass_neq (const mass_t *const lhs, const mass_t *const rhs)
	Returns true if lhs does not equal rhs. More...
bool	mass_lt (const mass_t *const lhs, const mass_t *const rhs)
	Returns true if lhs is less than rhs. More...
bool	mass_gt (const mass_t *const lhs, const mass_t *const rhs)
	Returns true if lhs is greater than rhs. More...
bool	mass_lteq (const mass_t *const lhs, const mass_t *const rhs)
	Returns true if lhs is less than or equal to rhs. More...
bool	mass_gteq (const mass_t *const lhs, const mass_t *const rhs)
	Returns true if lhs is greater than or equal to rhs. More...
int	mass_to_string (const mass_t *const m, char *const buff)
	Fills buff with the string representation of the mass_t. eg. "32.4762 mg". More...

Function Documentation

mass_add()

void mass_add	(	const mass_t *const	lhs,
		const mass_t *const	rhs,
		mass_t *const	res
	)

Add lhs to rhs and store result in res.

Parameters

lhs
rhs
res

Definition at line 87 of file mass.c.

                       {
 
        assert(lhs != NULL);
        assert(rhs != NULL);
        assert(res != NULL);
 
        res->ug = lhs->ug + rhs->ug;
        res->unit = lhs->unit;
 
}

References mass_t::ug, and mass_t::unit.

Referenced by mass_addeq().

mass_addeq()

void mass_addeq	(	mass_t *const	self,
		const mass_t *const	rhs
	)

Add rhs to self.

Parameters

self
rhs

Definition at line 149 of file mass.c.

                             {
        mass_add(self, rhs, self);
}

References mass_add().

mass_convert()

void mass_convert	(	const double *const	fromAmount,
		double *const	toAmount,
		const mass_unit_t	fromUnit,
		const mass_unit_t	toUnit
	)

Converts a floating point value from one unit to another.

Parameters

fromAmount
toAmount
fromUnit
toUnit

Definition at line 40 of file mass.c.

                              {
 
        assert(fromAmount != NULL);
        assert(toAmount != NULL);
 
        if(fromUnit == toUnit) {
            *toAmount = *fromAmount;
        }
        else if(toUnit == mass_ug) {
            *toAmount = *fromAmount * *mass_unit_to_ratio(fromUnit);
        }
        else if(fromUnit == mass_ug) {
            *toAmount = *fromAmount / *mass_unit_to_ratio(toUnit);
        }
        else {
            mass_convert(fromAmount, toAmount, toUnit, mass_ug);
        }
 
}

References mass_convert(), mass_ug, and mass_unit_to_ratio().

Referenced by mass_convert(), mass_get_value(), and mass_init().

mass_div()

bool mass_div	(	const mass_t *const	lhs,
		const mass_t *const	rhs,
		mass_t *const	res
	)

Divide lhs by rhs and store result in res, returns false if rhs is 0.

Parameters

lhs
rhs
res

Returns

true

false

Definition at line 129 of file mass.c.

                       {
 
        assert(lhs != NULL);
        assert(rhs != NULL);
        assert(res != NULL);
 
        //if ~0; protect against div / 0
        if(fabs(rhs->ug) < DBL_EPSILON) {
            return false;
        }
 
        res->ug = lhs->ug / rhs->ug;
        res->unit = lhs->unit;
        return true;
 
}

References mass_t::ug, and mass_t::unit.

Referenced by mass_diveq().

mass_diveq()

bool mass_diveq	(	mass_t *const	self,
		const mass_t *const	rhs
	)

Divide self by rhs, returns false if rhs is 0.

Parameters

self
rhs

Returns

true

false

Definition at line 167 of file mass.c.

                             {
        return mass_div(self, rhs, self);
}

References mass_div().

mass_eq()

bool mass_eq	(	const mass_t *const	lhs,
		const mass_t *const	rhs
	)

Returns true if lhs equals rhs.

Parameters

lhs
rhs

Returns

true

false

Definition at line 173 of file mass.c.

                             {
 
        assert(lhs != NULL);
        assert(rhs != NULL);
 
        //if ~==; if approx ~0
        return fabs(lhs->ug - rhs->ug) < DBL_EPSILON;
 
}

References mass_t::ug.

Referenced by mass_neq().

mass_get_value()

void mass_get_value	(	const mass_t *const	m,
		double *const	val
	)

Sets val to the value representing the mass_t according to its unt.

Parameters

m
val

Definition at line 76 of file mass.c.

                       {
 
        assert(m != NULL);
        assert(val != NULL);
 
        mass_convert(&m->ug, val, mass_ug, m->unit);
 
}

References mass_convert(), mass_ug, mass_t::ug, and mass_t::unit.

Referenced by mass_to_string().

mass_gt()

bool mass_gt	(	const mass_t *const	lhs,
		const mass_t *const	rhs
	)

Returns true if lhs is greater than rhs.

Parameters

lhs
rhs

Returns

true

false

Definition at line 207 of file mass.c.

                             {
 
        assert(lhs != NULL);
        assert(rhs != NULL);
 
        return mass_lt(rhs, lhs);
 
}

References mass_lt().

Referenced by mass_lteq().

mass_gteq()

bool mass_gteq	(	const mass_t *const	lhs,
		const mass_t *const	rhs
	)

Returns true if lhs is greater than or equal to rhs.

Parameters

lhs
rhs

Returns

true

false

Definition at line 229 of file mass.c.

                             {
 
        assert(lhs != NULL);
        assert(rhs != NULL);
 
        return !mass_lt(lhs, rhs);
 
}

References mass_lt().

mass_init()

void mass_init	(	mass_t *const	m,
		const mass_unit_t	unit,
		const double	val
	)

Initialises a mass_t with the given unit and value.

Parameters

m
unit
val

Definition at line 64 of file mass.c.

                      {
 
        assert(m != NULL);
 
        mass_convert(&val, &m->ug, unit, mass_ug);
        m->unit = unit;
 
}

References mass_convert(), mass_ug, mass_t::ug, and mass_t::unit.

Referenced by scale_weight().

mass_lt()

bool mass_lt	(	const mass_t *const	lhs,
		const mass_t *const	rhs
	)

Returns true if lhs is less than rhs.

Parameters

lhs
rhs

Returns

true

false

Definition at line 196 of file mass.c.

                             {
 
        assert(lhs != NULL);
        assert(rhs != NULL);
 
        return lhs->ug < rhs->ug;
 
}

References mass_t::ug.

Referenced by mass_gt(), and mass_gteq().

mass_lteq()

bool mass_lteq	(	const mass_t *const	lhs,
		const mass_t *const	rhs
	)

Returns true if lhs is less than or equal to rhs.

Parameters

lhs
rhs

Returns

true

false

Definition at line 218 of file mass.c.

                             {
 
        assert(lhs != NULL);
        assert(rhs != NULL);
 
        return !mass_gt(lhs, rhs);
 
}

References mass_gt().

mass_mul()

void mass_mul	(	const mass_t *const	lhs,
		const mass_t *const	rhs,
		mass_t *const	res
	)

Multiply lhs by rhs and store result in res.

Parameters

lhs
rhs
res

Definition at line 115 of file mass.c.

                       {
 
        assert(lhs != NULL);
        assert(rhs != NULL);
        assert(res != NULL);
 
        res->ug = lhs->ug * rhs->ug;
        res->unit = lhs->unit;
 
}

References mass_t::ug, and mass_t::unit.

Referenced by mass_muleq().

mass_muleq()

void mass_muleq	(	mass_t *const	self,
		const mass_t *const	rhs
	)

Multiply self by rhs.

Parameters

self
rhs

Definition at line 161 of file mass.c.

                             {
        mass_mul(self, rhs, self);
}

References mass_mul().

mass_neq()

bool mass_neq	(	const mass_t *const	lhs,
		const mass_t *const	rhs
	)

Returns true if lhs does not equal rhs.

Parameters

lhs
rhs

Returns

true

false

Definition at line 185 of file mass.c.

                             {
 
        assert(lhs != NULL);
        assert(rhs != NULL);
 
        return !mass_eq(lhs, rhs);
 
}

References mass_eq().

mass_sub()

void mass_sub	(	const mass_t *const	lhs,
		const mass_t *const	rhs,
		mass_t *const	res
	)

Substract rhs from lhs and store result in res.

Parameters

lhs
rhs
res

Definition at line 101 of file mass.c.

                       {
 
        assert(lhs != NULL);
        assert(rhs != NULL);
        assert(res != NULL);
 
        res->ug = lhs->ug - rhs->ug;
        res->unit = lhs->unit;
 
}

References mass_t::ug, and mass_t::unit.

Referenced by mass_subeq().

mass_subeq()

void mass_subeq	(	mass_t *const	self,
		const mass_t *const	rhs
	)

Subtract rhs from self.

Parameters

self
rhs

Definition at line 155 of file mass.c.

                             {
        mass_sub(self, rhs, self);
}

References mass_sub().

mass_to_string()

int mass_to_string	(	const mass_t *const	m,
		char *const	buff
	)

Fills buff with the string representation of the mass_t. eg. "32.4762 mg".

Parameters

m
buff	Must be at least MASS_TO_STRING_BUFF_SIZE in length

Returns

int Returns result of snprintf

Definition at line 241 of file mass.c.

                      {
 
        assert(m != NULL);
        assert(buff != NULL);
 
        double n; //value
        mass_get_value(m, &n);
        double i; //int part; discard
        const double f = fabs(modf(n, &i)); //frac part
        uint d = 0; //decimal count
 
        //if less than the epsilon, then it's ~0
        if(f >= DBL_EPSILON) { 
            d = (uint)fmax(0, ceil(1 - log10(f)));
        }
 
        return snprintf(
            buff,
            MASS_TO_STRING_BUFF_SIZE,
            "%01.*f %s", //format
            d, //how many decimals
            n, //the value
            mass_unit_to_string(m->unit)); //suffix (ie. "kg")
 
}

References mass_get_value(), MASS_TO_STRING_BUFF_SIZE, mass_unit_to_string(), and mass_t::unit.

mass_unit_to_ratio()

const double* const mass_unit_to_ratio

(

const mass_unit_t

u

)

Returns a pointer to a double with the number of micrograms per unit.

Parameters

u

Returns

const double* const

Definition at line 36 of file mass.c.

                                                            {
    return &MASS_RATIOS[(uint)u];
}

References MASS_RATIOS.

Referenced by mass_convert().

mass_unit_to_string()

const char* const mass_unit_to_string

(

const mass_unit_t

u

)

Returns a pointer to char with the textual representation of the unit.

Parameters

u

Returns

const char* const

Definition at line 32 of file mass.c.

                                                           {
    return MASS_NAMES[(uint)u];
}

References MASS_NAMES.

Referenced by mass_to_string().