roche 0.2.3__tar.gz → 0.2.8__tar.gz

{roche-0.2.3 → roche-0.2.8}/.github/workflows/python-publish.yml

@@ -80,3 +80,28 @@ jobs:
         with:
           command: upload
           args: --non-interactive final_dist/*
+
+  
+  build_rust:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v1
+
+    - name: Set up Rust
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        override: true
+
+    - name: Build
+      run: cargo build --release
+
+    - name: Run Tests
+      run: cargo test --release
+
+    - name: Publish
+      run: cargo publish --token ${{ secrets.CRATES_TOKEN }}
+      env:
+        CARGO_REGISTRY_TOKEN: ${{ secrets.CRATES_TOKEN }}

{roche-0.2.3 → roche-0.2.8}/Cargo.lock

@@ -187,7 +187,7 @@ checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
 
 [[package]]
 name = "rust-roche"
-version = "0.2.3"
+version = "0.2.8"
 dependencies = [
  "bulirsch",
  "ndarray",

{roche-0.2.3 → roche-0.2.8}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rust-roche"
-version = "0.2.3"
+version = "0.2.8"
 edition = "2024"
 description = "Rust translation of Tom Marsh's cpp-roche package for modelling Roche distorted stars/binary systems."
 license = "MIT"

roche-0.2.8/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: roche
+Version: 0.2.8
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+[![PyPi version](https://badgen.net/pypi/v/roche/)](https://pypi.org/project/roche)
+[![crates.io](https://badgen.net/crates/v/rust-roche)](https://crates.io/crates/rust-roche)
+
+rust-roche is a translation of Tom Marsh's C++ [cpp-roche](https://github.com/trmrsh/cpp-roche) package for modelling Roche-distorted binary systems. It also has a few useful functions and types from [cpp-subs](https://github.com/trmrsh/cpp-subs) such as Vec3 and Point.
+
+
+### Rust
+The latest version of rust-roche can be viewed at [rust-roche](https://crates.io/crates/rust-roche) and can be added to a rust project with
+
+```
+cargo add rust-roche
+```
+
+Some functions from cpp-roche have not been translated yet so this is still a work-in-progress. Please add an issue on the Github repo if there's a specific function from cpp-roche that you'd like adding.
+
+### Python
+This package has also been wrapped for python to replicate [trm-roche](https://github.com/trmrsh/trm-roche/tree/master) and can be installed with pip from PyPI
+
+```
+pip install roche
+```
+
+This is very much a first go at it. Most functions have been tested against their trm.roche counterparts however not all functions have been tested as of yet and some bugs may remain. Please add an issue on the Github repo if you find any.

{roche-0.2.3 → roche-0.2.8}/README.md

@@ -1,7 +1,19 @@
+[![PyPi version](https://badgen.net/pypi/v/roche/)](https://pypi.org/project/roche)
+[![crates.io](https://badgen.net/crates/v/rust-roche)](https://crates.io/crates/rust-roche)
+
 rust-roche is a translation of Tom Marsh's C++ [cpp-roche](https://github.com/trmrsh/cpp-roche) package for modelling Roche-distorted binary systems. It also has a few useful functions and types from [cpp-subs](https://github.com/trmrsh/cpp-subs) such as Vec3 and Point.
 
-Some functions from cpp-roche have not been translated yet so this is still a work-in-progress. Please add an issue on the Github repo if there's a specific function from cpp-roche that you'd like adding. 
 
+### Rust
+The latest version of rust-roche can be viewed at [rust-roche](https://crates.io/crates/rust-roche) and can be added to a rust project with
+
+```
+cargo add rust-roche
+```
+
+Some functions from cpp-roche have not been translated yet so this is still a work-in-progress. Please add an issue on the Github repo if there's a specific function from cpp-roche that you'd like adding.
+
+### Python
 This package has also been wrapped for python to replicate [trm-roche](https://github.com/trmrsh/trm-roche/tree/master) and can be installed with pip from PyPI
 
 ```

{roche-0.2.3 → roche-0.2.8}/pyproject.toml

@@ -4,8 +4,9 @@ build-backend = "maturin"
 
 [project]
 name = "roche"
-version = "0.2.3"
+version = "0.2.8"
 requires-python = ">=3.8"
+readme = "README.md"
 
 [tool.maturin]
 features = ["pyo3/extension-module", "pyo3/abi3-py38"]

{roche-0.2.3 → roche-0.2.8}/src/blink.rs

@@ -4,8 +4,8 @@ use crate::x_l1;
 
 ///
 /// blink tests for the occultation of a point in a semi-detached
-/// binary. blink = true when point is eclipsed, otherwise = false. It works 
-/// by first trying to eliminate as many paths that go nowhere near the 
+/// binary. blink = true when point is eclipsed, otherwise = false. It works
+/// by first trying to eliminate as many paths that go nowhere near the
 /// Roche lobe before getting down to the hard work of stepping
 /// along the path.
 ///
@@ -13,31 +13,25 @@ use crate::x_l1;
 /// NOT the inner lagrangian point distance.
 ///
 /// Arguments:
-/// 
+///
 /// * `q`: the mass ratio = M2/M1.
 /// * `r`: the position vector (in units of binary separation)
 /// * `e`: unit vector pointing towards Earth. Standardly this is (sini(i)*cos(phi),-sin(i)*sin(phi),cos(i))
-/// * `acc`: step size parameter. acc specifies the size of steps taken when trying to see if the 
-/// photon path goes inside the Roche lobe. The step size is roughly acc times the radius of the lobe filling star. 
-/// This means that the photon path could mistakenly not be occulted if it passed less than about (acc**2)/8 of 
-/// the radius below the surface of the Roche lobe. acc of order 0.1 should therefore do the job.
-/// Returns:
+/// * `acc`: step size parameter. acc specifies the size of steps taken when trying to see if the
+///   photon path goes inside the Roche lobe. The step size is roughly acc times the radius of the lobe filling star.
+///   This means that the photon path could mistakenly not be occulted if it passed less than about (acc**2)/8 of
+///   the radius below the surface of the Roche lobe. acc of order 0.1 should therefore do the job.
 /// 
+/// Returns:
+///
 /// * false = not eclipsed; true = eclipsed.
 ///
 pub fn blink(q: f64, r: &Vec3, e: &Vec3, acc: f64) -> Result<bool, RocheError> {
-
     let mut x_cofm: f64;
-    let c1: f64;
-    let c2: f64;
-    let step: f64;
-    let pp: f64;
-    let crit: f64;
     let mut p: f64;
     let p1: f64;
     let p2: f64;
 
-
     let mut r1: f64;
     let mut r2: f64;
     // Compute q dependent quantities
@@ -50,11 +44,11 @@ pub fn blink(q: f64, r: &Vec3, e: &Vec3, acc: f64) -> Result<bool, RocheError> {
         let message = format!("Invalid accuracy parameter. {} <= 0.0.", acc);
         return Err(RocheError::ParameterError(message));
     }
- 
+
     x_cofm = 1.0 / (1.0 + q);
-    c1 = 2.0 * x_cofm;
+    let c1: f64 = 2.0 * x_cofm;
     x_cofm *= q;
-    c2 = 2.0 * x_cofm;
+    let c2: f64 = 2.0 * x_cofm;
 
     // Locate the inner Lagrangian point (L1)
     let rl1: f64 = x_l1(q)?;
@@ -63,30 +57,30 @@ pub fn blink(q: f64, r: &Vec3, e: &Vec3, acc: f64) -> Result<bool, RocheError> {
     r1 = rl1;
     r2 = 1.0 - rl1;
     let xc: f64 = rl1 - x_cofm;
-    crit = c1/r1 + c2/r2 + xc*xc;
+    let crit: f64 = c1 / r1 + c2 / r2 + xc * xc;
 
     // The red star lies entirely within the sphere centred on its
     // centre of mass and reaching the inner Lagrangian point.
 
     let rsphere: f64 = 1.0 - rl1;
-    pp = rsphere*rsphere;
-    step = rsphere*acc;
+    let pp: f64 = rsphere * rsphere;
+    let step: f64 = rsphere * acc;
 
     // From now on computations are done every call. Main point is
-    // to try to bail out as soon as possible to save time 
+    // to try to bail out as soon as possible to save time
 
     // evaluate closest approach distance to sphere.
 
     let xt: f64 = r.x - 1.0;
-    let mut b: f64 = e.x*xt + e.y*r.y + e.z*r.z;
-    let mut c: f64 = xt*xt + r.y*r.y + r.z*r.z - pp;
+    let mut b: f64 = e.x * xt + e.y * r.y + e.z * r.z;
+    let mut c: f64 = xt * xt + r.y * r.y + r.z * r.z - pp;
 
     // Photon path crosses sphere at two points given by quadratic
     // equation l*l + 2*b*l + c = 0. First check that this has
     // real roots. If not, there is no eclipse. This test should
     // eliminate most cases.
 
-    let mut fac: f64 = b*b - c;
+    let mut fac: f64 = b * b - c;
 
     if fac <= 0.0 {
         return Ok(false);
@@ -96,7 +90,6 @@ pub fn blink(q: f64, r: &Vec3, e: &Vec3, acc: f64) -> Result<bool, RocheError> {
 
     // If the larger root is negative, the photon starts after the sphere.
     // This should get rid of another whole stack
-    
 
     let par2: f64 = -b + fac;
 
@@ -105,37 +98,29 @@ pub fn blink(q: f64, r: &Vec3, e: &Vec3, acc: f64) -> Result<bool, RocheError> {
     }
 
     //  Now for the hard work. The photon's path does go
-    //  inside the sphere ... groan. First evaluate smaller root 
+    //  inside the sphere ... groan. First evaluate smaller root
     //  but limit to >= 0 to ensure that only photon path
     //  and not its extrapolation backwards in included.
 
     let mut par1: f64 = -b - fac;
-    par1 = if par1 > 0.0 {
-        par1
-    } else {
-        0.0
-    };
+    par1 = if par1 > 0.0 { par1 } else { 0.0 };
 
-    // Now follow the photon's path in finite steps to see if 
+    // Now follow the photon's path in finite steps to see if
     // it intercepts the red star. We start off at closest
-    // approach point to increase chance of only needing one 
+    // approach point to increase chance of only needing one
     // computation of the roche potential
 
-    let par: f64 =  if b < 0.0 {
-        -b
-    } else {
-        0.0
-    };
+    let par: f64 = if b < 0.0 { -b } else { 0.0 };
 
-    let mut x1: f64 = r.x + par*e.x;
-    let mut x2: f64 = r.y + par*e.y;
-    let mut x3: f64 = r.z + par*e.z;
+    let mut x1: f64 = r.x + par * e.x;
+    let mut x2: f64 = r.y + par * e.y;
+    let mut x3: f64 = r.z + par * e.z;
 
     // Test roche potential for an occultation
     let mut xm: f64 = x1 - 1.0;
-    let mut yy: f64 = x2*x2;
-    let mut rr: f64 = yy + x3*x3;
-    let rs2: f64 = xm*xm + rr;
+    let mut yy: f64 = x2 * x2;
+    let mut rr: f64 = yy + x3 * x3;
+    let rs2: f64 = xm * xm + rr;
 
     // Point at c of m of red star. Definitely eclipsed, avoids
     // division by 0 later
@@ -144,26 +129,26 @@ pub fn blink(q: f64, r: &Vec3, e: &Vec3, acc: f64) -> Result<bool, RocheError> {
         return Ok(true);
     }
 
-    let rs1: f64 = x1*x1 + rr;
+    let rs1: f64 = x1 * x1 + rr;
     r1 = rs1.sqrt();
     r2 = rs2.sqrt();
 
     // Deeper in well than inner Lagrangian, therefore eclipsed.
 
     let mut xc: f64 = x1 - x_cofm;
-    c = c1/r1 + c2/r2 + xc*xc + yy;
+    c = c1 / r1 + c2 / r2 + xc * xc + yy;
 
     if c > crit {
         return Ok(true);
     }
 
-    // Now we need to step. Determine step direction by 
+    // Now we need to step. Determine step direction by
     // evaluating the first derivative
 
-    let a: f64 = x1*e.x + x2*e.y;
-    b = a + x3*e.z;
+    let a: f64 = x1 * e.x + x2 * e.y;
+    b = a + x3 * e.z;
 
-    if -c1*b/(rs1*r1) - c2*(b - e.x)/(rs2*r2) + 2.0*(a - x_cofm*e.x) > 0.0 {
+    if -c1 * b / (rs1 * r1) - c2 * (b - e.x) / (rs2 * r2) + 2.0 * (a - x_cofm * e.x) > 0.0 {
         p1 = par;
         p2 = par2;
     } else {
@@ -173,39 +158,38 @@ pub fn blink(q: f64, r: &Vec3, e: &Vec3, acc: f64) -> Result<bool, RocheError> {
 
     // Loop while the Roche potential increases in depth
 
-    let mut nstep: i32 = ((p2-p1).abs() / step + 0.5).floor() as i32;
+    let mut nstep: i32 = ((p2 - p1).abs() / step + 0.5).floor() as i32;
 
     nstep = nstep.max(2);
-    
-    let dp: f64 = (p2-p1)/(nstep as f64);
+
+    let dp: f64 = (p2 - p1) / (nstep as f64);
     let mut cmax: f64 = c - 1.0;
     let mut i: i32 = 0;
     while c > cmax && i < nstep {
         i += 1;
         cmax = c;
-        p = p1 + dp*(i as f64);
-        x1 = r.x + p*e.x;
-        x2 = r.y + p*e.y;
-        x3 = r.z + p*e.z;
+        p = p1 + dp * (i as f64);
+        x1 = r.x + p * e.x;
+        x2 = r.y + p * e.y;
+        x3 = r.z + p * e.z;
 
         // test roche potential for an occultation, again guarding
         // against division by 0
 
         xm = x1 - 1.0;
-        yy = x2*x2;
-        rr = yy + x3*x3;
-        r2 = (xm*xm + rr).sqrt();
+        yy = x2 * x2;
+        rr = yy + x3 * x3;
+        r2 = (xm * xm + rr).sqrt();
         if r2 <= 0.0 {
             return Ok(true);
         }
-        r1 = (x1*x1 + rr).sqrt();
+        r1 = (x1 * x1 + rr).sqrt();
         xc = x1 - x_cofm;
-        c = c1/r1 + c2/r2 + xc*xc + yy;
+        c = c1 / r1 + c2 / r2 + xc * xc + yy;
         if c > crit {
             return Ok(true);
         }
     }
 
-    return Ok(false)
-
-}
+    Ok(false)
+}

{roche-0.2.3 → roche-0.2.8}/src/disc_eclipse.rs

@@ -1,7 +1,6 @@
-use std::f64::consts::TAU;
-use crate::{Etype, Vec3};
 use crate::errors::RocheError;
-
+use crate::{Etype, Vec3};
+use std::f64::consts::TAU;
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 // This enumerates the 5 possible outcomes of the LOSC intersection with a circle.
@@ -19,36 +18,42 @@ pub enum Circle {
 }
 
 ///
-/// disc_eclipse works out phase ranges during which a cylindrically symmetric, flared disc 
-/// running between a pair of radii eclipses a given point. 
+/// disc_eclipse works out phase ranges during which a cylindrically symmetric, flared disc
+/// running between a pair of radii eclipses a given point.
 ///
 /// Arguments:
-/// 
+///
 /// * `iangle`:  the orbital inclination, degrees. 90 = edge on.
 /// * `r`:       the position vector of the point in question (units of binary separation)
 /// * `rdisc1`: inner disc  radius, units of separation
 /// * `rdisc2`: outer disc radius, units of separation
 /// * `beta`: exponent of flaring, so that the height scales as r**beta. beta should be >= 1
 /// * `height disc`: height at unit radius in disc (even if it does not exist)
-/// 
+///
 /// Returns:
-/// 
+///
 /// * a vector of ingress and egress phase pairs during which the point in question is eclipsed.
-/// The ingress phase will always be between 0 and 1 while the egress phase will be larger than this, but
-/// by no more than 1 cycle. If the vector is null, no eclipse takes place.
+///   The ingress phase will always be between 0 and 1 while the egress phase will be larger than this, but
+///   by no more than 1 cycle. If the vector is null, no eclipse takes place.
 ///
-pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f64, r: &Vec3) -> Result<Etype, RocheError> {
-
+pub fn disc_eclipse(
+    iangle: f64,
+    rdisc1: f64,
+    rdisc2: f64,
+    beta: f64,
+    height: f64,
+    r: &Vec3,
+) -> Result<Etype, RocheError> {
     if beta <= 1.0 {
-        return Err(RocheError::ParameterError("beta must be >= 1.0".to_string()));
+        return Err(RocheError::ParameterError(
+            "beta must be >= 1.0".to_string(),
+        ));
     }
 
     // Compute and store cosine and sine of inclination if need be.
     // let mut iangle_old: f64 = -1.0e30;
     let sini: f64;
     let cosi: f64;
-    // if iangle != iangle_old {
-        // iangle_old = iangle;
     (sini, cosi) = iangle.to_radians().sin_cos();
     // }
 
@@ -65,7 +70,7 @@ pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f6
     // Special case of exactly edge-on, only curved outer edge matters.
     if cosi == 0.0 {
         if r.z.abs() < h_out {
-            let rxy: f64 = (r.x*r.x + r.y*r.y).sqrt();
+            let rxy: f64 = (r.x * r.x + r.y * r.y).sqrt();
             if rxy <= rdisc2 {
                 temp.push((0.0, 1.0));
             }
@@ -74,23 +79,22 @@ pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f6
     }
 
     // Work out distance from axis
-    let rxy: f64 = (r.x*r.x + r.y*r.y).sqrt();
+    let rxy: f64 = (r.x * r.x + r.y * r.y).sqrt();
 
-    if rdisc1 < rxy && rxy < rdisc2 && r.z.abs() < height*rxy.powf(beta) {
+    if rdisc1 < rxy && rxy < rdisc2 && r.z.abs() < height * rxy.powf(beta) {
         // Point is inside disc and so is eclipsed
         temp.push((0.0, 1.1));
         return Ok(temp);
     }
 
-    let tani: f64 = sini/cosi;
+    let tani: f64 = sini / cosi;
     let mut result: Circle;
 
     let mut phase: f64 = 0.0;
     let mut ingress: f64;
     let mut egress: f64;
 
-    if rxy < rdisc2 && r.z >= height*rdisc1.max(rxy).powf(beta) {
-
+    if rxy < rdisc2 && r.z >= height * rdisc1.max(rxy).powf(beta) {
         // Point is in approximately conical region above the disc. Just need to check whether
         // it is not occulted by the edge of the disc
         result = circle_eclipse(rxy, r.z, h_out, rdisc2, tani, &mut phase);
@@ -100,27 +104,27 @@ pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f6
             temp.push((0.0, 1.1));
         } else if result == Circle::Crossing {
             // point partially occulted by disc edge; work out phases
-            let phi0: f64 = r.y.atan2(r.x)/TAU;
+            let phi0: f64 = r.y.atan2(r.x) / TAU;
             ingress = phi0 + phase;
             ingress -= ingress.floor();
-            egress = ingress + 1.0 - 2.0*phase;
+            egress = ingress + 1.0 - 2.0 * phase;
             temp.push((ingress, egress));
         }
         return Ok(temp);
     }
 
-    // Compute the radius of circle formed by LOSC in the plane of 
+    // Compute the radius of circle formed by LOSC in the plane of
     // the lower outer rim of the disc
-    let rcone_lo: f64 = 0.0_f64.max(tani*(-h_out - r.z));
+    let rcone_lo: f64 = 0.0_f64.max(tani * (-h_out - r.z));
 
     // Circle encloses rim, so no intersection
     if rcone_lo >= rxy + rdisc2 {
         return Ok(temp);
     }
 
-    // Compute the radius of circle formed by LOSC in the plane of 
+    // Compute the radius of circle formed by LOSC in the plane of
     // the upper outer rim of the disc
-    let rcone_hi: f64 = tani*(h_out - r.z);
+    let rcone_hi: f64 = tani * (h_out - r.z);
 
     // Circle disjoint from rim, so no intersection
     if rxy >= rcone_hi + rdisc2 {
@@ -128,7 +132,7 @@ pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f6
     }
 
     // For the moment we pretend that the disc has no hole at its centre, so
-    // that we are simply interested in the phases over which eclipse occurs. 
+    // that we are simply interested in the phases over which eclipse occurs.
     // At this point we are guaranteed that this will happen. All events are
     // symmetrically located around a phase defined by x and y only which will
     // be calculated at the end. We therefore just find the half range which
@@ -136,30 +140,25 @@ pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f6
 
     let eclipse_phase: f64;
     if rxy + rcone_lo <= rdisc2 {
-
         // Cone swept out by line of sight always inside lower face so total eclipse
         eclipse_phase = 0.5;
     } else if rxy <= rdisc2 {
-
-        // Points that project close to the z axis which are only 
+        // Points that project close to the z axis which are only
         // partially obscured by the disc hovering above them.
-        // this means they must be below -HOUT    
+        // this means they must be below -HOUT
         eclipse_phase = cut_phase(rxy, rcone_lo, rdisc2);
     } else {
-
         // Points further from the z axis than the outer rim of the disc that
         // will be eclipsed.
-        if rcone_hi*rcone_hi + rdisc2*rdisc2 >= rxy*rxy
-           && rcone_lo*rcone_lo + rdisc2*rdisc2 <= rxy*rxy {
-
+        if rcone_hi * rcone_hi + rdisc2 * rdisc2 >= rxy * rxy
+            && rcone_lo * rcone_lo + rdisc2 * rdisc2 <= rxy * rxy
+        {
             // In this case it is the curved outer disc rim that sets the limit
-            eclipse_phase = (rdisc2/rxy).asin()/TAU;
-        } else if rcone_hi*rcone_hi + rdisc2*rdisc2 < rxy*rxy {
-
+            eclipse_phase = (rdisc2 / rxy).asin() / TAU;
+        } else if rcone_hi * rcone_hi + rdisc2 * rdisc2 < rxy * rxy {
             // In this case it is upper outer rim that sets the limit
             eclipse_phase = cut_phase(rxy, rcone_hi, rdisc2);
         } else {
-
             // In this case it is lower outer rim that sets the limit
             eclipse_phase = cut_phase(rxy, rcone_lo, rdisc2);
         }
@@ -170,7 +169,7 @@ pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f6
     // Now let's calculate the 'appear_phase' if any.
 
     // First compute height of disc at inner boundary
-    let h_in: f64 = height*rdisc1.powf(beta);
+    let h_in: f64 = height * rdisc1.powf(beta);
 
     let mut appear_phase: f64 = -1.0;
 
@@ -206,11 +205,9 @@ pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f6
             }
         }
     } else if rxy < rdisc1 {
-
         if r.z < -h_in {
-
             // Points hovering around underside of disc. Have to consider just three circles
-      
+
             // First, the lower inner rim
             result = circle_eclipse(rxy, r.z, -h_in, rdisc1, tani, &mut phase);
             if result == Circle::Inside {
@@ -239,7 +236,6 @@ pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f6
                 }
             }
         } else if r.z < h_in {
-
             // Points inside hole in middle of disc. Have to consider just two circles
 
             // First, the upper inner rim
@@ -263,12 +259,12 @@ pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f6
     }
 
     // Here is the central phase
-    let phi0: f64 = r.y.atan2(-r.x/TAU);
+    let phi0: f64 = r.y.atan2(-r.x / TAU);
 
     if appear_phase <= 0.0 {
         ingress = phi0 - eclipse_phase;
         ingress -= ingress.floor();
-        egress = ingress + 2.0*eclipse_phase;
+        egress = ingress + 2.0 * eclipse_phase;
         temp.push((ingress, egress));
     } else if appear_phase < eclipse_phase {
         ingress = phi0 - eclipse_phase;
@@ -281,23 +277,27 @@ pub fn disc_eclipse(iangle: f64, rdisc1: f64, rdisc2: f64, beta: f64, height: f6
         temp.push((ingress, egress));
     }
 
-    return Ok(temp)
-
+    Ok(temp)
 }
 
-
-pub fn circle_eclipse(rxy: f64, z: f64, zcirc: f64, radius: f64, tani: f64, phase: &mut f64) -> Circle {
-
+pub fn circle_eclipse(
+    rxy: f64,
+    z: f64,
+    zcirc: f64,
+    radius: f64,
+    tani: f64,
+    phase: &mut f64,
+) -> Circle {
     // point above circle
     if z >= zcirc {
         return Circle::Above;
     }
-    let rcone: f64 = tani*(zcirc - z);
+    let rcone: f64 = tani * (zcirc - z);
 
     // line-of-sight always outside the circle
     if rcone >= rxy + radius {
         return Circle::Outside;
-    } 
+    }
 
     // line-of-sight circle separate from the circle
     if rxy >= rcone + radius {
@@ -313,12 +313,9 @@ pub fn circle_eclipse(rxy: f64, z: f64, zcirc: f64, radius: f64, tani: f64, phas
     *phase = cut_phase(rxy, rcone, radius);
 
     Circle::Crossing
-
 }
 
-
 pub fn cut_phase(rxy: f64, rcone: f64, radius: f64) -> f64 {
-
     // Temporary checks
     if rxy + rcone <= radius {
         panic!("rxy + rcone <= radius");
@@ -330,5 +327,5 @@ pub fn cut_phase(rxy: f64, rcone: f64, radius: f64) -> f64 {
         panic!("rcone >= radius + rxy");
     }
 
-    ((rxy*rxy + rcone*rcone - radius*radius)/(2.0*rcone*rxy)).acos()/TAU
+    ((rxy * rxy + rcone * rcone - radius * radius) / (2.0 * rcone * rxy)).acos() / TAU
 }

{roche-0.2.3 → roche-0.2.8}/src/errors.rs

@@ -1,5 +1,5 @@
-use pyo3::prelude::*;
 use pyo3::exceptions::{PyRuntimeError, PyValueError};
+use pyo3::prelude::*;
 use std::fmt;
 
 #[derive(Debug)]
@@ -17,7 +17,7 @@ pub enum RocheError {
     // error in rtsafe function
     RtsafeError(String),
     // error in wd_phases function
-    WdphasesError(String)
+    WdphasesError(String),
 }
 
 impl std::error::Error for RocheError {}
@@ -44,8 +44,8 @@ impl std::convert::From<RocheError> for PyErr {
             RocheError::PotminError(_) => PyRuntimeError::new_err(err.to_string()),
             RocheError::ParameterError(_) => PyValueError::new_err(err.to_string()),
             RocheError::FaceError(_) => PyRuntimeError::new_err(err.to_string()),
-            RocheError::RtsafeError(_) => PyRuntimeError::new_err(err.to_string()), 
-            RocheError::WdphasesError(_) => PyRuntimeError::new_err(err.to_string()), 
+            RocheError::RtsafeError(_) => PyRuntimeError::new_err(err.to_string()),
+            RocheError::WdphasesError(_) => PyRuntimeError::new_err(err.to_string()),
         }
     }
-}
+}