Make solve_scaled_odgp_with_parity return iterator

I changed the name to this:
solve_scaled_odgp_with_parity_k_ne_0

Because the zero branch returned the wrong type. But
it is never called with k=0.

Author: jlapeyre

src/odgp.rs

@@ -133,7 +133,6 @@ pub fn solve_odgp_with_parity(
         .map(move |alpha| (alpha * ZRootTwo::new(IBig::ZERO, IBig::ONE)) + &p)
 }
 
-
 pub fn solve_scaled_odgp(i: Interval, j: Interval, k: i64) -> impl Iterator<Item = DRootTwo> {
     let scale = pow_sqrt2(k);
     let neg_scale = -scale.clone();
@@ -142,22 +141,22 @@ pub fn solve_scaled_odgp(i: Interval, j: Interval, k: i64) -> impl Iterator<Item
     } else {
         j.scale(&neg_scale)
     };
-    solve_odgp(i.scale(&scale), scaled_j)
-        .map(move |alpha| DRootTwo::new(alpha, k))
+    solve_odgp(i.scale(&scale), scaled_j).map(move |alpha| DRootTwo::new(alpha, k))
 }
 
-pub fn solve_scaled_odgp_with_parity(
+pub fn solve_scaled_odgp_with_parity_k_ne_0(
     i: Interval,
     j: Interval,
     k: i64,
     beta: &DRootTwo,
-) -> Vec<DRootTwo> {
-    if k == 0 {
-        let base = beta.renew_denomexp(0);
-        return solve_odgp_with_parity(i, j, &base)
-            .map(DRootTwo::from_zroottwo)
-            .collect();
-    }
+) -> impl Iterator<Item = DRootTwo> {
+    // Can't do this because the iterators are not of the same type.
+    // But this function is only called with k == 1. So we don't need the k == 0 branch.
+    // if k == 0 {
+    //     let base = beta.renew_denomexp(0);
+    //     return solve_odgp_with_parity(i, j, &base)
+    //          .map(DRootTwo::from_zroottwo);
+    //  }
 
     let p = beta.renew_denomexp(k).parity();
     let offset = if p == IBig::ZERO {
@@ -169,7 +168,7 @@ pub fn solve_scaled_odgp_with_parity(
     let sub_i = i - offset.to_real();
     let sub_j = j - offset.conj_sq2().to_real();
     let sol = solve_scaled_odgp(sub_i, sub_j, k - 1);
-    sol.into_iter().map(|a| a + offset.clone()).collect()
+    sol.map(move |a| a + offset.clone())
 }
 
 #[cfg(test)]

src/tdgp.rs

@@ -7,7 +7,7 @@ use dashu_int::IBig;
 
 use crate::common::{fb_with_prec, ib_to_bf_prec};
 use crate::grid_op::GridOp;
-use crate::odgp::{solve_scaled_odgp, solve_scaled_odgp_with_parity};
+use crate::odgp::{solve_scaled_odgp, solve_scaled_odgp_with_parity_k_ne_0};
 use crate::region::{Ellipse, Interval, Rectangle};
 use crate::ring::{DOmega, DRootTwo};
 
@@ -42,7 +42,7 @@ pub fn solve_tdgp(
 
     let alpha0 = match sol_x.next() {
         Some(val) => val,
-        None => return vec![]
+        None => return vec![],
     };
 
     let droot_zero = DRootTwo::from_int(IBig::ZERO);
@@ -99,10 +99,8 @@ pub fn solve_tdgp(
         int_a = int_a.fatten(&dt_a);
         int_b = int_b.fatten(&dt_b);
 
-        let sol_t = solve_scaled_odgp_with_parity(int_a, int_b, 1, &parity);
-        let sol_x = sol_t
-            .into_iter()
-            .map(|alpha| alpha * dx.clone() + alpha0.clone());
+        let sol_t = solve_scaled_odgp_with_parity_k_ne_0(int_a, int_b, 1, &parity);
+        let sol_x = sol_t.map(|alpha| alpha * dx.clone() + alpha0.clone());
         for alpha in sol_x {
             sol_sufficient.push(DOmega::from_droottwo_vector(&alpha, &beta, k));
         }