numrs2 0.3.3

A Rust implementation inspired by NumPy for numerical computing (NumRS2)
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

//! Date and time functionality for NumRS
//!
//! This module provides data types for working with dates and times,
//! similar to NumPy's datetime64 and timedelta64.
//!
//! # Module Organization
//!
//! - [`units`] - Date and time unit enums (DateUnit, DateTimeUnit)
//! - [`mod@datetime64`] - DateTime64 type and date calculation functions
//! - [`mod@timedelta64`] - TimeDelta64 type and arithmetic operations
//! - [`timezone`] - Timezone support and business day calculations
//! - [`api`] - NumPy-compatible API functions and array operations
//!
//! # Examples
//!
//! ## Creating DateTime64 values
//!
//! ```
//! use numrs2::types::datetime::{DateTime64, DateTimeUnit, datetime64};
//!
//! // Using the constructor
//! let dt = DateTime64::new(100, DateTimeUnit::Second);
//!
//! // Using NumPy-compatible API
//! let dt2 = datetime64("2023-01-01", Some("D")).expect("should parse");
//! ```
//!
//! ## Working with timedeltas
//!
//! ```
//! use numrs2::types::datetime::{TimeDelta64, DateTimeUnit, timedelta64};
//!
//! // Using the constructor
//! let td = TimeDelta64::new(5, DateTimeUnit::Day);
//!
//! // Using NumPy-compatible API
//! let td2 = timedelta64(24, "h").expect("should create");
//! ```
//!
//! ## Timezone support
//!
//! ```
//! use numrs2::types::datetime::{DateTime64, DateTimeUnit, Timezone, TimezoneDateTime};
//!
//! let utc_dt = DateTime64::new(0, DateTimeUnit::Second);
//! let tz_dt = TimezoneDateTime::new(utc_dt, Timezone::est());
//! ```

// Submodules
pub mod api;
pub mod datetime64;
pub mod timedelta64;
pub mod timezone;
pub mod units;

// Re-export main types from units
pub use units::{parse_unit_string, DateTimeUnit, DateUnit};

// Re-export main types from datetime64
pub use datetime64::{
    date_from_days_since_epoch, days_in_month, days_since_epoch, days_to_date, is_leap_year,
    DateTime64,
};

// Re-export main types from timedelta64
pub use timedelta64::TimeDelta64;

// Re-export timezone types
pub use timezone::{business_days, Timezone, TimezoneDateTime};

// Re-export API functions
pub use api::{
    array_ops, datetime64, datetime_array, datetime_as_string, datetime_data, timedelta64,
};

#[cfg(test)]
mod integration_tests {
    use super::*;

    #[test]
    fn test_module_reexports() {
        // Verify all main types are accessible
        let _dt = DateTime64::new(0, DateTimeUnit::Second);
        let _td = TimeDelta64::new(1, DateTimeUnit::Day);
        let _tz = Timezone::utc();
    }

    #[test]
    fn test_api_functions() {
        // Verify API functions are accessible
        let dt = datetime64("2023-01-01", Some("D")).expect("should parse");
        let td = timedelta64(5, "D").expect("should create");
        let _s = datetime_as_string(&dt, None, None).expect("should convert");
        let (_unit, _count) = datetime_data(&dt);

        // Verify timedelta operations
        let dt2 = dt + td;
        assert!(dt2.value() > dt.value());
    }

    #[test]
    fn test_timezone_accessible() {
        let utc_dt = DateTime64::from_iso_string("2023-01-01T12:00:00", DateTimeUnit::Second)
            .expect("should parse");
        let tz_dt = TimezoneDateTime::new(utc_dt, Timezone::jst());
        assert_eq!(tz_dt.timezone.name, "JST");
    }

    #[test]
    fn test_business_days_accessible() {
        let dt =
            DateTime64::from_iso_string("2023-01-02", DateTimeUnit::Day).expect("should parse");
        let is_busday = business_days::is_busday(&dt).expect("should check");
        assert!(is_busday);
    }
}