num-valid 0.3.3

A robust numerical library providing validated types for real and complex numbers to prevent common floating-point errors like NaN propagation. Features a generic, layered architecture with support for native f64 and optional arbitrary-precision arithmetic.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! Documentation constants for mathematical function traits.
//!
//! This module contains reusable documentation strings for mathematical function traits,
//! reducing verbosity in macro invocations and improving maintainability.

// ============================================================================
// Logarithm Function Documentation
// ============================================================================

/// Trait documentation for natural logarithm (ln).
pub const DOC_LN_TRAIT: &str = "Trait for computing the [*natural logarithm*](https://en.wikipedia.org/wiki/Natural_logarithm) (base `e`) of a number.

Provides both a fallible method that returns a [`Result`] and a panicking method that directly returns the computed value or panics on invalid input.

# Associated Types

- `Error`: The error type that is returned by the `try_ln` method. This type must implement the [`std::error::Error`] trait.

# Required Methods

- `try_ln`: Computes the *natural logarithm* of `self` and returns a [`Result`]. If the computation is successful, it returns [`Ok`] with the computed value. If an error occurs, it returns [`Err`] with the associated error.
- `ln`: Computes the *natural logarithm* of `self` and directly returns the computed value. This method may panic (in Debug mode) if the computation fails.";

/// Try method documentation for natural logarithm.
pub const DOC_LN_TRY: &str = "Computes the *natural logarithm* of `self` and returns a [`Result`].

If the computation is successful, it returns [`Ok`] with the computed value. If an error occurs, it returns [`Err`] with the associated error.

# Errors

This method returns an error if the computation fails. The error type is defined by the associated [`Ln::Error`] type.";

/// Panicking method documentation for natural logarithm.
pub const DOC_LN_PANIC: &str = "Computes the *natural logarithm* of `self` and directly returns the computed value.

This method may panic (in Debug mode) if the computation fails.

# Panics

This method may panic (in Debug mode) if the computation fails. It is recommended to use the `try_ln` method for safe computations.";

/// Error type documentation for natural logarithm.
pub const DOC_LN_ERROR: &str = "The error type that is returned by the `try_ln` method.";

// ----------------------------------------------------------------------------

/// Trait documentation for base-10 logarithm (log10).
pub const DOC_LOG10_TRAIT: &str = "Trait for computing the [*base-10 logarithm*](https://en.wikipedia.org/wiki/Common_logarithm) of a number.

Provides both a fallible method that returns a [`Result`] and a panicking method that directly returns the computed value or panics on invalid input.

# Associated Types

- `Error`: The error type that is returned by the `try_log10` method. This type must implement the [`std::error::Error`] trait.

# Required Methods

- `try_log10`: Computes the *base-10 logarithm* of `self` and returns a [`Result`]. If the computation is successful, it returns [`Ok`] with the computed value. If an error occurs, it returns [`Err`] with the associated error.
- `log10`: Computes the *base-10 logarithm* of `self` and directly returns the computed value. This method may panic (in Debug mode) if the computation fails.";

/// Try method documentation for base-10 logarithm.
pub const DOC_LOG10_TRY: &str = "Computes the *base-10 logarithm* of `self` and returns a [`Result`].

If the computation is successful, it returns [`Ok`] with the computed value. If an error occurs, it returns [`Err`] with the associated error.

# Errors

This method returns an error if the computation fails. The error type is defined by the associated [`Log10::Error`] type.";

/// Panicking method documentation for base-10 logarithm.
pub const DOC_LOG10_PANIC: &str = "Computes the *base-10 logarithm* of `self` and directly returns the computed value.

This method may panic (in Debug mode) if the computation fails.

# Panics

This method may panic (in Debug mode) if the computation fails. It is recommended to use the `try_log10` method for safe computations.";

/// Error type documentation for base-10 logarithm.
pub const DOC_LOG10_ERROR: &str = "The error type that is returned by the `try_log10` method.";

// ----------------------------------------------------------------------------

/// Trait documentation for base-2 logarithm (log2).
pub const DOC_LOG2_TRAIT: &str = "Trait for computing the [*base-2 logarithm*](https://en.wikipedia.org/wiki/Binary_logarithm) of a number.

Provides both a fallible method that returns a [`Result`] and a panicking method that directly returns the computed value or panics on invalid input.

# Associated Types

- `Error`: The error type that is returned by the `try_log2` method. This type must implement the [`std::error::Error`] trait.

# Required Methods

- `try_log2`: Computes the *base-2 logarithm* of `self` and returns a [`Result`]. If the computation is successful, it returns [`Ok`] with the computed value. If an error occurs, it returns [`Err`] with the associated error.
- `log2`: Computes the *base-2 logarithm* of `self` and directly returns the computed value. This method may panic (in Debug mode) if the computation fails.";

/// Try method documentation for base-2 logarithm.
pub const DOC_LOG2_TRY: &str = "Computes the *base-2 logarithm* of `self` and returns a [`Result`].

If the computation is successful, it returns [`Ok`] with the computed value. If an error occurs, it returns [`Err`] with the associated error.

# Errors

This method returns an error if the computation fails. The error type is defined by the associated [`Log2::Error`] type.";

/// Panicking method documentation for base-2 logarithm.
pub const DOC_LOG2_PANIC: &str = "Computes the *base-2 logarithm* of `self` and directly returns the computed value.

This method may panic (in Debug mode) if the computation fails.

# Panics

This method may panic (in Debug mode) if the computation fails. It is recommended to use the `try_log2` method for safe computations.";

/// Error type documentation for base-2 logarithm.
pub const DOC_LOG2_ERROR: &str = "The error type that is returned by the `try_log2` method.";