Data update

Task/Resistor-mesh/Rust/resistor-mesh.rs

@@ -0,0 +1,133 @@
+use std::fmt;
+
+#[derive(Clone, Copy)]
+struct Node {
+    v: f64,
+    fixed: i32,
+}
+
+impl Node {
+    fn new() -> Self {
+        Node { v: 0.0, fixed: 0 }
+    }
+
+    fn new_with_values(v: f64, fixed: i32) -> Self {
+        Node { v, fixed }
+    }
+
+    fn get_v(&self) -> f64 {
+        self.v
+    }
+
+    fn set_v(&mut self, nv: f64) {
+        self.v = nv;
+    }
+
+    fn get_fixed(&self) -> i32 {
+        self.fixed
+    }
+
+    fn set_fixed(&mut self, nf: i32) {
+        self.fixed = nf;
+    }
+}
+
+impl fmt::Display for Node {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Node {{ v: {}, fixed: {} }}", self.v, self.fixed)
+    }
+}
+
+fn set_boundary(m: &mut Vec<Vec<Node>>) {
+    m[1][1].set_v(1.0);
+    m[1][1].set_fixed(1);
+
+    m[6][7].set_v(-1.0);
+    m[6][7].set_fixed(-1);
+}
+
+fn calculate_difference(
+    m: &Vec<Vec<Node>>,
+    d: &mut Vec<Vec<Node>>,
+    w: usize,
+    h: usize,
+) -> f64 {
+    let mut total = 0.0;
+    for i in 0..h {
+        for j in 0..w {
+            let mut v = 0.0;
+            let mut n = 0;
+            if i > 0 {
+                v += m[i - 1][j].get_v();
+                n += 1;
+            }
+            if j > 0 {
+                v += m[i][j - 1].get_v();
+                n += 1;
+            }
+            if i + 1 < h {
+                v += m[i + 1][j].get_v();
+                n += 1;
+            }
+            if j + 1 < w {
+                v += m[i][j + 1].get_v();
+                n += 1;
+            }
+            let val = m[i][j].get_v() - v / n as f64;
+            d[i][j].set_v(val);
+            if m[i][j].get_fixed() == 0 {
+                total += val * val;
+            }
+        }
+    }
+    total
+}
+
+fn iter(m: &mut Vec<Vec<Node>>, w: usize, h: usize) -> f64 {
+    let mut d: Vec<Vec<Node>> = vec![vec![Node::new(); w]; h];
+
+    let mut curr: [f64; 3] = [0.0, 0.0, 0.0];
+    let mut diff = 1e10;
+
+    while diff > 1e-24 {
+        set_boundary(m);
+        diff = calculate_difference(m, &mut d, w, h);
+        for i in 0..h {
+            for j in 0..w {
+                let current_v = m[i][j].get_v();
+                let diff_v = d[i][j].get_v();
+                m[i][j].set_v(current_v - diff_v);
+            }
+        }
+    }
+
+    for i in 0..h {
+        for j in 0..w {
+            let mut k = 0;
+            if i != 0 {
+                k += 1;
+            }
+            if j != 0 {
+                k += 1;
+            }
+            if i < h - 1 {
+                k += 1;
+            }
+            if j < w - 1 {
+                k += 1;
+            }
+            curr[(m[i][j].get_fixed() + 1) as usize] += d[i][j].get_v() * k as f64;
+        }
+    }
+
+    (curr[2] - curr[0]) / 2.0
+}
+
+const S: usize = 10;
+
+fn main() {
+    let mut mesh: Vec<Vec<Node>> = vec![vec![Node::new(); S]; S];
+
+    let r = 2.0 / iter(&mut mesh, S, S);
+    println!("R = {:.15}", r);
+}