Preset for optional symbolic integration of VanderPol problem (#18)

* added the init cond with extra powwers of epsilon expansion

* switched to symbolic init condition (Need to fix this)

* added option for symbolic Y0 in state Validator

* added preset for symbolic vanderpol integration

* fixed pull request comments: conversion to double before casting to sym

* fixed pull request comments: conversion to double before casting to sym

* fixed pull request comments: conversion to double before casting to sym

* better error msg

* better error msg

* Remove all symbolic dependencies

* Typo fix in error message

* Add comments explaining epsilon expansion

Co-authored-by: Steven Roberts <sroberts994@gmail.com>
Co-authored-by: Steven Roberts <steven94@vt.edu>

Author: elswit

src/+otp/+utils/StructParser.m

@@ -39,13 +39,13 @@
         function isValid = validateFromString(~, x, validator)
             switch validator
                 case 'numeric'
-                    isValid = isnumeric(x);
+                    isValid = isnumeric(x) || isa(x, 'sym');
                 case 'real'
                     isValid = isreal(x);
                 case 'finite'
-                    isValid = all(isfinite(x));
+                    isValid = all(isfinite(x), 'all');
                 case 'integer'
-                    isValid = isreal(x) && all(floor(x) == x);
+                    isValid = isreal(x) && all(floor(x) == x, 'all');
                 case 'vector'
                     isValid = isvector(x);
                 case 'matrix'
@@ -57,13 +57,13 @@
                 case 'scalar'
                     isValid = isscalar(x);
                 case 'positive'
-                    isValid = all(x > 0);
+                    isValid = all(x > 0, 'all');
                 case 'nonnegative'
-                    isValid = all(x >= 0);
+                    isValid = all(x >= 0, 'all');
                 case 'negative'
-                    isValid = all(x < 0);
+                    isValid = all(x < 0, 'all');
                 case 'nonpositive'
-                    isValid = all(x <= 0);
+                    isValid = all(x <= 0, 'all');
                 case 'row'
                     isValid = isrow(x);
                 case 'column'

src/+otp/+vanderpol/+presets/ExtendedPrecision.m

@@ -0,0 +1,39 @@
+classdef ExtendedPrecision < otp.vanderpol.VanderpolProblem
+    methods
+        function obj = ExtendedPrecision(epsilon)
+            if nargin < 1
+                epsilon = 1e-6;
+            end
+            
+            cls = class(epsilon);
+            
+            coeffs = [ ...
+                % Express large fractions using numbers that fit into a double
+                cast(199944165973, cls) / cast(3486784401, cls) * cast(7499951716, cls) / cast(4782969, cls), ...
+                cast(-1532057748884056, cls) / cast(617673396283947, cls) * cast(4765, cls), ...
+                cast(336712727619991, cls) / cast(22876792454961, cls) * cast(116, cls), ...
+                cast(-231923508930412, cls) / cast(847288609443, cls), ...
+                cast(515714746118, cls) / cast(10460353203, cls), ...
+                cast(-3927188888, cls) / cast(387420489, cls), ...
+                cast(34896076, cls) / cast(14348907, cls), ...
+                cast(-1121308, cls) / cast(1594323, cls), ...
+                cast(15266, cls) / cast(59049, cls), ...
+                cast(-292, cls) / cast(2187, cls), ...
+                cast(10, cls) / cast(81, cls), ...
+                cast(-2, cls) / cast(3, cls)];
+            z0 = 0;
+            for c = coeffs
+                % Use Horner's method to compute epsilon expansion
+                z0 = epsilon * z0 + c;
+            end
+            
+            y0 = [2; z0];
+            tspan = [0, 0.5];            
+            
+            params.epsilon = epsilon;
+            obj = obj@otp.vanderpol.VanderpolProblem(tspan, y0, params);
+            
+        end
+    end
+end
+

src/+otp/Problem.m

@@ -120,12 +120,12 @@ function validateNewState(obj, newTimeSpan, newY0, newParameters)
             % Ensures the TimeSpan, Y0, and Parameters are valid
             if length(newTimeSpan) ~= 2
                 error('TimeSpan must be a vector of two times');
-            elseif ~isnumeric(newTimeSpan)
+            elseif ~(isnumeric(newTimeSpan) || isa(newTimeSpan, 'sym'))
                 error('TimeSpan must be numeric');
             elseif ~iscolumn(newY0)
                 error('Y0 must be a column vector');
-            elseif ~(isnumeric(newY0) && all(isfinite(newY0)))
-                error('Y0 must be numeric and finite');
+            elseif ~(isnumeric(newY0) || isa(newY0, 'sym'))
+                error('Y0 must be numeric');
             elseif ~(isempty(obj.ExpectedNumVars) || length(newY0) == obj.ExpectedNumVars)
                 error('Expected Y0 to have %d components but has %d', obj.ExpectedNumVars, length(newY0));
             elseif ~isstruct(newParameters)