Show HN: Zscilib, scientific computing lib for embedded devices
GitHub - zephyrproject-rtos/zscilib: An open-source scientific computing library for embedded systems running Zephyr OS or standalone.

Zephyr Scientific Library (zscilib)

The Zephyr Scientific Library (zscilib) is an attempt to provide a set of
functions useful for scientific computing, data analysis and data manipulation
in the context of resource constrained embedded hardware devices.
It is written entirely in C, and while the main development target for the
library is the Zephyr Project,
it tries to be as portable as possible, and a standalone reference project
is included to use this library in non-Zephyr-based projects.
This version of zscilib has been developed and tested against Zephyr 3.3.0.
Motivation
As the processing power of small, embedded MCUs increases and costs fall, more
computation can be done on the endnode itself. This allows for more of the
'complex' data analysis that used to take place at the PC or server level
(data aggregation, statistical analysis, etc.) to be done in less time,
using less data storage, and at a lower overall processing cost on small,
embedded devices.

A key goal of zscilib is to allow more data processing to happen on the
endnode.

By generating scientifically-relevant data points (standard SI units,
pre-filtered data, etc.) directly on the endnode, zscilib aims to be a bridge
between raw data and more numerically complex toolkits like gsl, numpy
or R.
What makes zscilib distinct?
Numerous high quality, mature, open source scientific libraries already exist:

GNU scientific library (gsl)
Lis (Library of Iterative Solvers for linear systems)
CMSIS-DSP

Despite the wealth of mature functions in these existing libraries, though,
they tend to have the following two problems in an embedded context:

They are overly broad and resource intensive (GSL, etc.), and thus aren't
appropriate for small, resource constrained devices like the ARM Cortex M
family.
They are missing many of the domain-specific features required to convert
raw sensor data into actionable information (CMSIS-DSP, Lis).

The second item is of particular importance, since the goal of embedded systems
is often 'sensing' via raw data, correlating that data, and acting on the final
data points or passing them on for further analysis.
CMSIS-DSP contains a number of highly efficient algorithms for filtering
raw sensor data, but it doesn't offer any domain-specific assistance converting
filtered accelerometer vectors into orientation data, for example, or reading
a set of photodiodes and converting that data into a useful photometric value
like lux. It is excellent at 'conditioning' data, but not at 'understanding' it.
zscilib aims to find a middle ground between these two, allowing for richer
processing of raw data, but within the confines and limitations of the class
of microcontrollers commonly used on low-cost sensor endnodes.
Quick Start: Standalone
A few makefile-based projects are included in samples/standalone showing
how zscilib can be used independent of Zephyr.
If you already have an appropriate GNU toolchain and build tools (make, etc.)
installed, you can simply execute the following commands:
$ cd samples/standalone/svd_pinv
$ make
$ bin/zscilib
  Hello, zscilib!
  ...
Quick Start: Zephyr RTOS
Running a sample application
To run one of the sample applications using qemu, run the following commands:

Be sure to run source zephyr/zephyr-env.sh (OS X or Linux) or
.\zephyr\zephyr-env.cmd (Windows) before the commands below! This also
assumes qemu-system-arm is available on your local system.

$ west build -p -b mps2/an521/cpu0 \
  modules/lib/zscilib/samples/matrix/mult -t run
...
*** Booting Zephyr OS build zephyr-v2.6.0-536-g89212a7fbf5f  ***
zscilib matrix mult demo

mtx multiply output (4x3 * 3x4 = 4x4):

14.000000 17.000000 20.000000 23.000000 
35.000000 44.000000 53.000000 62.000000 
56.000000 71.000000 86.000000 101.000000 
7.000000 9.000000 11.000000 13.000000 

Press CTRL+A then x to quit qemu.
Running Unit Tests
To run the unit tests for this library, run the following command:
$ twister --inline-logs -p mps2/an521/cpu0 -T modules/lib/zscilib/tests
See the tests folder for further details.
To run compliance tests to make sure submitted code matches Zephyr PR
requirements, run this (updating HEAD~2 for the number of commits to check,
or setting it to origin/master.. to check everything):
$ ../../../zephyr/scripts/ci/check_compliance.py \
  -m Gitlint -m Identity -m Nits -m pylint -m checkpatch \
  -c HEAD~2..
Debugging with QEMU
If you wish to debug using QEMU (and with minor variation actual hardware),
you can run the following commands to start a new GDB debug session.

For an overview of debugging in GDB, you may find the following presentation
useful: LVC21-308: Essential ARM Cortex-M Debugging with GDB

In one terminal window, run:
$ west build -p auto -b mps2/an521/cpu0 modules/lib/zscilib/samples/matrix/pinv
Once the ELF file has been built, we can start a GDB server on the default
1234 socket, and wait for a new connection via:
$ cd build
$ ninja debugserver
In a new terminal window, connect to the GDB server via:
$ cd <zephyr_path>
$ arm-none-eabi-gdb-py \
  --eval-command="target remote localhost:1234" \
  --se=build/zephyr/zephyr.elf

The -py extension is optional, and makes use of a version of GDB from the
ARM GNU toolchain releases that enables Python scripts to be used with your
debug sessions. See the LVC21-308 presentation at the top of this
section for details.

From here, you can start debugging with the (gdb) prompt.
For example:
(gdb) b main
(gdb) c
Continuing.

Breakpoint 1, main () at modules/lib/zscilib/samples/matrix/pinv/src/main.c:70
70              printf("\n\nzscilib pseudo-inverse demo\n\n");
(gdb) n
72              pinv_demo();
(gdb) step
pinv_demo () at modules/lib/zscilib/samples/matrix/pinv/src/main.c:25
25              zsl_real_t vi[18 * 3] = {
(gdb) n
... 
(gdb) quit

Floating-Point Usage
zscilib can be configured to make use of single-precision (32-bit) or
double-precision (64-bit) floating point values via the
CONFIG_ZSL_SINGLE_PRECISION flag, which will determine the size of
zsl_real_t used throughout the library. The default setting for this
flag is n, meaning 64-bit values are used by default.
There is a tradeoff between the added range and precision that 64-bit
(double-precision) floating point values offer, and the memory and performance
gains of the smaller, less-precise but faster 32-bit (single-precision)
operations.

Due to the reduced precision of single-precision values, certain complex
functions in zscilib are only available when double-precision is enabled
(PINV, SVD, etc.).

Comparison
Single-Precision (32-bit) Floats

Require 4 bytes of memory to store
Have about 7 significant digits of precision
Have a range of about 1.E-36 to 1.E+36
HW acceleration available on Cortex-M4F, Cortex-M7 and most Cortex-M33 MCUs.
Generates smaller, more efficient code than double

Double-Precision (64-bit) Floats

Requires 8 bytes of memory to store
Have about 13 significant digits of precision
Have a range of about 1.E-303 to 1.E+303
HW acceleration generally only available on large, Cortex-M7 MCUs
Generates larger code, with more processing overhead per operation

Float Stack Usage in Zephyr
The sample code in this library typically has the CONFIG_FPU option set,
meaning that floating-point support is configured for
Unshared FP registers mode. This mode is used when the application
has a single thread that uses floating point registers.
If your application makes use of multiple threads, and more than one of
these threads uses floating-point operations, you should also enable the
CONFIG_FPU_SHARING config flag, which configures the kernel for
Shared FP registers mode. In this mode, the floating point registers are
saved and restored during each context switch, even when the associated threads
are not using them. This feature comes at the expense of an extra 72 bytes of
stack memory per stack frame (s0..s15 + FPCSR, plus an alignment word
to ensure that the stack pointer is double-word aligned).
Current Features

Features marked with the
v0.2.0 flag are in progress
or planned as part of the current release cycle, and may be partially
implemented or stubbed at present.
v0.3.0 indicates features planned for that later release.

Linear Algebra
Vector Operations

f32: Single-precision floating-point operations
f64: Double-precision floating-point operations
ARM: Optimised Arm Thumb-2 ASM implementation




Feature
Func
f32
f64
Arm
Notes




Array to vector
zsl_vec_from_arr
x
x




Copy
zsl_vec_copy
x
x




Get subset
zsl_vec_get_subset
x
x




Add
zsl_vec_add
x
x




Subtract
zsl_vec_sub
x
x




Negate
zsl_vec_neg
x
x




Sum
zsl_vec_sum
x
x

2 or more vects


Scalar add
zsl_vec_scalar_add
x
x




Scalar multiply
zsl_vec_scalar_mult
x
x




Scalar divide
zsl_vec_scalar_div
x
x




Distance
zsl_vec_dist
x
x

Between 2 vects


Dot product
zsl_vec_dot
x
x




Norm/abs value
zsl_vec_norm
x
x




Project
zsl_vec_project
x
x




To unit vector
zsl_vec_to_unit
x
x




Cross product
zsl_vec_cross
x
x




Sum of squares
zsl_vec_sum_of_sqrs
x
x




Comp-wise mean
zsl_vec_mean
x
x




Arithmetic mean
zsl_vec_ar_mean
x
x




Reverse
zsl_vec_rev
x
x




Zero to end
zsl_vec_zte
x
x

0 vals to end


Equality check
zsl_vec_is_equal
x
x




Non-neg check
zsl_vec_is_nonneg
x
x

All values >= 0


Contains
zsl_vec_contains
x
x




Quicksort
zsl_vec_sort
x
x




Print
zsl_vec_print
x
x





Matrix Operations

f32: Single-precision floating-point operations
f64: Double-precision floating-point operations
ARM: Optimised Arm Thumb-2 ASM implementation




Feature
Func
f32
f64
Arm
Notes




Array to matrix
zsl_mtx_from_arr
x
x




Copy
zsl_mtx_copy
x
x




Get value
zsl_mtx_get
x
x




Set value
zsl_mtx_set
x
x




Get row
zsl_mtx_get_row
x
x




Set row
zsl_mtx_set_row
x
x




Get col
zsl_mtx_get_col
x
x




Set col
zsl_mtx_set_col
x
x




Add
zsl_mtx_add
x
x




Add (d)
zsl_mtx_add_d
x
x

Destructive


Sum rows
zsl_mtx_sum_rows_d
x
x

Destructive


Sum rows scaled
zsl_mtx_sum_rows_scaled_d
x
x

Destructive


Subtract
zsl_mtx_sub
x
x




Subtract (d)
zsl_mtx_sub_d
x
x

Destructive


Multiply
zsl_mtx_mult
x
x




Multiply (d)
zsl_mtx_mult_d
x
x

Destructive


Multiply sc (d)
zsl_mtx_scalar_mult_d
x
x

Destructive


Multiple row sc (d)
zsl_mtx_scalar_mult_row_d
x
x

Destructive


Transpose
zsl_mtx_trans
x
x




Adjoint 3x3
zsl_mtx_adjoint_3x3
x
x




Adjoint
zsl_mtx_adjoint
x
x




Wedge product
zsl_mtx_vec_wedge

x




Reduce
zsl_mtx_reduce
x
x

Row+col removal


Reduce (iter)
zsl_mtx_reduce_iter
x
x

Iterative ver.


Augment
zsl_mtx_augm_diag
x
x

Adds row+col(s)


Determinant 3x3
zsl_mtx_deter_3x3
x
x




Determinant
zsl_mtx_deter
x
x




Gaussian El.
zsl_mtx_gauss_elim
x
x




Gaussian El. (d)
zsl_mtx_gauss_elim_d
x
x

Destructive


Gaussian Rd.
zsl_mtx_gauss_reduc
x
x




Column norm.
zsl_mtx_cols_norm
x
x

Unitary col vals


Gram-Schimdt
zsl_mtx_gram_schmidt
x
x




Elem. norm.
zsl_mtx_norm_elem
x
x

Norm vals to i,j


Elem. norm. (d)
zsl_mtx_norm_elem_d
x
x

Destructive


Invert 3x3
zsl_mtx_inv_3x3
x
x




Invert
zsl_mtx_inv
x
x




Balance
zsl_mtx_balance
x
x




Householder Ref.
zsl_mtx_householder
x
x




QR decomposition
zsl_mtx_qrd
x
x




QR decomp. iter.
zsl_mtx_qrd_iter

x




Eigenvalues
zsl_mtx_eigenvalues

x




Eigenvectors
zsl_mtx_eigenvectors

x




SVD
zsl_mtx_svd

x




Pseudoinverse
zsl_mtx_pinv

x




Min value
zsl_mtx_min
x
x




Max value
zsl_mtx_max
x
x




Min index
zsl_mtx_min_idx
x
x




Max index
zsl_mtx_max_idx
x
x




Equality check
zsl_mtx_is_equal
x
x




Non-neg check
zsl_mtx_is_notneg
x
x

All values >= 0


Symmetr. check
zsl_mtx_is_sym
x
x




Print
zsl_mtx_print
x
x





Unary matrix operations
The following component-wise unary operations can be executed on a matrix
using the zsl_mtx_unary_op function:

 Increment (++)
 Decrement (--)
 Negative (-)
 Logical negation (!)
 Round
 Abs
 Floor
 Ceiling
 Exponent
 Natural log
 Log10
 Square root
 Sin, cos, tan
 Asin, acos, atan
 Sinh, cosh, tanh

Binary matrix operations
The following component-wise binary operations can be executed on a pair
of symmetric matrices using the zsl_mtx_binary_op function:

 Add (a + b)
 Subtract (a - b)
 Multiply (a * b)
 Divide (a / b)
 Mean (mean(a, b)
 Exponent (a^b)
 Min (min(a, b))
 Max (max(a, b))
 Equal (a == b)
 Not equal (a != b)
 Less than (a < b)
 Greater than (a > b)
 Less than or equal to (a <= b)
 Greater than or equal to (a >= b)


NOTE: Component-wise unary and binary matrix operations can also
make use of user-defined functions at the application level if the existing
operand list is not sufficient. See zsl_mtx_unary_func and
zsl_mtx_binary_func for details.

Numerical Analysis
Statistics

 Mean
 Trimmed mean
 Weighted mean
 Time-weighted mean
 De-mean
 Percentile (AKA quantile)
 Median
 Weighted median
 Quartile
 Interquartile range
 Mode
 Data range
 Mean absolute deviation
 Median absolute deviation from median
 Variance
 Standard deviation
 Covariance
 Covariance matrix
 Linear regression
 Multiple linear regression [1]
 Weighted multiple minear regression [1]
 Quadrid fitting (Least-squars fitting of a quadric surface) [1]
 Absolute error
 Relative error
 Standard error

[1] Only available in double-precision
Probability Operations

 Uniform probability density function (PDF)
 Uniform distribution mean
 Uniform distribution variance
 Uniform cumulative distribution function (CDF)
 Normal probability density function (PDF)
 Normal cumulative distribution function (CDF)
 Inverse Error function
 Inverse normal cumulative distribution function (CDF)
 Factorial
 Binomial coefficient
 Binomial probability density function (PDF)
 Binomial distribution mean
 Binomial distribution variance
 Binomial cumulative distribution function (CDF)
 Information entropy
 Bayes' Theorem

Interpolation

 Nearest neighbour (AKA 'piecewise constant')
 Linear (AKA 'piecewise linear')
 Natural cubic spline

Physics
Atomic

 Nuclear radius
 Atomic Radioactive decay
 Bohr orbital radius
 Bohr orbital velocity
 Bohr orbital energy
 Bragg's law

Dynamics

 Newton's second law
 Mass-acceleration relationship
 Friction (Fn, uK/s)
 Normal force on an incline (in newtons based on mass, gravity, angle)
 Tension
 Dynamic lever
 Pendulums

 Period
 Max Speed



Electrical Components

 Capacitance

 Charge, voltage
 Area, distance


 Energy stored in capacitor
 Energy stored in inductor
 Transformer turns to voltage
 Resistor/inductor/capacitor voltage relationship
 Resistor/capacitor charge/discharge

 Current during charge
 Current during discharge
 Charge (in coulombs) during charge
 Charge (in coulombs) during discharge


 Current of RL circuit in time

Electric

 Coulomb's law
 Charge density
 Potential energy
 Electric field
 Coulombs potential
 Electric flux
 Force from a charge

Electricity

 Current (charge per second)
 Resistors in series/parallel
 Capacitors in series/parallel
 Resistivity of wire
 Ohm's law
 Power

 Current, voltage
 Voltage, resistance
 Current, resistance



Energy

 Kinetic energy
 Elastic potential energy
 Gravitational potential energy
 Power (work/energy over time)
 Energy lost to friction
 Energy of a photon
 Mechanical energy of a system
 Total energy of a system

Fluids

 Density (of substance in Kg/m^2)
 Simple pressure (force, area)
 Pressure in a fluid (at a certain height/depth, gravity, density, surf. pres.)
 Bouyant Force
 Fluid flow rate proportion
 Fluid force rate proportion
 Bernoulli's equation
 Volume flow rate

Gases

 Average velocity of a gas molecule (mass, temp, moles)
 Ideal gas law (pressure based on moles, temp, volume)
 Boyle's law (relationship of pressure, volume)
 Charles/Gay-Lussac law (relationship of pressure, volume)

Gravitation

 Orbital period
 Escape velocity
 Gravitational acceleration
 Orbital velocity
 Gravitational force
 Gravitational potential energy

Kinematics

 Change in distance (initial velocity, time, acceleration)
 Initial position (final pos, init velocity, accel, time)
 Initial position (final pos, init velocity, final velocity, accel)
 Change in time (initial and final velocity, acceleration)
 Instantaneous velocity (initial velocity, time, acceleration)
 Velocity (initial velocity, distance, acceleration)
 Average velocity (distance, time)
 Acceleration (initial and final velocity, time)
 Centripetal acceleration (radius, period, via radius/speed or radius/period)

Magnetics

 Magnetic force
 Force on current carrying wire
 Torque on current loop
 Potential energy from a dipole
 Orbital radius in magnetic field
 Magnetic flux
 Magnetic moment

Mass

 Calculate the CoM of a group of objects based on their mass and
distance from an arbitrary point

Momentum

 Calculate momentum (mass, velocity)
 Impulse (force, time)
 Change in momentum/force (mass, initial and final velocity)
 Elastic collision (when two objects collide and bounce)
 Inelastic collision (when two objects collide and stick)

Optics

 Refraction index
 Snell's law
 Focus distance
 Critical angle of incision
 Power (based on focal length)
 Magnification (real and apparent length)
 Diffraction

Photons

 Energy
 Linear momentum
 Wavelength
 Frequency
 Kinetic energy of photoelectric effect

Projectiles

 Horizontal and vertical velocity components (initial velocity, theta)
 Total time of flight

Formula 1: gravity, y2, y1, Vy
Formula 2: initial and final vertical velocity and gravity


 Vertical motion: position at time (Vy, gravity, time, initial height)
 Horizontal motion: horizontal change of distance at time
 Velocity (overall velocity from vertical and horizontal components)
 Trajectory
 Theta (angle between vertical and horizontal velocity)
 Range (distance travelled from ground using initial velocity, gravity, angle)

Relativity (v0.3.0)

 Time dilatation
 Lorentz contraction
 Relativistic momentum
 Kinetic energy
 Mass to energy
 Lorenz velocity transformation
 Relativistic doppler affect

Rotation

 Change in theta (analog to distance in kinematics)
 Distance travelled in circular motion
 Number of rotations around circle
 Change in time (analog to time in kinematics)
 Instantaneous angular velocity
 Angular velocity
 Average angular velocity
 Angular acceleration
 Rotational kinetic energy
 Rotational period
 Rotational frequency
 Centripetal acceleration
 Total acceleration
 Mechanical power (torque multiplied by angular velocity)

Sound

 Pressure amplitude
 Decibels (sound level between two intensities of the same frequency)
 Intensity (pressure amplitude, bulk modulus, density)
 Shock wave angle (speed of sound and velocity through medium)
 Doppler effect
 Beats (frequency resulting from overlap of two similar frequencies)

Thermodynamics

 Temperature conversion (fahrenheit, celsius, kelvin)
 Latent heat of fusion/vaporisation
 Heat (in joules of a material based on mass, specific heat and delta temp)
 Linear expansion of metal (length, alpha constant, change in temperature)
 Mean free path
 Efficiency of a heat engine (based on energy of hot and cold chambers)
 Carnot engine proportion

Waves

TBD

Work

 Work done over an interval of distance and constant applied force
 Work done cosine (as above but with x-component or on an incline)
 Work done sine (as above but with y-component or on an incline)
 Work-KE theorem

Motion and Orientation
AHRS/Attitude (Degrees)

 Basic struct definitions
 Conversion

 To vector (access vector API)
 To Euler (degrees to radian)
 From Euler (radians to degrees)
 From Accel + Mag (roll, pitch, yaw)
 From Accel (roll, pitch)


 Angle between two accelerometers

Compass

 Degrees, Minutes, Seconds to Decimal Degrees (dms to dd)
 Magnetic north
 Geographic (AKA true) north

Euler Angles (Radians)

 Basic struct definitions
 Conversion

 To vector (access vector API)



Gravity

 Gravitational field from latitude and altitude

Quaternions

 Basic struct definitions
 Magnitude
 Unit check
 Scaling
 Multiplication
 Exp
 Log
 Exponentiation
 Conjugate
 Inverse
 Difference
 Rotate
 Interpolation

 Lerp
 Slerp


 Integration

 Angular velocity (rad/s + time + current value)
 Angular momentum (Same as above, plus rotational mass)


 Conversion

 To unit (Normalise)
 To Euler (radians)
 From Euler (radians)
 To rotation matrix
 From rotation matrix
 To axis-angle
 From axis-angle


 Special Forms

 Identity



Sensor Fusion

 Define generic fusion interface/struct (accel+mag+gyro -> quaternion)
 Matrix rotation (adjust device orientation)
 Axis-angle rotation (adjust device orientation)
 Calibration

 Magnetometer (hard-iron and soft-iron errors)
 Correct magnetometer (apply correction coefficients)
 Madgwick calibration
 Mahoney calibration


 Implementations

 AQUA
 Complementary
 Extended Kalman
 Madgwick
 Mahoney
 SAAM



Colorimetry
Types/Structs

 Spectral power distribution (SPD)
 CIE 1931 XYZ tristimulus
 CIE 1931 xyY chromaticity
 CIE 1960 UCS chromaticity
 CIE 1976 UCS chromaticity
 RGBA color using floating-space notation (0.0 .. 1.0)
 RGBA color using 8-bit values
 RGBA color using 16-bit values
 CIE 1960 CCT, Duv value pair
 CIE 1931 XYZ tristimulus values for a standard illuminant
 CIE 1931 XYZ tristimulus values for a standard observer model

Functions

 SPD normalisation
 SPD to XYZ tristimulus
 CIE 1931 xyY chromaticity to XYZ tristimulus
 CIE 1931 XYZ tristimulus values to xyY chromaticity
 CIE 1931 xyY chromaticity to CIE 1960 uv
 CIE 1931 XYZ tristimulus to CIE 1960 uv
 CIE 1960 uv to CIE 1931 XYZ tristimulus
 CIE 1960 uv to CIE 1931 xyY chromaticity
 CIE 1960 uv to CIE 1976 u'v'
 CIE 1976 u'v' value to CIE 1960 uv
 Color temperature to (u,v) chromaticity
 CIE 1960 CCT (Duv = 0.0) to CIE 1931 XYZ tristimulus
 CIE 1960 CCT (Duv = 0.0) to 8-bit RGBA (supplied XYZ to RGB color space correlation matrix)
 CIE 1960 CCT (Duv = 0.0) to float RGBA (supplied XYZ to RGB color space correlation matrix)
 CIE 1960 CCT and Duv pair to CIE 1931 xyY chromaticity
 CIE 1960 CCT and Duv pair to CIE 1931 XYZ tristimulus
 CIE 1960 (u, v) pair to CIE 1960 CCT and Duv pair using:

 McCamy
 Ohno 2014


 CIE 1931 XYZ tristimulus to 8-bit RGBA (supplied XYZ to RGB color space correlation matrix)
 CIE 1931 XYZ tristimulus to float RGBA (supplied XYZ to RGB color space correlation matrix)
 Gamma encode
 Gamma decode

Color Data
Illuminants

 A
 B
 C
 D50
 D55
 D65
 E
 ICC

CIE Standard Observer Models

 CIE 1931 2 degree standard observer color matching functions
 CIE 1964 10 degree standard observer color matching functions

CIE Luminous Efficiency Functions

 CIE 1988 Photopic
 CIE 1951 Scotopic
 CIE LERP interpolation helper function

XYZ to RGB Color Space Correlation Matrices

 XYZ to linear sRGB (D65)
 XYZ to linear sRGB (D50)
 XYZ to Adobe RGB 98
 XYZ to Sony S-Gamut3.cine D65
 XYZ to NTSC
 XYZ to PAL/SECAM
 XYZ to ITU-R BT.709
 XYZ to ITU-R BT.2020
 XYZ to ACES Primaries #0 (AP0)
 XYZ to ACES Primaries #1 (AP1)
 XYZ to DCI-P3
 XYZ to DCI-P3+
 XYZ to CIE RGB

Chemistry

 Periodic table data including:

 Full name
 Abbreviation
 Atomic number
 Standard atomic weight



Measurement API (v0.2.0)
The zsl_measurement struct is a proof of concept attempt at representing
measurements in a concise but unambiguous manner.
It consists of:

A measurement type (Base Type + Extended Type)
The SI unit it uses (SI Unit Type)
The specific C type used to represent it in memory (C Type)
Additional meta-data to help interpret the measurement payload

There is an option to adjust the measurement's scale in +/- 10^n steps
(Scale Factor) from the default SI unit and scale indicated by the SI Unit
Type. For example, if 'Ampere' is indicated as the SI unit, the measurement
could indicate that the value is in uA by setting the scale factor to -6.

 Measurement struct(s) (see: zsl_measurement)
 Base Measurement Types
 Extended Measurement Types

 Color
 Light
 Temperature
 Other groups TBD


 SI Units
 SI Scales
 C Types

Longer Term Planned Features
Help is welcome on the following planned or desirable features.
Scalar Operations

Fast trigonometry approximations

Digital Signal Processing (v0.3.0)

Simple moving average filter
Windowed moving average filter
Weighted moving average filter
Other basic IIR and FIR-type filters and helper functions.

Spectrometry

Conversion between radiometric and photometric units
Radiometric data to lux
Radiometric data to CCT/Duv
Spectral analysis

Calibration

Offset management
Correlation matrix generation
Non-linear compensation

Architecture-Specific Optimisations
Basic tooling has been added to allow for optimised architecture-specific
implementations of key functions in assembly.
At present, this feature isn't being actively used or developed, but an aim
of zscilib is to add optimised versions of key functions to try to get the
best possible performance out of limited resources.
Initial optimisation will target the Arm Cortex-M family of devices and the
Thumb and Thumb-2 instruction sets, though other architectures can be
accommodated if necessary or useful.
Code Style
Since the primary target of this codebase is running as a module in
Zephyr OS, it follows the same coding style, which is itself
based on the Linux kernel coding style.
You can format the source code to match this style automatically using the
uncrustify command line tool, which has plugins available for many
common text editors (Atom Beautify, for example).

Crustify rules file

Contributing
If you wish to contribute to this library, you can raise a PR as follows:

Fork the repository: https://github.com/zephyrproject-rtos/zscilib/fork
git clone your forked repository.
Update your local repo and commit any changes.
Push the changes out to your fork on Github.
Navigate to https://github.com/zephyrproject-rtos/zscilib and to the
right of the Branch menu click New pull request.
Fill out the form that is presented.
Click the Create Pull Request button to submit the PR.

Also have a look at the Issues page to see if there is any outstanding
work or issues that you might be able to help with!
License
Apache 2.0.
