NAME

Math::Handy - Handy math routines and operators that aren't in CORE Raku.

SYNOPSIS

use Math::Handy;

say 25!;  # 15511210043330985984000000

say Γ 1/2; # 1.7724538509055163

say binomial(9, 5); # 126

say Σ (^1e2).grep: &is-prime; # 1060

say Π (^1e2).grep: &is-prime; # 2305567963945518424753102147331756070

say 33 divmod 5;   # (6 3)

say 33 divmod 5.1; # (6 3)

say 33 /% 5.1;     # (6 2.5)

say adr 16781; # (5 2)

say mdr 16781; # (0 4)

say 180°; # 3.141592653589793

say 200ᵍ; # 3.141592653589793

DESCRIPTION

Math::Handy provides several handy functions and operators.

Factorial operators

factorial (Int) - the product of the integers from one to $n. Also available as postfix:<!> (Int).

Factorial is a discrete operation, only valid at integer values. For a continuous function, you want gamma (Real $n).

gamma (Real) is a continuous factorial function. Γ($n) =~= ($n - 1)!. Also available as Γ (Real $n) (Greek uppercase gamma). Calculated using Lanczos approximation. (Only valid for positive arguments at this point.)

Also related to factorial() is binomial().

binomial(Int $n, Int $p), very commonly appears in combinatorics. Is equivalently expressed as: n! / (p! × (n - p)!).

Arithematic operators

Raku has the very convenient sum function. Traditional mathematics spells it Σ. This module provides a Σ (*@list) operator to remedy that.

Another common mathematical operator that Raku left out is product(). Raku has the [*] meta reduce operator, but that is difficult to chain with other operations. This module provides both a product (*@list) routine, and the more traditionally spelled: Π (*@list) (Greek uppercase pi)

Raku has div, Raku has mod, Raku has polymod(), but sometimes you may want a plain old divmod.

infix:<divmod> (Real, Real) coerces arguments to Int and returns the whole divisions and the remainder.

Also available as infix:</%> (Real, Real): Real %/ Real which doesn't coerce.

Digital roots

The additive digital root of an Integer in a particular base, is the recursive sum of the digits until only a single digit remains. The persistance is the number of times the function needs to recurse to reach a single digit.

Provides digital-root (Int $n, :$base = 10). Calculates and returns the additive digital root and the persistance, by default in base 10. Pass in a named base (2 = 36) if a different base is desired. Also available as the abbreviated adr (Int $n, :$base = 10)

Similar to the additive digital-root() is the multiplicative-digital-root(). The multiplicative-digital-root (Int $n, :$base = 10) is the recursive product of the digits until only one digit remains. Returns the multiplicative digital root and the persistance. Also available as the abbreviated mdr (Int $n, :$base = 10)

Radian conversions

Raku provides a multitude of trigonometric functions, but they all work with radian angle measurements by default. To make it easy to work with degrees (360° in 2π radians), or gradians (400ᵍ in 2π radians), provides two postfix conversion routines.

postfix:<°> (Real $degrees) converts degree measurments to radians.

postfix:<ᵍ> (Real $gradians) converts gradian measurments to radians.

AUTHOR

Most of these were code snippets I or someone else wrote as helper functions for solving RosettaCode tasks.

If there is a routine you think should be added, or if I bungled one of the existing, please let me know.

Stephen Schulze (aka thundergnat thundergnat@comcast.net)

COPYRIGHT AND LICENSE

This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.