use tabs, not spaces

src/misc.rs

@@ -1,92 +1,92 @@
 cfg_if::cfg_if! {
-    if #[cfg(target_arch = "wasm32")] {
-        use wasm_bindgen::prelude::*;
-        #[wasm_bindgen]
-        extern "C" {
-            // Use `js_namespace` here to bind `console.log(..)` instead of just
-            // `log(..)`
-            #[wasm_bindgen(js_namespace = console)]
-            fn log(s: &str);
-        }
+	if #[cfg(target_arch = "wasm32")] {
+		use wasm_bindgen::prelude::*;
+		#[wasm_bindgen]
+		extern "C" {
+			// Use `js_namespace` here to bind `console.log(..)` instead of just
+			// `log(..)`
+			#[wasm_bindgen(js_namespace = console)]
+			fn log(s: &str);
+		}
 
-        #[allow(dead_code)]
-        pub fn log_helper(s: &str) {
-            log(s);
-        }
+		#[allow(dead_code)]
+		pub fn log_helper(s: &str) {
+			log(s);
+		}
 
-        #[allow(dead_code)]
-        #[allow(unused_variables)]
-        pub fn debug_log(s: &str) {
-            #[cfg(debug_assertions)]
-            log(s);
-        }
-    } else {
-        #[allow(dead_code)]
-        pub fn log_helper(s: &str) {
-            println!("{}", s);
-        }
+		#[allow(dead_code)]
+		#[allow(unused_variables)]
+		pub fn debug_log(s: &str) {
+			#[cfg(debug_assertions)]
+			log(s);
+		}
+	} else {
+		#[allow(dead_code)]
+		pub fn log_helper(s: &str) {
+			println!("{}", s);
+		}
 
-        #[allow(dead_code)]
-        #[allow(unused_variables)]
-        pub fn debug_log(s: &str) {
-            #[cfg(debug_assertions)]
-            println!("{}", s);
-        }
-    }
+		#[allow(dead_code)]
+		#[allow(unused_variables)]
+		pub fn debug_log(s: &str) {
+			#[cfg(debug_assertions)]
+			println!("{}", s);
+		}
+	}
 }
 
 pub struct SteppedVector {
-    data: Vec<f64>,
-    min: f64,
-    max: f64,
-    step: f64,
+	data: Vec<f64>,
+	min: f64,
+	max: f64,
+	step: f64,
 }
 
 impl SteppedVector {
-    pub fn get_index(&self, x: f64) -> Option<usize> {
-        if (x > self.max) | (self.min > x) {
-            return None;
-        }
+	pub fn get_index(&self, x: f64) -> Option<usize> {
+		if (x > self.max) | (self.min > x) {
+			return None;
+		}
 
-        // Should work....
-        let possible_i = ((x + self.min) / self.step) as usize;
-        if self.data[possible_i] == x {
-            Some(possible_i)
-        } else {
-            None
-        }
+		// Should work....
+		let possible_i = ((x + self.min) / self.step) as usize;
+		if self.data[possible_i] == x {
+			Some(possible_i)
+		} else {
+			None
+		}
 
-        // Not really needed as the above code should handle everything
-        /*
-        for (i, ele) in self.data.iter().enumerate() {
-            if ele > &x {
-                return None;
-            } else if &x == ele {
-                return Some(i);
-            }
-        }
-        None
-        */
-    }
+		// Not really needed as the above code should handle everything
+		/*
+		for (i, ele) in self.data.iter().enumerate() {
+			if ele > &x {
+				return None;
+			} else if &x == ele {
+				return Some(i);
+			}
+		}
+		None
+		*/
+	}
 }
 
 impl From<Vec<f64>> for SteppedVector {
-    // Note: input `data` is assumed to be sorted from min to max
-    fn from(data: Vec<f64>) -> SteppedVector {
-        let max = data[0];
-        let min = data[data.len() - 1];
-        let step = (max - min).abs() / ((data.len() - 1) as f64);
-        SteppedVector {
-            data,
-            min,
-            max,
-            step,
-        }
-    }
+	// Note: input `data` is assumed to be sorted from min to max
+	fn from(data: Vec<f64>) -> SteppedVector {
+		let max = data[0];
+		let min = data[data.len() - 1];
+		let step = (max - min).abs() / ((data.len() - 1) as f64);
+		SteppedVector {
+			data,
+			min,
+			max,
+			step,
+		}
+	}
 }
 
 // Rounds f64 to specific number of digits
 pub fn digits_precision(x: f64, digits: usize) -> f64 {
-    let large_number: f64 = 10.0_f64.powf(digits as f64);
-    (x * large_number).round() / large_number
+	let large_number: f64 = 10.0_f64.powf(digits as f64);
+	(x * large_number).round() / large_number
 }