merge develop

.gitignore

@@ -1,2 +1,5 @@
 *~
 .DS_Store
++drc2
+va
+drc2_lib.slx

@Andsm/Andsm.m

@@ -1,13 +1,13 @@
 classdef Andsm < handle
     properties
-        trainingData
-        validationData
+        training_data
+        validation_data
 
         model
     end
     properties (Access = private)
-        iBestModel
-        jBestModel
+        i_best_model
+        j_best_model
 
         n
         m
@@ -18,70 +18,70 @@
 
         prev
 
-        errL2
-        errLinf
+        err_l2
+        err_linf
     end
     methods
-        function self = Andsm(trainingData, validationData)
+        function self = Andsm(training_data, validation_data)
             % Init values
 
             % Validate training and validation data
-            validateData_(trainingData, 'training');
+            validateData_(training_data, 'training');
 
-            if ~isempty(validationData)
-                validateData_(validationData, 'validation');
+            if ~isempty(validation_data)
+                validateData_(validation_data, 'validation');
             end
 
             % Store training and validation data
-            self.trainingData = trainingData;
-            self.validationData = validationData;
+            self.training_data = training_data;
+            self.validation_data = validation_data;
 
-            self.m = size(trainingData.u{1}, 2);
-            self.n = size(trainingData.x{1}, 2); 
+            self.m = size(training_data.u{1}, 2);
+            self.n = size(training_data.x{1}, 2); 
 
         end
 
-        function val = isSolved(self)
+        function val = is_solved(self)
             if isempty(self.model)
                 val = false;
             else
                 val = true;
             end
         end
 
-        function prev = getPreviousSolverState(self)
+        function prev = get_solver_state(self)
             prev = self.prev;
         end
-        function prevKappa = getPreviousKappa(self)
-            prevKappa = self.kappa;
+        function kappa = get_kappa(self)
+            kappa = self.kappa;
         end
-        function prevLambda = getPreviousLambda(self)
-            prevLambda = self.lambda;
+        function lambda = get_lambda(self)
+            lambda = self.lambda;
         end
 
         % Model performance metrics
         val = err(self, errType, stats)
 
-        val = errL2Avg(self)
-        val = errL2Std(self)
+        val = err_l2_avg(self)
+        val = err_l2_std(self)
 
-        val = errLinfAvg(self)
-        val = errLinfStd(self)
+        val = err_linf_avg(self)
+        val = err_linf_std(self)
 
         % Best model (with min avg L2 err)
-        [bestModel, errL2BestModel, errLinfBestModel, indexBestModel] ...
-            = getBestModel(self)
+        [best_model, err_l2_best_model, err_linf_best_model, index_best_model] ...
+            = get_best_model(self)
 
         % Model training
-        train(self, deg, kappa, lambda, isIncrementallyStable, solverConfig)
+        train(self, deg, kappa, lambda, solver_config)
 
         % Export model
-        export(self, filename, modelType, modelInput, option, model)
+        export(self, filename, model_type, model_input, option, model)
     end
 
     methods (Static)
         [tt, uu, xx, yy] = sim(model, time, u, x0, tol)
-        [errL2, errLinf] = computeError(t, x, tRef, xRef)
+        [errL2, errLinf] = compute_error(t, x, t_ref, x_ref)
     end
 
 end

@Andsm/err.m

@@ -1,72 +1,72 @@
-function val = err(self, errType, stats)
+function val = err(self, err_type, stats)
 
 if nargin <= 1
-    errType = '';
+    err_type = '';
 end
 if nargin <= 2
     stats = '';
 end
-errType = lower(errType);
+err_type = lower(err_type);
 stats = lower(stats);
 
-err.L2 = [];
-err.Linf = [];
-switch errType
+err.l2 = [];
+err.linf = [];
+switch err_type
     case 'l2'
-        err.L2 = self.errL2;
+        err.l2 = self.err_l2;
     case 'linf'
-        err.Linf = self.errLinf;
+        err.linf = self.err_linf;
     otherwise
-        err.L2 = self.errL2;
-        err.Linf = self.errLinf; 
+        err.l2 = self.err_l2;
+        err.linf = self.err_linf; 
 end
 
 switch stats
     case {'avg', 'average'}
-        [m, n] = size(err.L2);
-        val.L2 = zeros(m, n);
+        [m, n] = size(err.l2);
+        val.l2 = zeros(m, n);
         for i = 1 : m
             for j = 1 : n
-                val.L2(i,j) = err.L2{i,j}.avg;
+                val.l2(i,j) = err.l2{i,j}.avg;
             end
         end
-        [m, n] = size(err.Linf);
-        val.Linf = zeros(m, n);
+        [m, n] = size(err.linf);
+        val.linf = zeros(m, n);
         for i = 1 : m
             for j = 1 : n
-                val.Linf(i,j) = err.Linf{i,j}.avg;
+                val.linf(i,j) = err.linf{i,j}.avg;
             end
         end
     case 'std'
-        [m, n] = size(err.L2);
-        val.L2 = zeros(m, n);
+        [m, n] = size(err.l2);
+        val.l2 = zeros(m, n);
         for i = 1 : m
             for j = 1 : n
-                val.L2(i,j) = err.L2{i,j}.std;
+                val.l2(i,j) = err.l2{i,j}.std;
             end
         end
-        [m, n] = size(err.Linf);
-        val.Linf = zeros(m, n);
+        [m, n] = size(err.linf);
+        val.linf = zeros(m, n);
         for i = 1 : m
             for j = 1 : n
-                val.Linf(i,j) = err.Linf{i,j}.std;
+                val.linf(i,j) = err.linf{i,j}.std;
             end
         end
     otherwise
-        val.L2 = err.L2;
-        val.Linf = err.Linf;
+        val.l2 = err.l2;
+        val.linf = err.linf;
 end
 
-if isempty(val.L2)
-    val = rmfield(val, 'L2');
+if isempty(val.l2)
+    val = rmfield(val, 'l2');
 end
-if isempty(val.Linf)
-    val = rmfield(val, 'Linf');
+if isempty(val.linf)
+    val = rmfield(val, 'linf');
 end
 
 if length(fieldnames(val)) == 1
-    fieldName = fieldnames(val);
-    val = getfield(val, fieldName{1});
+    fieldname = fieldnames(val);
+    val = getfield(val, fieldname{1});
 end
 
 

@Andsm/export.m

@@ -1,12 +1,12 @@
-function export(self, filename, modelType, modelInput, option, model)
+function export(self, filename, model_type, model_input, option, model)
 
 if nargin <= 5  % no model
-    if ~self.isSolved
-        errStruct.message = 'No model and models not trained yet';
-        errStruct.identifier = 'Andsi:export:noSolution';
-        error(errStruct);
+    if ~self.is_solved
+        err_struct.message = 'No model and models not trained yet';
+        err_struct.identifier = 'Andsi:export:no_solution';
+        error(err_struct);
     end
-    model = self.model{self.iBestModel, self.jBestModel};
+    model = self.model{self.i_best_model, self.j_best_model};
 end
 
 if nargin <= 4  % no option
@@ -15,14 +15,14 @@ function export(self, filename, modelType, modelInput, option, model)
 
 [pathstr,filename,~] = fileparts(filename);
 
-switch lower(modelType)
+switch lower(model_type)
     case {'simulink', 'simscape', 'ssc'}
         % Prepare pinPosition
-        if isfield(option, 'pinPosition')
+        if isfield(option, 'pin_position')
             if lengh(option.pinPosition) ~= model.m
-                errStruct.message = 'Length of option.pinPostion must be number of ports';
-                errStruct.identifier = 'Andsi:export:pinNumberError';
-                error(errStruct);    
+                err_struct.message = 'Length of option.pinPostion must be number of ports';
+                err_struct.identifier = 'Andsi:export:pin_number_error';
+                error(err_struct);    
             end
         else
             option.pinPosition = repmat('l',1,model.m);
@@ -34,31 +34,31 @@ function export(self, filename, modelType, modelInput, option, model)
             label = filename;
         end
 
-        switch lower(modelInput)
+        switch lower(model_input)
             case {'i', 'current'}
-                exportSimscapeI_(model, pathstr, filename, label, option);               
+                export_simscape_i_(model, pathstr, filename, label, option);               
             case {'v', 'voltage'}
-                exportSimscapeV_(model, pathstr, filename, label, option);                               
+                export_simscape_v_(model, pathstr, filename, label, option);                               
             otherwise
-                errStruct.message = 'modelInput is either ''i'' for current (through variable) or ''v'' for voltage (across variable)';
-                errStruct.identifier = 'Andsi:export:modelInputError';
-                error(errStruct);    
+                err_struct.message = 'model_input is either ''i'' for current (through variable) or ''v'' for voltage (across variable)';
+                err_struct.identifier = 'Andsi:export:model_input_error';
+                error(err_struct);    
         end
 
     case {'veriloga', 'va'}
-        switch lower(modelInput)
+        switch lower(model_input)
             case {'i', 'current'}
-                exportVerilogaI_(model, pathstr, filename, option);
+                export_veriloga_i_(model, pathstr, filename, option);
             case {'v', 'voltage'}
-
+                export_veriloga_v_(model, pathstr, filename, option);
             otherwise
-                errStruct.message = 'modelInput is either ''i'' for current (through variable) or ''v'' for voltage (across variable)';
-                errStruct.identifier = 'Andsi:export:modelInputError';
-                error(errStruct);    
+                err_struct.message = 'model_input is either ''i'' for current (through variable) or ''v'' for voltage (across variable)';
+                err_struct.identifier = 'Andsi:export:model_input_error';
+                error(err_struct);    
         end
 
     otherwise
-        errStruct.message = 'modelType is either ''ssc'' for Simulink or ''va'' for Verilog A';
-        errStruct.identifier = 'Andsi:export:modelTypeError';
-        error(errStruct);    
+        err_struct.message = 'model_type is either ''ssc'' for Simulink or ''va'' for Verilog A';
+        err_struct.identifier = 'Andsi:export:model_type_error';
+        error(err_struct);    
 end

@Andsm/get_best_model.m

@@ -0,0 +1,16 @@
+function [best_model, err_best_model, index_best_model] = get_best_model(self)
+
+if ~self.is_solved
+    err_struct.message = 'Models not trained yet';
+    err_struct.identifier = 'Andsi:model_best:no_solution';
+    error(err_struct);
+end
+
+best_model = self.model{self.i_best_model, self.j_best_model};
+err = self.err;
+err_best_model.l2_avg = err.l2{self.i_best_model, self.j_best_model}.avg;
+err_best_model.l2_std = err.l2{self.i_best_model, self.j_best_model}.std;
+err_best_model.linf_avg = err.linf{self.i_best_model, self.j_best_model}.avg;
+err_best_model.linf_std = err.linf{self.i_best_model, self.j_best_model}.std;
+index_best_model = [self.i_best_model, self.j_best_model];
+