optimize scan inequalities

Author: kaikalii

site/src/other.rs

@@ -189,7 +189,7 @@ pub fn Optimizations() -> impl IntoView {
             </tr>
             <tr><th><Prim prim=Table/></th> <td>"✔"</td> <td>"✔"</td> <td>"✔"</td> <td>"✔"</td> <td>"✔"</td></tr>
             <tr><th><Prim prim=Reduce/></th> <td>"✔"</td> <td></td>  <td></td> <td>"✔"</td> <td></td></tr>
-            <tr><th><Prim prim=Scan/></th> <td>"✔"</td>  <td>"✔"</td> <td></td> <td></td> <td></td></tr>
+            <tr><th><Prim prim=Scan/></th> <td>"✔"</td>  <td>"✔"</td> <td>"✔"</td> <td></td> <td></td></tr>
         </table>
 
         <p>"The pattern "<Prims prims=[Reduce]/><code>"F"</code><Prims prims=[Table]/><code>"G"</code>" is optimized to use much less memory and run much faster than the naive implementation. This only occurs when both functions have signature "<code>"|2.1"</code>". Rather than creating the entire table and then reducing it, each reduced row is generated as it is needed."</p>

src/algorithm/reduce.rs

@@ -784,6 +784,10 @@ pub fn scan(ops: Ops, env: &mut Uiua) -> UiuaResult {
             let mut arr = match prim {
                 Primitive::Eq => fast_scan(nums, |a, b| is_eq::num_num(a, b) as f64),
                 Primitive::Ne => fast_scan(nums, |a, b| is_ne::num_num(a, b) as f64),
+                Primitive::Lt => fast_scan(nums, |a, b| other_is_lt::num_num(a, b) as f64),
+                Primitive::Le => fast_scan(nums, |a, b| other_is_le::num_num(a, b) as f64),
+                Primitive::Gt => fast_scan(nums, |a, b| other_is_gt::num_num(a, b) as f64),
+                Primitive::Ge => fast_scan(nums, |a, b| other_is_ge::num_num(a, b) as f64),
                 Primitive::Add => fast_scan(nums, add::num_num),
                 Primitive::Sub if flipped => fast_scan(nums, flip(sub::num_num)),
                 Primitive::Sub => fast_scan(nums, sub::num_num),
@@ -824,6 +828,10 @@ pub fn scan(ops: Ops, env: &mut Uiua) -> UiuaResult {
             let mut val: Value = match prim {
                 Primitive::Eq => fast_scan(bytes, is_eq::generic).into(),
                 Primitive::Ne => fast_scan(bytes, is_ne::generic).into(),
+                Primitive::Lt => fast_scan(bytes, other_is_lt::generic).into(),
+                Primitive::Le => fast_scan(bytes, other_is_le::generic).into(),
+                Primitive::Gt => fast_scan(bytes, other_is_gt::generic).into(),
+                Primitive::Ge => fast_scan(bytes, other_is_ge::generic).into(),
                 Primitive::Add => fast_scan::<f64>(bytes.convert(), add::num_num).into(),
                 Primitive::Sub if flipped => {
                     fast_scan::<f64>(bytes.convert(), flip(sub::num_num)).into()