Sylvester.Arithmetic by Allister Beharry

<PackageReference Include="Sylvester.Arithmetic" Version="0.2.8.1" />

---

API Diff between 0.2.8.1 and 0.2.6

120 Additions 6 Removals

Sylvester

• public static class Arithmetic
  • public class N1<d1> : N10<0, 0, 0, 0, 0, 0, 0, 0, 0, d1> where d1 : Base10Digit
  • public class N10<d10, d9, d8, d7, d6, d5, d4, d3, d2, d1> : Number where d10 : Base10Digit where d9 : Base10Digit where d8 : Base10Digit where d7 : Base10Digit where d6 : Base10Digit where d5 : Base10Digit where d4 : Base10Digit where d3 : Base10Digit where d2 : Base10Digit where d1 : Base10Digit
  • public sealed class N10Overflow : IEquatable<N10Overflow>, IStructuralEquatable, IComparable<N10Overflow>, IComparable, IStructuralComparable
  • public sealed class N10Underflow : IEquatable<N10Underflow>, IStructuralEquatable, IComparable<N10Underflow>, IComparable, IStructuralComparable
  • public interface Number
  • public static _arg2 isNotZero<a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, _arg2, a1, a2, a3, a4, a5, a6, a7, a8, a9>(a x1, a1 x2, a2 x3, a3 x4, a4 x5, a5 x6, a6 x7, a7 x8, a8 x9, a9 x10)
  • public static j isZero<a, _arg20, b, c, d, e, f, g, h, i, _arg2, _arg4, _arg6, _arg8, _arg10, _arg12, _arg14, _arg16, _arg18, j, k, l, m, n, o, p, q, r, s>(a x1, k x2, l x3, m x4, n x5, o x6, p x7, q x8, r x9, s x10)
  • public static _arg3 max<dim0, dim1, _arg6, _arg3>(dim0 l, dim1 r)
  • public static _arg3 min<dim0, dim1, _arg6, _arg3>(dim0 l, dim1 r)
  • public static _arg11 noDigit1<a, b, c, d, e, f, g, h, i, j, _arg11>(a _arg1, b _arg2, c _arg3, d _arg4, e _arg5, f _arg6, g _arg7, h _arg8, i _arg9, j x1)
  • public static _arg11 noDigit10<a, _arg11, b, c, d, e, f, g, h, i, j>(a x10, b _arg1, c _arg2, d _arg3, e _arg4, f _arg5, g _arg6, h _arg7, i _arg8, j _arg9)
  • public static _arg11 noDigit2<a, b, c, d, e, f, g, h, i, _arg11, j>(a _arg1, b _arg2, c _arg3, d _arg4, e _arg5, f _arg6, g _arg7, h _arg8, i x2, j _arg9)
  • public static _arg11 noDigit3<a, b, c, d, e, f, g, h, _arg11, i, j>(a _arg1, b _arg2, c _arg3, d _arg4, e _arg5, f _arg6, g _arg7, h x3, i _arg8, j _arg9)
  • public static _arg11 noDigit4<a, b, c, d, e, f, g, _arg11, h, i, j>(a _arg1, b _arg2, c _arg3, d _arg4, e _arg5, f _arg6, g x4, h _arg7, i _arg8, j _arg9)
  • public static _arg11 noDigit5<a, b, c, d, e, f, _arg11, g, h, i, j>(a _arg1, b _arg2, c _arg3, d _arg4, e _arg5, f x5, g _arg6, h _arg7, i _arg8, j _arg9)
  • public static _arg11 noDigit6<a, b, c, d, e, _arg11, f, g, h, i, j>(a _arg1, b _arg2, c _arg3, d _arg4, e x6, f _arg5, g _arg6, h _arg7, i _arg8, j _arg9)
  • public static _arg11 noDigit7<a, b, c, d, _arg11, e, f, g, h, i, j>(a _arg1, b _arg2, c _arg3, d x7, e _arg4, f _arg5, g _arg6, h _arg7, i _arg8, j _arg9)
  • public static _arg11 noDigit8<a, b, c, _arg11, d, e, f, g, h, i, j>(a _arg1, b _arg2, c x8, d _arg3, e _arg4, f _arg5, g _arg6, h _arg7, i _arg8, j _arg9)
  • public static _arg11 noDigit9<a, b, _arg11, c, d, e, f, g, h, i, j>(a _arg1, b x9, c _arg2, d _arg3, e _arg4, f _arg5, g _arg6, h _arg7, i _arg8, j _arg9)
  • public static n number<n>() where n : Number
• public static class Base10
  • public class 0 : I0
  • public class 1 : I1
  • public class 2 : I2
  • public class 3 : I3
  • public class 4 : I4
  • public class 5 : I5
  • public class 6 : I6
  • public class 7 : I7
  • public class 8 : I8
  • public class 9 : I9
  • public interface I0 : ZeroDigit
  • public interface I1 : NonZeroDigit
  • public interface I2 : PrimeDigit, PowerOf2Digit, NonZeroDigit
  • public interface I3 : PrimeDigit, PowerOf3Digit, NonZeroDigit
  • public interface I4 : SquareDigit, PowerOf2Digit, NonZeroDigit
  • public interface I5 : PrimeDigit, PowerOf5Digit, NonZeroDigit
  • public interface I6 : MultipleOf3Digit, MultipleOf2Digit, NonZeroDigit
  • public interface I7 : PrimeDigit, NonZeroDigit
  • public interface I8 : PowerOf2Digit, NonZeroDigit
  • public interface I9 : SquareDigit, PowerOf3Digit, NonZeroDigit
  • public interface MultipleOf2Digit : Base10Digit
  • public interface MultipleOf3Digit : Base10Digit
  • public interface NonZeroDigit : Base10Digit
  • public interface PowerOf2Digit : MultipleOf2Digit
  • public interface PowerOf3Digit : MultipleOf3Digit
  • public interface PowerOf5Digit : Base10Digit
  • public interface PrimeDigit : Base10Digit
  • public interface SquareDigit : Base10Digit
  • public interface ZeroDigit : Base10Digit
  • public static 0 d0 { get; }
  • public static 1 d1 { get; }
  • public static 2 d2 { get; }
  • public static 3 d3 { get; }
  • public static 4 d4 { get; }
  • public static 5 d5 { get; }
  • public static 6 d6 { get; }
  • public static 7 d7 { get; }
  • public static 8 d8 { get; }
  • public static 9 d9 { get; }
  • public static ulong _val(Base10Digit d)
  • public static bool areEqual<d>(d _arg1, object b) where d : Base10Digit
  • public static d digit<d>() where d : Base10Digit
  • public static Type getCharBase10Type(char d)
  • public static Type[] getIntBase10TypeArray(int n, int length)
  • public static bool isEqualTo<d>(object b) where d : Base10Digit
• public interface Base10Digit
  • int Val { get; }
  • ulong Val_ { get; }
• public static class Bool
  • public interface Bool
  • public class False : Bool
  • public class True : Bool
  • public static False _false { get; }
  • public static True _true { get; }
• public static class Constraints
  • public sealed class Constraint<n> : IEquatable<Constraint<n>>, IStructuralEquatable, IComparable<Constraint<n>>, IComparable, IStructuralComparable
  • public sealed class Equal<n> : IEquatable<Equal<n>>, IStructuralEquatable, IComparable<Equal<n>>, IComparable, IStructuralComparable
  • public sealed class Failure : IEquatable<Failure>, IStructuralEquatable, IComparable<Failure>, IComparable, IStructuralComparable
  • public sealed class GreaterThan<n> : IEquatable<GreaterThan<n>>, IStructuralEquatable, IComparable<GreaterThan<n>>, IComparable, IStructuralComparable
  • public sealed class GreaterThanOrEqual<n> : IEquatable<GreaterThanOrEqual<n>>, IStructuralEquatable, IComparable<GreaterThanOrEqual<n>>, IComparable, IStructuralComparable
  • public sealed class IndexInRange<n> : IEquatable<IndexInRange<n>>, IStructuralEquatable, IComparable<IndexInRange<n>>, IComparable, IStructuralComparable
  • public sealed class IndexOutOfRange<n> : IEquatable<IndexOutOfRange<n>>, IStructuralEquatable, IComparable<IndexOutOfRange<n>>, IComparable, IStructuralComparable
  • public sealed class LessThan<n> : IEquatable<LessThan<n>>, IStructuralEquatable, IComparable<LessThan<n>>, IComparable, IStructuralComparable
  • public sealed class LessThanOrEqual<n> : IEquatable<LessThanOrEqual<n>>, IStructuralEquatable, IComparable<LessThanOrEqual<n>>, IComparable, IStructuralComparable
  • public sealed class NotEqual<n> : IEquatable<NotEqual<n>>, IStructuralEquatable, IComparable<NotEqual<n>>, IComparable, IStructuralComparable
  • public sealed class Success : IEquatable<Success>, IStructuralEquatable, IComparable<Success>, IComparable, IStructuralComparable
  • public static void check<a>(a q)
  • public static void checkeq<l, r>(l l, r r)
  • public static void checkgt<l, r>(l l, r r)
  • public static void checkgte<l, r>(l l, r r)
  • public static void checkidx<a, n>(a a, n l)
  • public static void checklt<l, r>(l l, r r)
  • public static void checklte<l, r>(l l, r r)
  • public static void checknoteq<l, r>(l l, r r)
  • public static r checkres<r, a>(r result, a condition)
• public static class N10
  • public static N1<0> 0 { get; }
  • public static N1<1> 1 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 1, 0> 10 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 1, 1> 11 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 1, 2> 12 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 1, 3> 13 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 1, 4> 14 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 1, 5> 15 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 1, 6> 16 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 1, 7> 17 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 1, 8> 18 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 1, 9> 19 { get; }
  • public static N1<2> 2 { get; }
  • public static N10<0, 0, 0, 0, 0, 0, 0, 0, 2, 0> 20 { get; }
  • public static N1<3> 3 { get; }
  • public static N1<4> 4 { get; }
  • public static N1<5> 5 { get; }
  • public static N1<6> 6 { get; }
  • public static N1<7> 7 { get; }
  • public static N1<8> 8 { get; }
  • public static N1<9> 9 { get; }
  • public static _arg3 pp<a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, a1, a2, _arg57, a3, a4, a5, _arg51, a6, a7, _arg45, a8, a9, _arg39, a10, a11, _arg33, a12, a13, _arg27, a14, a15, _arg21, a16, a17, _arg15, a18, a19, _arg9, a20, _arg3, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30>(a l) where a : N10<a21, a22, a23, a24, a25, a26, a27, a28, a29, a30> where a21 : Base10Digit where a22 : Base10Digit where a23 : Base10Digit where a24 : Base10Digit where a25 : Base10Digit where a26 : Base10Digit where a27 : Base10Digit where a28 : Base10Digit where a29 : Base10Digit where a30 : Base10Digit

Sylvester.Arithmetic

• public static class Base10
• public static class Bool
• public static class Constraints
• public static class N10
• public interface Number
• public static class NumberModule