Function range 

pub fn range(x: f64, step: f64, size: usize, order: &str) -> Vec<f64>

range(x, step, size, order)

Generating function

The range function generates a sequence of floating-point numbers starting from x, with a specified step value, producing up to size elements, ordered either ascending (“asc”) or descending (“desc”).

The function returns an empty vector if:

• size exceeds 1,000,000 (to prevent excessively large sequences)
• step is nonpositive
• order is not “asc” or “desc”

This function is useful when you need a sequence of a specific size, especially in cases where the total range is not explicitly known or when you want to generate a fixed number of evenly spaced points.

Arguments

• x - The starting value of the sequence.
• step - The interval between consecutive numbers; must be positive.
• size - The number of elements to generate; capped at 1,000,000 for safety.
• order - A string slice indicating the sequence order: “asc” for ascending, “desc” for descending.

Returns

A vector containing the sequence of f64 values, ordered according to the order parameter.

Examples

use mathlab::math::range;
// For the order argument, use "asc" for ascending order or "desc" for descending order, otherwise the function will return [].
assert_eq!(range(0.0, 0.1, 10, "abcd"), []);
assert_eq!(range(0.0, 0.1, 0, "asc"), []); // The parameter size must be from 1 to 1 million.
assert_eq!(range(0.0, 0.1, 1000000000, "asc"), []); // The parameter size must be from 1 to 1 million.
assert_eq!(range(1.0, 1.0, 10, "asc"), [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]);
assert_eq!(range(0.0, 0.1, 10, "asc"), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]);
assert_eq!(range(0.0, 0.1, 10, "desc"), [0.0, -0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9]);
assert_eq!(range(0.9, 0.1, 10, "desc"), [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0]);
assert_eq!(range(0.0, 2.0, 3, "asc"), [0.0, 2.0, 4.0]);
assert_eq!(range(4.0, 2.0, 3, "desc"), [4.0, 2.0, 0.0]);

End Fun Doc