Merge pull request #7 from chaossoftware/feature/update-to-num-methods-v2

Feature/update to num methods v2

Author: dobriyanchik

src/ChaosSoft.sln src/ModelledSystems.slnsrc/ChaosSoft.sln renamed to src/ModelledSystems.sln

@@ -0,0 +1,27 @@
+using System.Xml.Serialization;
+
+namespace ModelledSystems.Configuration;
+
+public class ChartsCfg
+{
+    [XmlAttribute("width")]
+    public int Width { get; set; }
+
+    [XmlAttribute("height")]
+    public int Height { get; set; }
+
+    [XmlAttribute("scale")]
+    public double Scale { get; set; }
+
+    [XmlAttribute("labelSize")]
+    public float LabelSize { get; set; }
+
+    [XmlAttribute("tickSize")]
+    public float TickSize { get; set; }
+
+    [XmlAttribute("padding")]
+    public float Padding { get; set; }
+
+    [XmlAttribute("grid")]
+    public bool Grid { get; set; }
+}

src/ModelledSystems/Configuration/ChartsCfg.cs

@@ -0,0 +1,29 @@
+using System.Linq;
+using System.Xml;
+using System.Xml.Serialization;
+
+namespace ModelledSystems.Configuration;
+
+[XmlRoot("Config")]
+public class Config
+{
+    [XmlElement("ModelingTask")]
+    public TaskCfg Task { get; set; }
+
+    [XmlElement("Output")]
+    public OutputCfg Out { get; set; }
+
+    [XmlArray("Routines")]
+    [XmlArrayItem("Routine", typeof(RoutineCfg))]
+    public RoutineCfg[] RoutinesList { get; set; }
+
+    [XmlArray("Systems")]
+    [XmlArrayItem("System", typeof(SystemCfg))]
+    public SystemCfg[] SystemsList { get; set; }
+
+    public RoutineCfg Routine =>
+        RoutinesList.First(r => r.Name == Task.Action);
+
+    public SystemCfg System =>
+        SystemsList.First(s => s.Name == Task.System);
+}

src/ModelledSystems/Configuration/Config.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Linq;
+
+namespace ModelledSystems.Configuration;
+
+internal static class ConfigUtils
+{
+    internal static double ParseParameterValue(string value)
+    {
+        string[] _operations = new string[] { "/", "*" };
+        string operation = _operations.FirstOrDefault(o => value.Contains(o));
+
+        if (operation == null)
+        {
+            return Convert.ToDouble(value);
+        }
+
+        string[] pair = value.Split(operation[0]);
+
+        double val1 = ParseValue(pair[0]);
+        double val2 = ParseValue(pair[1]);
+
+        return GetOperationResult(val1, val2, operation);
+    }
+
+    private static double ParseValue(string value)
+    {
+        value = value.Trim();
+
+        return value.Equals("pi", StringComparison.InvariantCultureIgnoreCase) ?
+            Math.PI :
+            Convert.ToDouble(value);
+    }
+
+    private static double GetOperationResult(double val1, double val2, string operation)
+    {
+        return operation switch
+        {
+            "*" => val1 * val2,
+            "/" => val1 / val2,
+            _ => throw new NotImplementedException($"operation {operation} is not recognized"),
+        };
+    }
+}

src/ModelledSystems/Configuration/ConfigUtils.cs

@@ -0,0 +1,12 @@
+using System.Xml.Serialization;
+
+namespace ModelledSystems.Configuration;
+
+public class OrthogonalizationCfg
+{
+    [XmlAttribute("type")]
+    public string Type { get; set; }
+
+    [XmlAttribute("interval")]
+    public int Interval { get; set; }
+}

src/ModelledSystems/Configuration/OrthogonalizationCfg.cs

@@ -0,0 +1,15 @@
+using System.Xml.Serialization;
+
+namespace ModelledSystems.Configuration;
+
+public class OutputCfg
+{
+    [XmlElement("Charts")]
+    public ChartsCfg Charts { get; set; }
+
+    [XmlAttribute("outDir")]
+    public string Dir { get; set; }
+
+    [XmlAttribute("binaryOutput")]
+    public bool BinOutput { get; set; }
+}

src/ModelledSystems/Configuration/OutputCfg.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Xml;
+using System.Xml.Serialization;
+
+namespace ModelledSystems.Configuration;
+
+public class RoutineCfg
+{
+    [XmlAttribute("name")]
+    public string Name { get; set; }
+
+    [XmlAnyAttribute]
+    public XmlAttribute[] XAttributes { get; set; }
+
+    public string GetString(string name) =>
+        XAttributes.First(a => a.Name.Equals(name)).Value;
+
+    public int GetInt(string name) =>
+        Convert.ToInt32(GetString(name), CultureInfo.InvariantCulture);
+
+    public double GetDouble(string name) =>
+        Convert.ToDouble(GetString(name), CultureInfo.InvariantCulture);
+}

src/ModelledSystems/Configuration/RoutineCfg.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Text.RegularExpressions;
+using System.Xml.Serialization;
+
+namespace ModelledSystems.Configuration;
+
+public class SysParamCfg
+{
+    private double from = double.NaN;
+    private double to = double.NaN;
+    private double value = double.NaN;
+
+    [XmlAttribute("range")]
+    public string rangeText;
+
+    [XmlAttribute("value")]
+    public string valueText;
+
+    [XmlAttribute("name")]
+    public string Name { get; set; }
+
+    public double From
+    {
+        get
+        {
+            if (double.IsNaN(from))
+            {
+                from = Convert.ToDouble(Regex.Split(rangeText, "\\.\\.")[0].Trim());
+            }
+
+            return from;
+        }
+    }
+
+    public double To
+    {
+        get
+        {
+            if (double.IsNaN(to))
+            {
+                to = Convert.ToDouble(Regex.Split(rangeText, "\\.\\.")[1].Trim());
+            }
+
+            return to;
+        }
+    }
+
+    public double Value
+    {
+        get
+        {
+            if (double.IsNaN(value))
+            {
+                value = ConfigUtils.ParseParameterValue(valueText);
+            }
+
+            return value;
+        }
+    }
+}

src/ModelledSystems/Configuration/SysParamCfg.cs

@@ -0,0 +1,26 @@
+using ChaosSoft.NumericalMethods.Ode;
+using System;
+using System.Xml.Serialization;
+
+namespace ModelledSystems.Configuration;
+
+public class SysSolverCfg
+{
+    [XmlAttribute("name")]
+    public string Name { get; set; }
+
+    [XmlAttribute("time")]
+    public double ModellingTime { get; set; }
+
+    [XmlAttribute("dt")]
+    public double Dt { get; set; }
+
+    public SolverType Type =>
+        Name.ToLowerInvariant() switch
+        {
+            "discrete" => SolverType.Discrete,
+            "rk4" => SolverType.RK4,
+            "rk5" => SolverType.RK5,
+            _ => throw new NotSupportedException($"Unknown solver {Name}"),
+        };
+}

src/ModelledSystems/Configuration/SysSolverCfg.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Xml.Serialization;
+
+namespace ModelledSystems.Configuration;
+
+public class SystemCfg
+{
+    [XmlAttribute("name")]
+    public string Name { get; set; }
+
+    [XmlElement("Solver")]
+    public SysSolverCfg Solver { get; set; }
+
+    [XmlArray("Parameters")]
+    [XmlArrayItem("Param", typeof(SysParamCfg))]
+    public SysParamCfg[] Params { get; set; }
+
+    [XmlElement("InitialConditions")]
+    public string InitialConditionsValue { get; set; }
+
+    [XmlElement("LinearInitialConditions")]
+    public string LinearInitialConditionsValue { get; set; }
+
+    public double[] InitialConditions =>
+        InitialConditionsValue.Split(' ').Select(v => ConfigUtils.ParseParameterValue(v)).ToArray();
+
+    public double[,] LinearInitialConditions
+    {
+        get
+        {
+            string[] rows = LinearInitialConditionsValue.Split(';');
+            double[,] conditions = new double[rows.Length, rows.Length];
+
+            for (int i = 0; i < rows.Length; i++)
+            {
+                string[] columns = rows[i].Trim().Split(' ');
+
+                for (int j = 0; j < rows.Length; j++)
+                {
+                    conditions[i, j] = Convert.ToDouble(columns[j].Trim(), CultureInfo.InvariantCulture);
+                }
+            }
+
+            return conditions;
+        }
+    }
+
+    public double[] ParamsValues => Params.Select(p => p.Value).ToArray();
+}