diff --git a/src/earth_orbit.rs b/src/earth_orbit.rs
index 7ab7f29..cd695b1 100644
--- a/src/earth_orbit.rs
+++ b/src/earth_orbit.rs
@@ -14,7 +14,7 @@ enum Event {
     DecemberSolstice
 }
 
-fn get_time_of(event: Event, timestamp: i64) -> i64 {
+fn time_of(event: Event, timestamp: i64) -> i64 {
     let jd = unix_to_julian(timestamp);
 
     let y = jde_to_julian_year(jd).floor();
@@ -22,7 +22,7 @@ fn get_time_of(event: Event, timestamp: i64) -> i64 {
     // Convert AD year to millenia, from 2000 AD
     let m = (y - 2000.0) / 1000.0;
 
-    let jdme = get_jdme(event, m);
+    let jdme = jdme(event, m);
 
     // Julian century
     let t = (jdme - J2000) / 36525.0;
@@ -31,13 +31,13 @@ fn get_time_of(event: Event, timestamp: i64) -> i64 {
 
     let l = 1.0 + 0.0334 * cos_deg(w) + 0.0007 * cos_deg(2.0 * w);
 
-    let s = get_periodic_terms(t);
+    let s = periodic_terms(t);
 
     // FIXME: Improve the accuracy
     terrestrial_to_universal_time(julian_to_unix(jdme + (0.00001 * s) / l))
 }
 
-fn get_jdme(event: Event, m: f64) -> f64 {
+fn jdme(event: Event, m: f64) -> f64 {
     let jdme_terms = vec![
         (2451_623.80984, 365_242.37404,  0.05169, -0.00411, -0.00057), // March Equinoxe
         (2451_716.56767, 365_241.62603,  0.00325,  0.00888, -0.00030), // June Solstice
@@ -54,7 +54,7 @@ fn get_jdme(event: Event, m: f64) -> f64 {
       + e * m.powi(4)
 }
 
-fn get_periodic_terms(t: f64) -> f64 {
+fn periodic_terms(t: f64) -> f64 {
     let terms = vec![
         (485.0, 324.96,   1934.136),
         (203.0, 337.23,  32964.467),
@@ -87,56 +87,56 @@ fn get_periodic_terms(t: f64) -> f64 {
     })
 }
 
-fn get_previous_time_of(event: Event, timestamp: i64) -> i64 {
-    let time_of_event = get_time_of(event, timestamp);
+fn previous_time_of(event: Event, timestamp: i64) -> i64 {
+    let time_of_event = time_of(event, timestamp);
     if time_of_event >= timestamp {
         let delta = (365.25 * 86400.0) as i64;
-        get_time_of(event, timestamp - delta)
+        time_of(event, timestamp - delta)
     } else {
         time_of_event
     }
 }
 
-fn get_next_time_of(event: Event, timestamp: i64) -> i64 {
-    let time_of_event = get_time_of(event, timestamp);
+fn next_time_of(event: Event, timestamp: i64) -> i64 {
+    let time_of_event = time_of(event, timestamp);
     if time_of_event <= timestamp {
         let delta = (365.25 * 86400.0) as i64;
-        get_time_of(event, timestamp + delta)
+        time_of(event, timestamp + delta)
     } else {
         time_of_event
     }
 }
 
-pub fn get_previous_march_equinox(timestamp: i64) -> i64 {
-    get_previous_time_of(Event::MarchEquinox, timestamp)
+pub fn previous_march_equinox(timestamp: i64) -> i64 {
+    previous_time_of(Event::MarchEquinox, timestamp)
 }
 
-pub fn get_next_march_equinox(timestamp: i64) -> i64 {
-    get_next_time_of(Event::MarchEquinox, timestamp)
+pub fn next_march_equinox(timestamp: i64) -> i64 {
+    next_time_of(Event::MarchEquinox, timestamp)
 }
 
-pub fn get_previous_june_solstice(timestamp: i64) -> i64 {
-    get_previous_time_of(Event::JuneSolstice, timestamp)
+pub fn previous_june_solstice(timestamp: i64) -> i64 {
+    previous_time_of(Event::JuneSolstice, timestamp)
 }
 
-pub fn get_next_june_solstice(timestamp: i64) -> i64 {
-    get_next_time_of(Event::JuneSolstice, timestamp)
+pub fn next_june_solstice(timestamp: i64) -> i64 {
+    next_time_of(Event::JuneSolstice, timestamp)
 }
 
-pub fn get_previous_september_equinox(timestamp: i64) -> i64 {
-    get_previous_time_of(Event::SeptemberEquinox, timestamp)
+pub fn previous_september_equinox(timestamp: i64) -> i64 {
+    previous_time_of(Event::SeptemberEquinox, timestamp)
 }
 
-pub fn get_next_september_equinox(timestamp: i64) -> i64 {
-    get_next_time_of(Event::SeptemberEquinox, timestamp)
+pub fn next_september_equinox(timestamp: i64) -> i64 {
+    next_time_of(Event::SeptemberEquinox, timestamp)
 }
 
-pub fn get_previous_december_solstice(timestamp: i64) -> i64 {
-    get_previous_time_of(Event::DecemberSolstice, timestamp)
+pub fn previous_december_solstice(timestamp: i64) -> i64 {
+    previous_time_of(Event::DecemberSolstice, timestamp)
 }
 
-pub fn get_next_december_solstice(timestamp: i64) -> i64 {
-    get_next_time_of(Event::DecemberSolstice, timestamp)
+pub fn next_december_solstice(timestamp: i64) -> i64 {
+    next_time_of(Event::DecemberSolstice, timestamp)
 }
 
 #[cfg(test)]
@@ -145,40 +145,40 @@ mod tests {
     use utils::*;
 
     #[test]
-    fn get_next_june_solstice_test() {
+    fn next_june_solstice_test() {
         // Example 27.a from "Astronomical Algoritms"
         // June Solstice: 1962-06-21 21:25:08 TD
         let t = terrestrial_to_universal_time(parse_time("1962-06-21T21:25:08+00:00"));
-        assert_eq!(t, get_next_june_solstice(parse_time("1962-06-01T00:00:00+00:00")));
+        assert_eq!(t, next_june_solstice(parse_time("1962-06-01T00:00:00+00:00")));
     }
 
     #[test]
-    fn get_previous_december_solstice_test() {
+    fn previous_december_solstice_test() {
         let accuracy = 20; // TODO: Improve accuracy
         let solstice_december_2012 = parse_time("2012-12-21T11:11:37+0000");
 
         let times = vec![
-            get_previous_december_solstice(parse_time("2014-06-01T00:00:00+0000")),
+            previous_december_solstice(parse_time("2014-06-01T00:00:00+0000")),
             parse_time("2013-06-01T00:00:00+0000"),
         ];
 
         for t in times {
-            assert_approx_eq!(solstice_december_2012, get_previous_december_solstice(t), accuracy);
+            assert_approx_eq!(solstice_december_2012, previous_december_solstice(t), accuracy);
         }
     }
 
     #[test]
-    fn get_next_december_solstice_test() {
+    fn next_december_solstice_test() {
         let accuracy = 20; // TODO: Improve accuracy
         let solstice_december_2013 = parse_time("2013-12-21T17:11:00+0000");
 
         let times = vec![
-            get_next_december_solstice(parse_time("2012-06-01T00:00:00+0000")),
+            next_december_solstice(parse_time("2012-06-01T00:00:00+0000")),
             parse_time("2013-06-01T00:00:00+0000"),
         ];
 
         for t in times {
-            assert_approx_eq!(solstice_december_2013, get_next_december_solstice(t), accuracy);
+            assert_approx_eq!(solstice_december_2013, next_december_solstice(t), accuracy);
         }
     }
 }
diff --git a/src/ephemeris.rs b/src/ephemeris.rs
index 847ea65..4e9fdd4 100644
--- a/src/ephemeris.rs
+++ b/src/ephemeris.rs
@@ -8,19 +8,19 @@ use alloc::string::ToString;
 use alloc::string::String;
 
 /// Get the ephemeris of a geodate
-pub fn get_ephemeris(timestamp: i64, longitude: f64, latitude: f64) -> BTreeMap<i64, String> {
+pub fn ephemeris(timestamp: i64, longitude: f64, latitude: f64) -> BTreeMap<i64, String> {
     let mut events = BTreeMap::new();
 
-    let day_begin_at = get_midnight(timestamp, longitude);
-    let day_end_at = get_midnight(day_begin_at + 86400 + 10000, longitude);
+    let day_begin_at = midnight(timestamp, longitude);
+    let day_end_at = midnight(day_begin_at + 86400 + 10000, longitude);
 
     events.insert(timestamp, "Current".to_string());
 
     let es = vec![
-        ("Equinox", get_next_march_equinox(day_begin_at)),
-        ("Equinox", get_next_september_equinox(day_begin_at)),
-        ("Solstice", get_next_december_solstice(day_begin_at)),
-        ("Solstice", get_next_june_solstice(day_begin_at))
+        ("Equinox", next_march_equinox(day_begin_at)),
+        ("Equinox", next_september_equinox(day_begin_at)),
+        ("Solstice", next_december_solstice(day_begin_at)),
+        ("Solstice", next_june_solstice(day_begin_at))
     ];
     for (name, e) in es {
         if e < day_end_at {
@@ -28,12 +28,12 @@ pub fn get_ephemeris(timestamp: i64, longitude: f64, latitude: f64) -> BTreeMap<
         }
     }
 
-    let n = get_lunation_number(day_begin_at); // FIXME: Potential bug here
+    let n = lunation_number(day_begin_at); // FIXME: Potential bug here
     let es = vec![
-        ("New Moon", get_new_moon(n)),
-        ("First Quarter Moon", get_first_quarter_moon(n + 0.25)),
-        ("Full Moon", get_full_moon(n + 0.50)),
-        ("Last Quarter Moon", get_last_quarter_moon(n + 0.75))
+        ("New Moon", new_moon(n)),
+        ("First Quarter Moon", first_quarter_moon(n + 0.25)),
+        ("Full Moon", full_moon(n + 0.50)),
+        ("Last Quarter Moon", last_quarter_moon(n + 0.75))
     ];
     for (name, e) in es {
         if day_begin_at < e && e < day_end_at {
@@ -41,52 +41,52 @@ pub fn get_ephemeris(timestamp: i64, longitude: f64, latitude: f64) -> BTreeMap<
         }
     }
 
-    if let Some(moonrise) = get_moonrise(timestamp, longitude, latitude) {
-        if moonrise < day_begin_at {
-            if let Some(moonrise) = get_moonrise(timestamp + 86400, longitude, latitude) {
-                if day_begin_at <= moonrise && moonrise <= day_end_at {
-                    events.insert(moonrise, "Moonrise+1".to_string());
+    if let Some(event) = moonrise(timestamp, longitude, latitude) {
+        if event < day_begin_at {
+            if let Some(event) = moonrise(timestamp + 86400, longitude, latitude) {
+                if day_begin_at <= event && event <= day_end_at {
+                    events.insert(event, "Moonrise+1".to_string());
                 } else {
-                    //events.insert(moonrise, "Moonrise +1");
+                    //events.insert(event, "Moonrise +1"); // FIXME?
                 }
             }
-        } else if moonrise > day_end_at {
-            if let Some(moonrise) = get_moonrise(timestamp - 86400, longitude, latitude) {
-                if day_begin_at <= moonrise && moonrise <= day_end_at {
-                    events.insert(moonrise, "Moonrise-1".to_string());
+        } else if event > day_end_at {
+            if let Some(event) = moonrise(timestamp - 86400, longitude, latitude) {
+                if day_begin_at <= event && event <= day_end_at {
+                    events.insert(event, "Moonrise-1".to_string());
                 } else {
-                    //events.insert(moonrise, "Moonrise -1");
+                    //events.insert(event, "Moonrise -1"); // FIXME?
                 }
             }
         } else {
-            events.insert(moonrise, "Moonrise".to_string());
+            events.insert(event, "Moonrise".to_string());
         }
     }
 
-    if let Some(moonset) = get_moonset(timestamp, longitude, latitude) {
-        if moonset < day_begin_at {
-            if let Some(moonset) = get_moonset(timestamp + 86400, longitude, latitude) {
-                if day_begin_at <= moonset && moonset <= day_end_at {
-                    events.insert(moonset, "Moonset".to_string());
+    if let Some(event) = moonset(timestamp, longitude, latitude) {
+        if event < day_begin_at {
+            if let Some(event) = moonset(timestamp + 86400, longitude, latitude) {
+                if day_begin_at <= event && event <= day_end_at {
+                    events.insert(event, "Moonset".to_string());
                 }
             }
-        } else if moonset > day_end_at {
-            if let Some(moonset) = get_moonset(timestamp - 86400, longitude, latitude) {
-                if day_begin_at <= moonset && moonset <= day_end_at {
-                    events.insert(moonset, "Moonset".to_string());
+        } else if event > day_end_at {
+            if let Some(event) = moonset(timestamp - 86400, longitude, latitude) {
+                if day_begin_at <= event && event <= day_end_at {
+                    events.insert(event, "Moonset".to_string());
                 }
             }
         } else {
-            events.insert(moonset, "Moonset".to_string());
+            events.insert(event, "Moonset".to_string());
         }
     }
 
-    if let Some(sunrise) = get_sunrise(timestamp, longitude, latitude) {
-        events.insert(sunrise, "Sunrise".to_string());
+    if let Some(event) = sunrise(timestamp, longitude, latitude) {
+        events.insert(event, "Sunrise".to_string());
     }
 
-    if let Some(sunset) = get_sunset(timestamp, longitude, latitude) {
-        events.insert(sunset, "Sunset".to_string());
+    if let Some(event) = sunset(timestamp, longitude, latitude) {
+        events.insert(event, "Sunset".to_string());
     }
 
     events
diff --git a/src/geodate.rs b/src/geodate.rs
index d64be31..acf4d9a 100644
--- a/src/geodate.rs
+++ b/src/geodate.rs
@@ -42,7 +42,7 @@ static ZEROS: [i64; 6] = [
 /// %s Seasonal month (for a solar calendar)
 ///
 /// %x Unix timestamp
-pub fn get_formatted_date(format: &str, timestamp: i64, longitude: f64) -> String {
+pub fn formatted_date(format: &str, timestamp: i64, longitude: f64) -> String {
     let mut res = String::from(format);
     let now = timestamp;
     let lon = longitude;
@@ -71,8 +71,8 @@ pub fn get_formatted_date(format: &str, timestamp: i64, longitude: f64) -> Strin
     let mut zero = 0;
     for &e in &ZEROS {
         // Pick the nearest zero to shorten calculations
-        first_new_moon = get_next_new_moon(e);
-        zero = get_midnight(first_new_moon, lon);
+        first_new_moon = next_new_moon(e);
+        zero = midnight(first_new_moon, lon);
         if zero < now {
             break;
         }
@@ -81,13 +81,13 @@ pub fn get_formatted_date(format: &str, timestamp: i64, longitude: f64) -> Strin
         panic!("too far back in time");
     }
 
-    let mut new_year = get_next_december_solstice(zero);
+    let mut new_year = next_december_solstice(zero);
     let mut new_month = match calendar {
-        Calendar::Solar     => get_next_march_equinox(zero),
-        Calendar::Lunisolar => get_next_new_moon(first_new_moon)
+        Calendar::Solar     => next_march_equinox(zero),
+        Calendar::Lunisolar => next_new_moon(first_new_moon)
     };
 
-    let mut midnight = get_midnight(now, lon);
+    let mut midnight = midnight(now, lon);
     if midnight > now {
         midnight -= 86400;
     } else if midnight <= now - 86400 {
@@ -105,21 +105,21 @@ pub fn get_formatted_date(format: &str, timestamp: i64, longitude: f64) -> Strin
             new_month = match calendar {
                 Calendar::Solar => {
                     match m {
-                        0 => get_next_june_solstice(new_month),
-                        1 => get_next_september_equinox(new_month),
-                        2 => get_next_december_solstice(new_month),
-                        3 => get_next_march_equinox(new_month),
+                        0 => next_june_solstice(new_month),
+                        1 => next_september_equinox(new_month),
+                        2 => next_december_solstice(new_month),
+                        3 => next_march_equinox(new_month),
                         _ => unreachable!()
                     }
                 },
                 Calendar::Lunisolar => {
-                    get_next_new_moon(new_month)
+                    next_new_moon(new_month)
                 }
             };
             d = 0;
             m += 1;
             if new_year < t + 86400 {
-                new_year = get_next_december_solstice(new_year);
+                new_year = next_december_solstice(new_year);
                 m = 0;
                 y += 1;
             }
@@ -160,8 +160,8 @@ pub fn get_formatted_date(format: &str, timestamp: i64, longitude: f64) -> Strin
 }
 
 /// Get date with the default formatting
-pub fn get_date(timestamp: i64, longitude: f64) -> String {
-    get_formatted_date("%h:%y:%m:%d:%c:%b", timestamp, longitude)
+pub fn date(timestamp: i64, longitude: f64) -> String {
+    formatted_date("%h:%y:%m:%d:%c:%b", timestamp, longitude)
 }
 
 #[cfg(test)]
@@ -170,83 +170,83 @@ mod tests {
     use utils::*;
 
     #[test]
-    fn get_date_test() {
-        assert_eq!("01:14:05:24:15:42", get_date(1403322675, -1.826189));
+    fn date_test() {
+        assert_eq!("01:14:05:24:15:42", date(1403322675, -1.826189));
     }
 
     #[test]
-    fn get_solar_date_test() {
+    fn solar_date_test() {
         let format = "%u:%s:%d:%c:%b";
         // Stonehenge coordinates: 51.178844, -1.826189
-        assert_eq!("44:02:00:15:42", get_formatted_date(format, 1403322675, -1.826189));
+        assert_eq!("44:02:00:15:42", formatted_date(format, 1403322675, -1.826189));
     }
 
     #[test]
-    fn get_lunisolar_date_test() {
+    fn lunisolar_date_test() {
         let format = "%u:%m:%d:%c:%b";
-        assert_eq!("00:00:00:00:00", get_formatted_date(format, parse_time("1970-01-07T00:06:15+0000"), 0.0));
-        assert_eq!("00:11:29:99:99", get_formatted_date(format, parse_time("1970-12-28T00:01:20+0000"), 0.0));
-        assert_eq!("01:00:00:00:00", get_formatted_date(format, parse_time("1970-12-28T00:01:30+0000"), 0.0));
-        assert_eq!("06:00:00:00:00", get_formatted_date(format, parse_time("1976-01-01T00:03:20+0000"), 0.0));
-        assert_eq!("14:03:03:71:59", get_formatted_date(format, 449947500, -2.7653));
-        assert_eq!("43:11:28:99:98", get_formatted_date(format, parse_time("2014-01-01T00:03:20+0000"), 0.0));
-        assert_eq!("43:11:28:99:99", get_formatted_date(format, parse_time("2014-01-01T00:03:30+0000"), 0.0));
-        assert_eq!("44:00:00:00:00", get_formatted_date(format, parse_time("2014-01-01T00:03:40+0000"), 0.0));
+        assert_eq!("00:00:00:00:00", formatted_date(format, parse_time("1970-01-07T00:06:15+0000"), 0.0));
+        assert_eq!("00:11:29:99:99", formatted_date(format, parse_time("1970-12-28T00:01:20+0000"), 0.0));
+        assert_eq!("01:00:00:00:00", formatted_date(format, parse_time("1970-12-28T00:01:30+0000"), 0.0));
+        assert_eq!("06:00:00:00:00", formatted_date(format, parse_time("1976-01-01T00:03:20+0000"), 0.0));
+        assert_eq!("14:03:03:71:59", formatted_date(format, 449947500, -2.7653));
+        assert_eq!("43:11:28:99:98", formatted_date(format, parse_time("2014-01-01T00:03:20+0000"), 0.0));
+        assert_eq!("43:11:28:99:99", formatted_date(format, parse_time("2014-01-01T00:03:30+0000"), 0.0));
+        assert_eq!("44:00:00:00:00", formatted_date(format, parse_time("2014-01-01T00:03:40+0000"), 0.0));
 
         let format = "%h:%u:%m:%d:%c:%b";
-        assert_eq!("00:63:00:00:00:00", get_formatted_date(format, parse_time("2033-01-01T00:03:45+0000"), 0.0));
-        assert_eq!("01:01:00:00:00:00", get_formatted_date(format, parse_time("2071-01-01T00:03:30+0000"), 0.0));
-        assert_eq!("01:50:00:00:00:00", get_formatted_date(format, parse_time("2120-01-01T00:03:00+0000"), 0.0));
-        assert_eq!("02:15:00:00:00:00", get_formatted_date(format, parse_time("2185-01-01T00:03:30+0000"), 0.0));
-        assert_eq!("03:40:00:00:00:00", get_formatted_date(format, parse_time("2310-01-01T00:02:30+0000"), 0.0));
-        assert_eq!("05:30:00:00:00:00", get_formatted_date(format, parse_time("2500-01-01T00:02:30+0000"), 0.0));
+        assert_eq!("00:63:00:00:00:00", formatted_date(format, parse_time("2033-01-01T00:03:45+0000"), 0.0));
+        assert_eq!("01:01:00:00:00:00", formatted_date(format, parse_time("2071-01-01T00:03:30+0000"), 0.0));
+        assert_eq!("01:50:00:00:00:00", formatted_date(format, parse_time("2120-01-01T00:03:00+0000"), 0.0));
+        assert_eq!("02:15:00:00:00:00", formatted_date(format, parse_time("2185-01-01T00:03:30+0000"), 0.0));
+        assert_eq!("03:40:00:00:00:00", formatted_date(format, parse_time("2310-01-01T00:02:30+0000"), 0.0));
+        assert_eq!("05:30:00:00:00:00", formatted_date(format, parse_time("2500-01-01T00:02:30+0000"), 0.0));
 
         let format = "%u:%m:%d:%c:%b";
-        assert_eq!("63:00:00:00:00", get_formatted_date(format, parse_time("2033-01-01T00:03:45+0000"), 0.0));
-        assert_eq!("01:00:00:00:00", get_formatted_date(format, parse_time("2071-01-01T00:03:30+0000"), 0.0));
-        assert_eq!("50:00:00:00:00", get_formatted_date(format, parse_time("2120-01-01T00:03:00+0000"), 0.0));
-        assert_eq!("15:00:00:00:00", get_formatted_date(format, parse_time("2185-01-01T00:03:30+0000"), 0.0));
-        assert_eq!("40:00:00:00:00", get_formatted_date(format, parse_time("2310-01-01T00:02:30+0000"), 0.0));
-        assert_eq!("30:00:00:00:00", get_formatted_date(format, parse_time("2500-01-01T00:02:30+0000"), 0.0));
+        assert_eq!("63:00:00:00:00", formatted_date(format, parse_time("2033-01-01T00:03:45+0000"), 0.0));
+        assert_eq!("01:00:00:00:00", formatted_date(format, parse_time("2071-01-01T00:03:30+0000"), 0.0));
+        assert_eq!("50:00:00:00:00", formatted_date(format, parse_time("2120-01-01T00:03:00+0000"), 0.0));
+        assert_eq!("15:00:00:00:00", formatted_date(format, parse_time("2185-01-01T00:03:30+0000"), 0.0));
+        assert_eq!("40:00:00:00:00", formatted_date(format, parse_time("2310-01-01T00:02:30+0000"), 0.0));
+        assert_eq!("30:00:00:00:00", formatted_date(format, parse_time("2500-01-01T00:02:30+0000"), 0.0));
 
         // Check bugs fixed by version 0.2.1
-        assert_eq!("46:02:10:49:46", get_formatted_date(format, parse_time("2016-03-19T12:00:00+0000"), 0.0));
-        assert_eq!("46:02:11:80:04", get_formatted_date(format, parse_time("2016-03-20T08:00:00+0000"), 170.0));
-        assert_eq!("30:04:28:99:99", get_formatted_date(format, parse_time("2000-06-01T17:57:50+0000"), 90.0));
-        assert_eq!("30:05:00:00:00", get_formatted_date(format, parse_time("2000-06-01T17:58:00+0000"), 90.0));
+        assert_eq!("46:02:10:49:46", formatted_date(format, parse_time("2016-03-19T12:00:00+0000"), 0.0));
+        assert_eq!("46:02:11:80:04", formatted_date(format, parse_time("2016-03-20T08:00:00+0000"), 170.0));
+        assert_eq!("30:04:28:99:99", formatted_date(format, parse_time("2000-06-01T17:57:50+0000"), 90.0));
+        assert_eq!("30:05:00:00:00", formatted_date(format, parse_time("2000-06-01T17:58:00+0000"), 90.0));
 
         // Check bugs fixed by version 0.3.0
-        assert_eq!("00:11:29:99:99", get_formatted_date(format, parse_time("1970-12-28T00:08:40+00:00"), -1.8262));
-        assert_eq!("01:00:00:00:00", get_formatted_date(format, parse_time("1970-12-28T00:08:50+00:00"), -1.8262)); // v0.2.1 panics
-        assert_eq!("01:00:01:49:35", get_formatted_date(format, parse_time("1970-12-29T12:00:00+00:00"), -1.8262)); // v0.2.1 panics
-        assert_eq!("01:00:02:49:32", get_formatted_date(format, parse_time("1970-12-30T12:00:00+00:00"), -1.8262)); // v0.2.1 panics
-        assert_eq!("01:00:03:99:28", get_formatted_date(format, parse_time("1970-12-31T23:59:59+00:00"), -1.8262)); // v0.2.1 panics
-        assert_eq!("01:00:03:99:29", get_formatted_date(format, parse_time("1971-01-01T00:00:00+00:00"), -1.8262));
+        assert_eq!("00:11:29:99:99", formatted_date(format, parse_time("1970-12-28T00:08:40+00:00"), -1.8262));
+        assert_eq!("01:00:00:00:00", formatted_date(format, parse_time("1970-12-28T00:08:50+00:00"), -1.8262)); // v0.2.1 panics
+        assert_eq!("01:00:01:49:35", formatted_date(format, parse_time("1970-12-29T12:00:00+00:00"), -1.8262)); // v0.2.1 panics
+        assert_eq!("01:00:02:49:32", formatted_date(format, parse_time("1970-12-30T12:00:00+00:00"), -1.8262)); // v0.2.1 panics
+        assert_eq!("01:00:03:99:28", formatted_date(format, parse_time("1970-12-31T23:59:59+00:00"), -1.8262)); // v0.2.1 panics
+        assert_eq!("01:00:03:99:29", formatted_date(format, parse_time("1971-01-01T00:00:00+00:00"), -1.8262));
 
         // Negative time
         let format = "%h:%u:%m:%d:%c:%b";
-        assert_eq!("-00:01:11:22:99:75", get_formatted_date(format, 0, 0.0)); // Unix Epoch
-        assert_eq!("-00:13:00:00:00:00", get_formatted_date(format, parse_time("1957-01-01T00:03:40+0000"), 0.0));
-        assert_eq!("-00:70:00:00:00:00", get_formatted_date(format, parse_time("1900-01-01T00:03:40+0000"), 0.0));
-        assert_eq!("-02:71:00:00:00:00", get_formatted_date(format, parse_time("1699-01-01T00:04:35+0000"), 0.0));
-        assert_eq!("-03:28:00:00:00:00", get_formatted_date(format, parse_time("1642-01-01T00:04:40+0000"), 0.0));
-        assert_eq!("-03:47:00:00:00:00", get_formatted_date(format, parse_time("1623-01-01T00:04:30+0000"), 0.0));
+        assert_eq!("-00:01:11:22:99:75", formatted_date(format, 0, 0.0)); // Unix Epoch
+        assert_eq!("-00:13:00:00:00:00", formatted_date(format, parse_time("1957-01-01T00:03:40+0000"), 0.0));
+        assert_eq!("-00:70:00:00:00:00", formatted_date(format, parse_time("1900-01-01T00:03:40+0000"), 0.0));
+        assert_eq!("-02:71:00:00:00:00", formatted_date(format, parse_time("1699-01-01T00:04:35+0000"), 0.0));
+        assert_eq!("-03:28:00:00:00:00", formatted_date(format, parse_time("1642-01-01T00:04:40+0000"), 0.0));
+        assert_eq!("-03:47:00:00:00:00", formatted_date(format, parse_time("1623-01-01T00:04:30+0000"), 0.0));
 
         let format = "%u:%m:%d:%c:%b";
-        assert_eq!("-01:11:22:99:75", get_formatted_date(format, 0, 0.0)); // Unix Epoch
-        assert_eq!("-13:00:00:00:00", get_formatted_date(format, parse_time("1957-01-01T00:03:40+0000"), 0.0));
-        assert_eq!("-70:00:00:00:00", get_formatted_date(format, parse_time("1900-01-01T00:03:40+0000"), 0.0));
-        assert_eq!("-71:00:00:00:00", get_formatted_date(format, parse_time("1699-01-01T00:04:35+0000"), 0.0));
-        assert_eq!("-28:00:00:00:00", get_formatted_date(format, parse_time("1642-01-01T00:04:40+0000"), 0.0));
-        assert_eq!("-47:00:00:00:00", get_formatted_date(format, parse_time("1623-01-01T00:04:30+0000"), 0.0));
+        assert_eq!("-01:11:22:99:75", formatted_date(format, 0, 0.0)); // Unix Epoch
+        assert_eq!("-13:00:00:00:00", formatted_date(format, parse_time("1957-01-01T00:03:40+0000"), 0.0));
+        assert_eq!("-70:00:00:00:00", formatted_date(format, parse_time("1900-01-01T00:03:40+0000"), 0.0));
+        assert_eq!("-71:00:00:00:00", formatted_date(format, parse_time("1699-01-01T00:04:35+0000"), 0.0));
+        assert_eq!("-28:00:00:00:00", formatted_date(format, parse_time("1642-01-01T00:04:40+0000"), 0.0));
+        assert_eq!("-47:00:00:00:00", formatted_date(format, parse_time("1623-01-01T00:04:30+0000"), 0.0));
 
         // Bug
-        assert_eq!("-30:11:28:99:99", get_formatted_date(format, parse_time("1940-12-28T00:01:39+00:00"), 0.0)); // Unix Epoch
-        assert_eq!("-29:00:00:00:00", get_formatted_date(format, parse_time("1940-12-28T00:01:40+00:00"), 0.0)); // Unix Epoch
+        assert_eq!("-30:11:28:99:99", formatted_date(format, parse_time("1940-12-28T00:01:39+00:00"), 0.0)); // Unix Epoch
+        assert_eq!("-29:00:00:00:00", formatted_date(format, parse_time("1940-12-28T00:01:40+00:00"), 0.0)); // Unix Epoch
 
         // Bug with "50:08:28:100:00" at solar midnight
-        assert_eq!("50:08:27:99:99", get_formatted_date(format, parse_time("2020-09-15T23:55:01+0000"), 0.0));
-        assert_eq!("50:08:28:00:00", get_formatted_date(format, parse_time("2020-09-15T23:55:02+0000"), 0.0));
-        assert_eq!("50:08:28:00:00", get_formatted_date(format, parse_time("2020-09-15T23:55:03+0000"), 0.0));
+        assert_eq!("50:08:27:99:99", formatted_date(format, parse_time("2020-09-15T23:55:01+0000"), 0.0));
+        assert_eq!("50:08:28:00:00", formatted_date(format, parse_time("2020-09-15T23:55:02+0000"), 0.0));
+        assert_eq!("50:08:28:00:00", formatted_date(format, parse_time("2020-09-15T23:55:03+0000"), 0.0));
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 4a71473..19cfab6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,12 +7,10 @@
 //! # Examples
 //!
 //! ```rust
-//! use geodate::geodate;
-//!
 //! let timestamp = 1403322675;
 //! let longitude = -1.826189;
 //!
-//! assert_eq!("01:14:05:24:15:42", geodate::get_date(timestamp, longitude));
+//! assert_eq!("01:14:05:24:15:42", geodate::date(timestamp, longitude));
 //! ```
 //!
 //! This library also exposes some useful functions implementing algorithms
@@ -28,17 +26,17 @@
 //! let longitude = -1.826189;
 //! let latitude  = 51.178844;
 //!
-//! let solstice = earth_orbit::get_previous_december_solstice(timestamp);
+//! let solstice = earth_orbit::previous_december_solstice(timestamp);
 //! assert_eq!(1387645873, solstice);
 //!
-//! if let Some(sunrise) = sun_transit::get_sunrise(timestamp, longitude, latitude) {
+//! if let Some(sunrise) = sun_transit::sunrise(timestamp, longitude, latitude) {
 //!     assert_eq!(1403322705, sunrise);
 //! }
 //! ```
 //!
-//! Note: some functions available in pair, for example `get_*_december_solstice()`
+//! Note: some functions available in pair, for example `*_december_solstice()`
 //! return the `previous` and `next` events for the given time, while others,
-//! like `get_sunrise()`, give the event associated with the current implicit
+//! like `sunrise()`, give the event associated with the current implicit
 //! time period (day, month).
 
 #![no_std]
@@ -77,3 +75,6 @@ pub mod ephemeris;
 
 /// Reverse a geodate into a timestamp
 pub mod reverse;
+
+pub use geodate::date;
+pub use geodate::formatted_date;
diff --git a/src/main.rs b/src/main.rs
index 4750fcc..135376c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,10 +3,6 @@ extern crate geodate;
 
 use getopts::Options;
 
-use geodate::geodate::*;
-use geodate::ephemeris::*;
-use geodate::reverse::*;
-
 use std::env;
 use std::time::SystemTime;
 
@@ -77,7 +73,8 @@ fn main() {
 
     // Convert geodate string back into unix timestamp
     if matches.free.len() == 4 && matches.free[3].contains(":") {
-        println!("{}", get_timestamp(format, matches.free[3].clone(), lon));
+        let date = &matches.free[3];
+        println!("{}", geodate::reverse::timestamp(&format, date, lon));
         return;
     }
 
@@ -91,14 +88,14 @@ fn main() {
     };
 
     if matches.opt_present("e") {
-        let events = get_ephemeris(now, lon, lat);
+        let events = geodate::ephemeris::ephemeris(now, lon, lat);
 
         for (&time, name) in &events {
-            let date = get_formatted_date(&format, time, lon);
+            let date = geodate::formatted_date(&format, time, lon);
             println!("{:20} {}", format!("{}:", name), date);
         }
     } else {
-        let date = get_formatted_date(&format, now, lon);
+        let date = geodate::formatted_date(&format, now, lon);
         println!("{}", date);
     }
 }
diff --git a/src/moon_phase.rs b/src/moon_phase.rs
index 3ccb06c..0e05013 100644
--- a/src/moon_phase.rs
+++ b/src/moon_phase.rs
@@ -17,7 +17,7 @@ enum MoonPhase {
 
 // From "Astronomical Algorithms"
 // By Jean Meeus
-fn get_time_of(phase: MoonPhase, lunation_number: f64) -> i64 {
+fn time_of(phase: MoonPhase, lunation_number: f64) -> i64 {
     /*
     // TODO: use `lunation_number: i64`
     let k = match phase {
@@ -211,25 +211,25 @@ fn get_time_of(phase: MoonPhase, lunation_number: f64) -> i64 {
     terrestrial_to_universal_time(julian_to_unix(jde))
 }
 
-pub fn get_new_moon(lunation_number: f64) -> i64 {
-    get_time_of(MoonPhase::NewMoon, lunation_number)
+pub fn new_moon(lunation_number: f64) -> i64 {
+    time_of(MoonPhase::NewMoon, lunation_number)
 }
 
-pub fn get_first_quarter_moon(lunation_number: f64) -> i64 {
-    get_time_of(MoonPhase::FirstQuarterMoon, lunation_number)
+pub fn first_quarter_moon(lunation_number: f64) -> i64 {
+    time_of(MoonPhase::FirstQuarterMoon, lunation_number)
 }
 
-pub fn get_full_moon(lunation_number: f64) -> i64 {
-    get_time_of(MoonPhase::FullMoon, lunation_number)
+pub fn full_moon(lunation_number: f64) -> i64 {
+    time_of(MoonPhase::FullMoon, lunation_number)
 }
 
-pub fn get_last_quarter_moon(lunation_number: f64) -> i64 {
-    get_time_of(MoonPhase::LastQuarterMoon, lunation_number)
+pub fn last_quarter_moon(lunation_number: f64) -> i64 {
+    time_of(MoonPhase::LastQuarterMoon, lunation_number)
 }
 
 /*
-// TODO: get_lunation_number(timestamp: i64, numbering: LunationNumbering)
-// TODO: get_meeus_lunation_number(timestamp: i64)
+// TODO: lunation_number(timestamp: i64, numbering: LunationNumbering)
+// TODO: meeus_lunation_number(timestamp: i64)
 enum LunationNumbering {
     Islamic,
     Thai,
@@ -239,16 +239,16 @@ enum LunationNumbering {
 */
 
 /// Computes the Lunation Number since the first new moon of 2000
-pub fn get_lunation_number(timestamp: i64) -> f64 {
+pub fn lunation_number(timestamp: i64) -> f64 {
     ((unix_to_year(timestamp) - 2000.0) * 12.3685).floor() // TODO: `as i64`
 }
 
-pub fn get_next_new_moon(timestamp: i64) -> i64 {
-    let new_moon = get_new_moon(get_lunation_number(timestamp));
-    if new_moon > timestamp {
-        new_moon
+pub fn next_new_moon(timestamp: i64) -> i64 {
+    let t = new_moon(lunation_number(timestamp));
+    if t > timestamp {
+        t
     } else {
-        get_new_moon(get_lunation_number(timestamp) + 1.0)
+        new_moon(lunation_number(timestamp) + 1.0)
     }
 }
 
@@ -258,68 +258,68 @@ mod tests {
     use utils::*;
 
     #[test]
-    fn get_lunation_number_test() {
+    fn lunation_number_test() {
         // Example 49.a from "Astronomical Algoritms"
         // New Moon: 1977-02-18 03:37:42 TD
         let t = terrestrial_to_universal_time(parse_time("1977-02-18T03:37:42+00:00"));
-        assert_eq!(-283.0, get_lunation_number(t));
+        assert_eq!(-283.0, lunation_number(t));
 
         // Later in the day
         let t = parse_time("1977-02-18T12:00:00+00:00");
-        assert_eq!(-283.0, get_lunation_number(t));
+        assert_eq!(-283.0, lunation_number(t));
 
         // Later in the month
         let t = parse_time("1977-02-30T12:00:00+00:00");
-        assert_eq!(-283.0, get_lunation_number(t));
+        assert_eq!(-283.0, lunation_number(t));
 
         // Earlier in the day
         let t = parse_time("1977-02-18T01:00:00+00:00");
-        assert_eq!(-283.0, get_lunation_number(t));
+        assert_eq!(-283.0, lunation_number(t));
 
         // A few days before
         let t = parse_time("1977-02-14T12:00:00+00:00");
-        assert_eq!(-283.0, get_lunation_number(t)); // FIXME: should be -284
+        assert_eq!(-283.0, lunation_number(t)); // FIXME: should be -284
 
         // A week before
         let t = parse_time("1977-02-11T12:00:00+00:00");
-        assert_eq!(-284.0, get_lunation_number(t));
+        assert_eq!(-284.0, lunation_number(t));
 
         // Meeus Lunation 0
         let t = parse_time("2000-01-06T18:14:00+00:00");
-        assert_eq!(0.0, get_lunation_number(t));
+        assert_eq!(0.0, lunation_number(t));
 
         // Brown Lunation 1
         let t = parse_time("1923-01-17T02:41:00+00:00");
-        assert_eq!(-952.0, get_lunation_number(t));
+        assert_eq!(-952.0, lunation_number(t));
 
         // Islamic Lunation 1
         let t = parse_time("0622-07-16T00:00:00+00:00");
-        assert_eq!(-17037.0, get_lunation_number(t));
+        assert_eq!(-17037.0, lunation_number(t));
 
         // Thai Lunation 0
         let t = parse_time("0638-03-22T00:00:00+00:00");
-        assert_eq!(-16843.0, get_lunation_number(t)); // FIXME: should be -16842
+        assert_eq!(-16843.0, lunation_number(t)); // FIXME: should be -16842
     }
 
     #[test]
-    fn get_new_moon_test() {
+    fn new_moon_test() {
         // Example 49.a from "Astronomical Algoritms"
         // New Moon: 1977-02-18 03:37:42 TD
-        let lunation_number = -283.0;
+        let n = -283.0;
         let t = terrestrial_to_universal_time(parse_time("1977-02-18T03:37:42+00:00"));
-        assert_eq!(t, get_new_moon(lunation_number));
+        assert_eq!(t, new_moon(n));
 
         // First new moon of 1970
         let t = parse_time("1970-01-07T20:35:27+0000");
-        assert_eq!(t, get_new_moon(get_lunation_number(0) + 1.0));
+        assert_eq!(t, new_moon(lunation_number(0) + 1.0));
     }
 
     #[test]
-    fn get_last_quarter_moon_test() {
+    fn last_quarter_moon_test() {
         // Example 49.b from "Astronomical Algoritms"
         // Last Quarter Moon: 2044-01-21 23:48:17 TD
-        let lunation_number = 544.75;
+        let n = 544.75;
         let t = terrestrial_to_universal_time(parse_time("2044-01-21T23:48:17+00:00"));
-        assert_eq!(t, get_last_quarter_moon(lunation_number));
+        assert_eq!(t, last_quarter_moon(n));
     }
 }
diff --git a/src/moon_transit.rs b/src/moon_transit.rs
index ed4233e..128cbcc 100644
--- a/src/moon_transit.rs
+++ b/src/moon_transit.rs
@@ -12,7 +12,7 @@ enum Event {
     Moonset
 }
 
-fn get_moon_position(julian_day: f64) -> (f64, f64, f64) {
+fn moon_position(julian_day: f64) -> (f64, f64, f64) {
     // Julian century
     let t = jde_to_julian_century(julian_day);
 
@@ -267,16 +267,16 @@ fn get_moon_position(julian_day: f64) -> (f64, f64, f64) {
     (a, s, d)
 }
 
-fn get_time_of(event: Event, timestamp: i64, longitude: f64, latitude: f64) -> Option<i64> {
+fn time_of(event: Event, timestamp: i64, longitude: f64, latitude: f64) -> Option<i64> {
     let lon = -longitude; // Longitude of the observer, measured positively west
     let lat = latitude; // Latitude of the observer, measured positively north
 
     // Julian day
     let jd = (unix_to_julian(timestamp) + longitude / 360.0 + 0.5).floor() - 0.5;
 
-    let (mut asc1, dec1,    _) = get_moon_position(jd - 1.0);
-    let (    asc2, dec2, dist) = get_moon_position(jd);
-    let (mut asc3, dec3,    _) = get_moon_position(jd + 1.0);
+    let (mut asc1, dec1,    _) = moon_position(jd - 1.0);
+    let (    asc2, dec2, dist) = moon_position(jd);
+    let (mut asc3, dec3,    _) = moon_position(jd + 1.0);
     while asc2 < asc1 {
         asc1 -= 180.0;
     }
@@ -350,12 +350,12 @@ fn get_time_of(event: Event, timestamp: i64, longitude: f64, latitude: f64) -> O
     Some(julian_to_unix(jd + m + dm))
 }
 
-pub fn get_moonrise(timestamp: i64, longitude: f64, latitude: f64) -> Option<i64> {
-    get_time_of(Event::Moonrise, timestamp, longitude, latitude)
+pub fn moonrise(timestamp: i64, longitude: f64, latitude: f64) -> Option<i64> {
+    time_of(Event::Moonrise, timestamp, longitude, latitude)
 }
 
-pub fn get_moonset(timestamp: i64, longitude: f64, latitude: f64) -> Option<i64> {
-    get_time_of(Event::Moonset, timestamp, longitude, latitude)
+pub fn moonset(timestamp: i64, longitude: f64, latitude: f64) -> Option<i64> {
+    time_of(Event::Moonset, timestamp, longitude, latitude)
 }
 
 #[cfg(test)]
@@ -365,16 +365,16 @@ mod tests {
     use utils::*;
 
     #[test]
-    fn get_moon_position_test() {
+    fn moon_position_test() {
         let jd = unix_to_julian(parse_time("1992-04-12T00:00:00+00:00"));
-        let (asc, dec, dist) = get_moon_position(jd);
+        let (asc, dec, dist) = moon_position(jd);
         assert_approx_eq!(asc, 134.688_470, 0.000_01);
         assert_approx_eq!(dec, 13.768_368, 0.000_01);
         assert_approx_eq!(dist, 368_409.7, 0.1);
     }
 
     #[test]
-    fn get_moonrise_test() {
+    fn moonrise_test() {
         let accuracy = 90;
         let times = vec![
             ("2000-01-01T01:50:14+00:00", "2000-01-01T12:00:00+00:00", 0.0, 0.0),
@@ -393,7 +393,7 @@ mod tests {
             ("2025-10-21T05:24:26+00:00", "2025-10-21T12:00:00+00:00", -4.0, 0.0),
         ];
         for (t0, t1, lat, lon) in times {
-            assert_approx_eq!(get_moonrise(parse_time(t1), lon, lat).unwrap(), parse_time(t0), accuracy);
+            assert_approx_eq!(moonrise(parse_time(t1), lon, lat).unwrap(), parse_time(t0), accuracy);
         }
     }
 }
diff --git a/src/reverse.rs b/src/reverse.rs
index f9c2f89..3a4ce4a 100644
--- a/src/reverse.rs
+++ b/src/reverse.rs
@@ -1,12 +1,11 @@
 use geodate::*;
 
-use alloc::string::String;
 use alloc::vec::Vec;
 
 /// Reverse a geodate into a timestamp
-pub fn get_timestamp(format: String, date: String, longitude: f64) -> i64 {
-    let y = date_year(date.clone());
-    let n = date_index(date.clone());
+pub fn timestamp(format: &str, date: &str, longitude: f64) -> i64 {
+    let y = date_year(date);
+    let n = date_index(date);
 
     // Approximate timestamps of bounds
     let mut min = (y - 2) * 365 * 86400;
@@ -30,7 +29,7 @@ pub fn get_timestamp(format: String, date: String, longitude: f64) -> i64 {
 
     loop {
         let mid = (min + max) / 2;
-        let i = date_index(get_formatted_date(&format, mid, longitude));
+        let i = date_index(&formatted_date(&format, mid, longitude));
         if i == n || mid == min || mid == max {
             return mid;
         }
@@ -43,7 +42,7 @@ pub fn get_timestamp(format: String, date: String, longitude: f64) -> i64 {
 }
 
 // Extract year from a geodate string
-fn date_year(date: String) -> i64 {
+fn date_year(date: &str) -> i64 {
     let parts: Vec<_> = date.split(":").collect();
 
     let y = match parts.len() {
@@ -56,7 +55,7 @@ fn date_year(date: String) -> i64 {
 }
 
 // Transform a geodate string into an integer for comparison
-fn date_index(date: String) -> i64 {
+fn date_index(date: &str) -> i64 {
     let year = date_year(date.clone());
     let mut index = date.replace(":", "").parse::<i64>().unwrap();
     if index < 0 { // Special case for negative years
@@ -71,36 +70,36 @@ mod tests {
 
     #[test]
     fn date_year_test() {
-        assert_eq!(date_year(    "00:00:00:00:00".into()),     0);
-        assert_eq!(date_year(    "02:00:00:00:00".into()),     2);
-        assert_eq!(date_year(    "42:00:00:00:00".into()),    42);
+        assert_eq!(date_year(    "00:00:00:00:00"),     0);
+        assert_eq!(date_year(    "02:00:00:00:00"),     2);
+        assert_eq!(date_year(    "42:00:00:00:00"),    42);
 
-        assert_eq!(date_year(   "-00:00:00:00:00".into()),     0);
-        assert_eq!(date_year(   "-02:00:00:00:00".into()),    -2);
-        assert_eq!(date_year(   "-42:00:00:00:00".into()),   -42);
+        assert_eq!(date_year(   "-00:00:00:00:00"),     0);
+        assert_eq!(date_year(   "-02:00:00:00:00"),    -2);
+        assert_eq!(date_year(   "-42:00:00:00:00"),   -42);
 
-        assert_eq!(date_year( "00:00:00:00:00:00".into()),     0);
-        assert_eq!(date_year( "00:02:00:00:00:00".into()),     2);
-        assert_eq!(date_year( "00:42:00:00:00:00".into()),    42);
-        assert_eq!(date_year( "03:37:00:00:00:00".into()),   337);
-        assert_eq!(date_year( "13:37:00:00:00:00".into()),  1337);
+        assert_eq!(date_year( "00:00:00:00:00:00"),     0);
+        assert_eq!(date_year( "00:02:00:00:00:00"),     2);
+        assert_eq!(date_year( "00:42:00:00:00:00"),    42);
+        assert_eq!(date_year( "03:37:00:00:00:00"),   337);
+        assert_eq!(date_year( "13:37:00:00:00:00"),  1337);
 
-        assert_eq!(date_year("-00:00:00:00:00:00".into()),     0);
-        assert_eq!(date_year("-00:02:00:00:00:00".into()),    -2);
-        assert_eq!(date_year("-00:42:00:00:00:00".into()),   -42);
-        assert_eq!(date_year("-03:37:00:00:00:00".into()),  -337);
-        assert_eq!(date_year("-13:37:00:00:00:00".into()), -1337);
+        assert_eq!(date_year("-00:00:00:00:00:00"),     0);
+        assert_eq!(date_year("-00:02:00:00:00:00"),    -2);
+        assert_eq!(date_year("-00:42:00:00:00:00"),   -42);
+        assert_eq!(date_year("-03:37:00:00:00:00"),  -337);
+        assert_eq!(date_year("-13:37:00:00:00:00"), -1337);
     }
 
     #[test]
     fn date_index_test() {
-        assert_eq!(date_index( "00:00:00:00:00:00".into()),             0);
-        assert_eq!(date_index( "00:02:00:00:00:00".into()),     200000000);
-        assert_eq!(date_index("-00:02:00:00:00:00".into()),    -200000000);
-        assert_eq!(date_index("-00:02:05:00:00:00".into()),    -195000000);
-        assert_eq!(date_index("-00:02:10:00:00:00".into()),    -190000000);
-        assert_eq!(date_index("-00:01:00:00:00:00".into()),    -100000000);
-        assert_eq!(date_index("-00:01:10:00:00:00".into()),     -90000000);
-        assert_eq!(date_index("-00:01:11:28:99:99".into()),     -88710001);
+        assert_eq!(date_index( "00:00:00:00:00:00"),             0);
+        assert_eq!(date_index( "00:02:00:00:00:00"),     200000000);
+        assert_eq!(date_index("-00:02:00:00:00:00"),    -200000000);
+        assert_eq!(date_index("-00:02:05:00:00:00"),    -195000000);
+        assert_eq!(date_index("-00:02:10:00:00:00"),    -190000000);
+        assert_eq!(date_index("-00:01:00:00:00:00"),    -100000000);
+        assert_eq!(date_index("-00:01:10:00:00:00"),     -90000000);
+        assert_eq!(date_index("-00:01:11:28:99:99"),     -88710001);
     }
 }
diff --git a/src/sun_transit.rs b/src/sun_transit.rs
index c1674bf..d1ecb81 100644
--- a/src/sun_transit.rs
+++ b/src/sun_transit.rs
@@ -12,7 +12,7 @@ enum Event {
     Sunset
 }
 
-fn get_time_of(event: Event, timestamp: i64, longitude: f64, latitude: f64, altitude: f64) -> Option<i64> {
+fn time_of(event: Event, timestamp: i64, longitude: f64, latitude: f64, altitude: f64) -> Option<i64> {
     // Julian day
     let jd = (unix_to_julian(timestamp) + longitude / 360.0 + 0.5).floor();
 
@@ -217,24 +217,24 @@ pub fn mean_obliquity_eliptic(julian_century: f64) -> f64 {
         + dec_deg(0.0, 0.0, 0.001_813) * t.powi(3)
 }
 
-pub fn get_noon(timestamp: i64, longitude: f64) -> i64 {
-    get_midday(timestamp, longitude)
+pub fn noon(timestamp: i64, longitude: f64) -> i64 {
+    midday(timestamp, longitude)
 }
 
-pub fn get_midday(timestamp: i64, longitude: f64) -> i64 {
-    get_time_of(Event::Midday, timestamp, longitude, 0.0, 0.0).unwrap()
+pub fn midday(timestamp: i64, longitude: f64) -> i64 {
+    time_of(Event::Midday, timestamp, longitude, 0.0, 0.0).unwrap()
 }
 
-pub fn get_midnight(timestamp: i64, longitude: f64) -> i64 {
-    get_time_of(Event::Midnight, timestamp, longitude, 0.0, 0.0).unwrap()
+pub fn midnight(timestamp: i64, longitude: f64) -> i64 {
+    time_of(Event::Midnight, timestamp, longitude, 0.0, 0.0).unwrap()
 }
 
-pub fn get_sunrise(timestamp: i64, longitude: f64, latitude: f64) -> Option<i64> {
-    get_time_of(Event::Sunrise, timestamp, longitude, latitude, 0.0)
+pub fn sunrise(timestamp: i64, longitude: f64, latitude: f64) -> Option<i64> {
+    time_of(Event::Sunrise, timestamp, longitude, latitude, 0.0)
 }
 
-pub fn get_sunset(timestamp: i64, longitude: f64, latitude: f64) -> Option<i64> {
-    get_time_of(Event::Sunset, timestamp, longitude, latitude, 0.0)
+pub fn sunset(timestamp: i64, longitude: f64, latitude: f64) -> Option<i64> {
+    time_of(Event::Sunset, timestamp, longitude, latitude, 0.0)
 }
 
 #[cfg(test)]
@@ -291,9 +291,9 @@ mod tests {
     }
 
     #[test]
-    fn get_noon_test() {
-        get_noon(parse_time("1992-10-13T00:00:00+00:00"), 0.0);
-        get_noon(parse_time("1992-10-13T00:00:00+00:00"), 174.0);
+    fn noon_test() {
+        noon(parse_time("1992-10-13T00:00:00+00:00"), 0.0);
+        noon(parse_time("1992-10-13T00:00:00+00:00"), 174.0);
 
         // http://www.esrl.noaa.gov/gmd/grad/solcalc/
         let times = vec![
@@ -303,12 +303,12 @@ mod tests {
         ];
 
         for (t0, t1, _, lon) in times {
-            assert_approx_eq!(parse_time(t0), get_noon(parse_time(t1), lon), 1);
+            assert_approx_eq!(parse_time(t0), noon(parse_time(t1), lon), 1);
         }
     }
 
     #[test]
-    fn get_midnight_test() {
+    fn midnight_test() {
         // http://www.esrl.noaa.gov/gmd/grad/solcalc/
         let times = vec![
             ("2000-01-01T00:03:18+00:00", "2000-01-01T12:00:00+00:00", 45.0, 0.0),
@@ -317,13 +317,13 @@ mod tests {
         ];
 
         for (t0, t1, _, lon) in times {
-            assert_approx_eq!(parse_time(t0), get_midnight(parse_time(t1), lon), 1);
+            assert_approx_eq!(parse_time(t0), midnight(parse_time(t1), lon), 1);
         }
     }
 
     #[test]
-    fn get_sunrise_test() {
-        assert_eq!(None, get_sunrise(parse_time("2010-12-21T12:00:00+00:00"), 0.0, 70.0));
+    fn sunrise_test() {
+        assert_eq!(None, sunrise(parse_time("2010-12-21T12:00:00+00:00"), 0.0, 70.0));
 
         // TODO: Test at latitudes > 70
         // http://www.esrl.noaa.gov/gmd/grad/solcalc/
@@ -340,13 +340,13 @@ mod tests {
             // TODO: Improve accuracy
             let accuracy = if lat > 60.0 { 100 } else { 20 };
 
-            assert_approx_eq!(parse_time(t0), get_sunrise(parse_time(t1), lon, lat).unwrap(), accuracy);
+            assert_approx_eq!(parse_time(t0), sunrise(parse_time(t1), lon, lat).unwrap(), accuracy);
         }
     }
 
     #[test]
-    fn get_sunset_test() {
-        assert_eq!(None, get_sunrise(parse_time("2010-12-21T12:00:00+00:00"), 0.0, 70.0));
+    fn sunset_test() {
+        assert_eq!(None, sunrise(parse_time("2010-12-21T12:00:00+00:00"), 0.0, 70.0));
 
         // TODO: Test at latitudes > 70
         // http://www.esrl.noaa.gov/gmd/grad/solcalc/
@@ -362,7 +362,7 @@ mod tests {
             // TODO: Improve accuracy
             let accuracy = if lat > 60.0 { 100 } else { 20 };
 
-            assert_approx_eq!(parse_time(t0), get_sunset(parse_time(t1), lon, lat).unwrap(), accuracy);
+            assert_approx_eq!(parse_time(t0), sunset(parse_time(t1), lon, lat).unwrap(), accuracy);
         }
     }
 }