refactoring and javadoc

Author: RealAntEngineer

src/main/java/com/rae/formicapi/math/data/OneDTabulatedFunction.java

@@ -0,0 +1,91 @@
+package com.rae.formicapi.math.data;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+public class OneDTabulatedFunction {
+    private final TreeMap<Float, Float> table;
+    private final float step;
+    private final StepMode mode;
+    private final boolean clamp;
+
+    /**
+     * @param table Sorted data: x -> y
+     * @param step Distance between values in transformed space (e.g., log(x) if LOGARITHMIC)
+     * @param mode The axis step mode (linear, log, etc.)
+     * @param clamp Clamp outside instead of extrapolating.
+     */
+    public OneDTabulatedFunction(TreeMap<Float, Float> table, float step, StepMode mode, boolean clamp) {
+        this.table = table;
+        this.step = step;
+        this.mode = mode;
+        this.clamp = clamp;
+    }
+
+    private float evaluate(double input, TreeMap<Float, Float> table) {
+        if (table.isEmpty()) {
+            throw new IllegalStateException("Function table is empty");
+        }
+
+        float index = (float) (mode.forward.applyAsDouble(input) / step);
+        int lowerIndex = (int) Math.floor(index);
+        float frac = index - lowerIndex;
+
+        float T1 = (float) mode.inverse.applyAsDouble(lowerIndex * step);
+        float T2 = (float) mode.inverse.applyAsDouble((lowerIndex + 1) * step);
+
+        // Safeguard in case floating-point precision causes a missing key
+        if (!table.containsKey(T1) || !table.containsKey(T2)) {
+            Map.Entry<Float, Float> lower = table.floorEntry((float) input);
+            Map.Entry<Float, Float> upper = table.ceilingEntry((float) input);
+
+            if (lower == null || upper == null) {
+                return table.get(table.firstKey());
+            }
+
+            float T_lower = lower.getKey();
+            float T_upper = upper.getKey();
+            if (T_lower == T_upper) {
+                return table.get(T_lower);
+            }
+            float fracAlt = (float) ((input - T_lower) / (T_upper - T_lower));
+
+            return lower.getValue() * (1 - fracAlt) + upper.getValue() * fracAlt;
+        }
+
+        float P1 = table.get(T1);
+        float P2 = table.get(T2);
+
+        return P1 * (1 - frac) + P2 * frac;
+    }
+
+    public float evaluate(float output) {
+        return evaluate(output, table);
+    }
+
+    private float extrapolateBelow(TreeMap<Float, Float> searchMap) {
+        Map.Entry<Float, Float> lower = searchMap.firstEntry();
+        Map.Entry<Float, Float> upper = searchMap.higherEntry(lower.getKey());
+        if (upper == null) return lower.getValue();
+        return linear(searchMap, lower, upper);
+    }
+
+    private float extrapolateAbove(TreeMap<Float, Float> searchMap) {
+        Map.Entry<Float, Float> upper = searchMap.lastEntry();
+        Map.Entry<Float, Float> lower = searchMap.lowerEntry(upper.getKey());
+        if (lower == null) return upper.getValue();
+        return linear(searchMap, lower, upper);
+    }
+
+    private float linear(TreeMap<Float, Float> map, Map.Entry<Float, Float> a, Map.Entry<Float, Float> b) {
+        float x1 = a.getKey();
+        float x2 = b.getKey();
+        float y1 = a.getValue();
+        float y2 = b.getValue();
+        float query = map.firstKey(); // doesn't matter in this context
+        float t = (query - x1) / (x2 - x1);
+        return y1 * (1 - t) + y2 * t;
+    }
+
+
+}

src/main/java/com/rae/formicapi/math/data/ReversibleOneDTabulatedFunction.java

@@ -0,0 +1,77 @@
+package com.rae.formicapi.math.data;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.function.Function;
+
+public class ReversibleOneDTabulatedFunction {
+
+    private final OneDTabulatedFunction f;
+    private final OneDTabulatedFunction inverse_f;
+
+    public ReversibleOneDTabulatedFunction(Function<Float, Float>  f, float min, float max, StepMode stepMode, float step, StepMode inverseStepMode, float inverseStep) {
+        TreeMap<Float, Float> populated = populate(f, min, max, stepMode, step);
+        this.f = new OneDTabulatedFunction(populated, step, stepMode, true);
+        inverse_f = new OneDTabulatedFunction(invertTable(populated, inverseStepMode, inverseStep), inverseStep, inverseStepMode, true);
+    }
+
+    private TreeMap<Float, Float> populate(Function<Float, Float>  f, float min, float max, StepMode stepMode, float step) {
+        TreeMap<Float, Float> treeMap = new TreeMap<>();
+        for (float x = min; x < max; x= (float) stepMode.inverse.applyAsDouble(stepMode.forward.applyAsDouble(x) + step)) {
+            try {
+                float P = f.apply(x);
+                treeMap.put(x, P);
+            } catch (Exception ignored) {
+            }
+        }
+        return treeMap;
+    }
+
+
+    /**
+     * Returns a reversed version of the map: y -> x
+     */
+    private TreeMap<Float, Float> invertTable(TreeMap<Float, Float> original, StepMode stepMode, float step) {
+        TreeMap<Float, Float> inverted = new TreeMap<>();
+        // Step 2: Build regular grid in log(P) space
+        List<Map.Entry<Float, Float>> entries = new ArrayList<>(original.entrySet());
+
+        // Determine the log pressure range
+        float logP_start = (float) stepMode.forward.applyAsDouble(entries.get(0).getValue());
+        float logP_end = (float) stepMode.forward.applyAsDouble(entries.get(entries.size() - 1).getValue());
+        int numSteps = (int) ((logP_end - logP_start) / step);
+
+
+        for (int i = 0; i < numSteps; i++) {
+            float targetLogP = logP_start + i * step;
+
+            // Find where targetLogP fits between logP1 and logP2
+            for (int j = 0; j < entries.size() - 1; j++) {
+                float T1 = entries.get(j).getKey();
+                float T2 = entries.get(j + 1).getKey();
+                float logP1 = (float) stepMode.forward.applyAsDouble(entries.get(j).getValue());
+                float logP2 = (float) stepMode.forward.applyAsDouble(entries.get(j + 1).getValue());
+
+                if (targetLogP >= logP1 && targetLogP <= logP2 && logP1 != logP2) {
+                    // Linear interpolation in logP
+                    float t = (targetLogP - logP1) / (logP2 - logP1);
+                    float T_interp = T1 + t * (T2 - T1);
+
+                    inverted.put((float) stepMode.inverse.applyAsDouble(targetLogP), T_interp);
+                    break;
+                }
+            }
+        }
+        return inverted;
+    }
+
+    public float getF(float x) {
+        return f.evaluate(x);
+    }
+
+    public float getInverseF(float x) {
+        return inverse_f.evaluate(x);
+    }
+}

src/main/java/com/rae/formicapi/math/data/StepMode.java

@@ -0,0 +1,22 @@
+package com.rae.formicapi.math.data;
+
+import java.util.function.DoubleUnaryOperator;
+
+public enum StepMode {
+    LINEAR(
+            x -> x,
+            x -> x
+    ),
+    LOGARITHMIC(
+            Math::log,
+            Math::exp
+    );
+
+    public final DoubleUnaryOperator forward;
+    public final DoubleUnaryOperator inverse;
+
+    StepMode(DoubleUnaryOperator forward, DoubleUnaryOperator inverse) {
+        this.forward = forward;
+        this.inverse = inverse;
+    }
+}

src/main/java/com/rae/formicapi/thermal_utilities/EOSLibrary.java

@@ -1,5 +1,8 @@
 package com.rae.formicapi.thermal_utilities;
 
+import com.rae.formicapi.thermal_utilities.eos.PengRobinsonEOS;
+import com.rae.formicapi.thermal_utilities.eos.VanDerWaalsEOS;
+
 public class EOSLibrary {
     //you can find a,b values at https://en.wikipedia.org/wiki/Van_der_Waals_constants_(data_page)
     public static PengRobinsonEOS getPRWaterEOS() {