text:
function regular_training_ms(video)

opts.dataDir = 'net/traffic_Simple' ;
opts.expDir = ['net/' video] ;

opts.train.batchSize = 5 ;
opts.train.numEpochs = 20;
opts.train.continue = false ;
opts.train.useGpu = true ;
opts.train.learningRate    = 1e-3;
opts.train.expDir = opts.expDir ;

scales = [1, 0.75, 0.5];

%opts = vl_argparse(opts, varargin) ;

% --------------------------------------------------------------------
%                                                         Prepare data
% --------------------------------------------------------------------

imgDir = ['../SBMIDataset/' video '/input'];
labelDir = ['../SBMIDataset/' video '/groundtruth'];
imdb = getImdb(video,imgDir,labelDir);

imdb.half_size = 15;

%%%%%%Yi%%%%%% redefined the net
load('net');

net.layers{end-1} = struct('type', 'conv', ...
    'filters', 0.1*randn(1,1,64,1, 'single'), ...
    'biases', zeros(1, 1, 'single'), ...
    'stride', 1, ...
    'pad', 0) ;
net.layers{end} = struct('type', 'sigmoidcrossentropyloss');

load('meanPixel.mat');
imdb.meanPixel = meanPixel;
imdb.scales = scales;

[net,info] = cnn_train_adagrad_ms(net, imdb, @getBatch,...
    opts.train,'errorType','euclideanloss',...
    'conserveMemory', true);

end

function [im, labels] = getBatch(imdb, batch)
% --------------------------------------------------------------------

half_size = imdb.half_size;
meanPixel = imdb.meanPixel;

for ii = 1:numel(batch)

    imagename = imdb.images.name{batch(ii)};
    im_ii = single(imread(imagename));
    labelname = imdb.images.labels{batch(ii)};
    roi = imread(labelname);
    labels_ii = zeros(size(roi, 1), size(roi, 2));
    labels_ii( roi == 50 )  = 0.25;       %shade
    labels_ii( roi == 170 ) = 0.75;       %object boundary
    labels_ii( roi == 255 ) = 1;          %foreground

    % resize the image to half size
    if size(im_ii,1) > 400 || size(im_ii,2) >400
        im_ii = imresize(im_ii, 0.5, 'nearest');
        labels_ii = imresize(labels_ii, 0.5, 'nearest');
    end

    im(:,:,:,ii) = im_ii;
    labels(:,:,1,ii) = labels_ii;
end
end

function imdb = getImdb(video, imgDir, labelDir)

files = [dir([imgDir '/*.png']); dir([imgDir '/*.jpg'])];
label_files = dir([labelDir '/*.png']);
names = {};labels = {};

load(['../split/' video '.mat']);

for ii = 1:numel(train_index)
    names{end+1} = [imgDir '/' files(train_index(ii)).name];
    labels{end+1} = [labelDir '/' label_files(train_index(ii)).name];
end

im = imread(labels{1});
mask = ones(size(im,1),size(im,2));
if size(mask,1) > 400 || size(mask,2) >400
    mask = imresize(mask, 0.5, 'nearest');
end

imdb.mask = single(mask);

imdb.images.set = ones(1,numel(names));
imdb.images.name = names ;
imdb.images.labels = labels;
end

author: zhangqianqianQQ

repo: MachineVisionAlgorithm


text:
% book : Signals and Systems Laboratory with MATLAB
% authors : Alex Palamides & Anastasia Veloni

% DFT of a circularly shifted sequence

% circular shift in time
x=[ 1 0 3 4 7];
m=2;
xc=circshift(x',m);
Left=dft(xc);
Left.'

X=dft(x);
N=length(x);
k=0:N-1;
Right=X.*exp(-j*2*pi*m*k/N);
Right.'

% circular shift in frequency
x=[ 1 0 3 4 7];
N=length(x);
n=0:N-1;
m=2;
Left=dft(x.*exp(j*2*pi*n*m/N));
Left.'

X=dft(x);
Right=circshift(X.',m)

author: Sable

repo: mcbench-benchmarks


text:
function EEG = eeg_formatamica(EEG)
if isfield(EEG.etc.amica,'LLt') && isfield(EEG.etc.amica,'LLt_smooth')
    if size(EEG.data,2) == size(EEG.etc.amica.LLt,2) && size(EEG.data,3) == size(EEG.etc.amica.LLt,3)
        if size(EEG.data,2) == size(EEG.etc.amica.LLt_smooth,2) && size(EEG.data,3) == size(EEG.etc.amica.LLt_smooth,3)

            EEG.data = [EEG.data; EEG.etc.amica.LLt; EEG.etc.amica.LLt_smooth];
            EEG.etc.amica.prob_added = 1;
            num_models = size(EEG.etc.amica.LLt,1);
            EEG.nbchan = EEG.nbchan + 2*num_models;
            if ~isempty(EEG.chanlocs)
                channames = {};
                for k=1:2*num_models
                    channames{end+1} = ['prob' num2str(k)]; end
                [EEG.chanlocs(end+1 : end+2*num_models).labels] = channames{:};
            end
        end
    end
end

author: PatternRecognition

repo: OpenBMI


text:
function [lin_restr,nonlin_restr,tpl]=create_restrictions_and_markov_chains0(tpl)
% create_restrictions_and_markov_chains0 -- creates restrictions for
% the constant-parameter SVAR model
%
% ::
%
%
%   [lin_restr,nonlin_restr,tpl]=create_restrictions_and_markov_chains0(tpl)
%
% Args:
%
%    - **tpl** [struct]: template created for SVAR objects
%
% Returns:
%    :
%
%    - **lin_restr** [cell]: two column-cell (see below). The first column
%    contains COEF objects or linear combinations of COEF objects, which are
%    themselves COEF objects.
%
%    - **nonlin_restr** [cell]: one column-cell containing inequality or
%    nonlinear restrictions
%
%    - **tpl** [struct]: non-modified template
%
% Note:
%
%    - The syntax to construct a basic COEF object is a=coef(eqtn,vname,lag)
%      - **eqtn** [integer|char]: integer or variable name
%      - **vname** [integer|char]: integer or variable name
%      - **lag** [integer]: integer or variable name
%
%    - RISE sorts the endogenous variables alphabetically and use this order
%    to tag each equation in SVAR and RFVAR models.
%
% Example:
%    coef('pi','ygap',0)
%
%    coef(2,3,0)
%
%    coef(2,'ygap',0)
%
%    coef('pi',3,0)
%
%    See also:

% syntax is coef(eqtn,vname,lag)
%-------------------------------
lin_restr={
    % first equation or "FFR" equation
    %----------------------------------
    coef('FFR','pi',1),0
    coef('FFR','pi',2),0
    coef('FFR','ygap',1),0
    coef('FFR','ygap',2),0
    coef('FFR','FFR',2),0
    % second equation or "pi" equation
    %----------------------------------
    coef('pi','FFR',0),0
    coef('pi','FFR',1),0
    coef('pi','FFR',2),0
    coef('pi','ygap',1),0
    coef('pi','ygap',2),0
    % third equation or "ygap" equation
    %-----------------------------------
    coef('ygap','FFR',1),0
    coef('ygap','FFR',2),0
    coef('ygap','pi',1),0
    coef('ygap','pi',2),0
    coef('ygap','pi',0)+coef('ygap','FFR',0),0
    };
nonlin_restr={
    % third equation or "ygap" equation
    %-----------------------------------
    'coef(ygap,FFR,0)>=0'
    };
end

author: jmaih


text:
classdef SoITransitionUpIntTermCause < AbstractIntegrationTerminationCause
    %SoITransitionUpIntTermCause Summary of this class goes here
    %   Detailed explanation goes here

    properties
        fromBody KSPTOT_BodyInfo
        toBody KSPTOT_BodyInfo
        celBodyData
    end

    methods
        function obj = SoITransitionUpIntTermCause(fromBody, toBody, celBodyData)
            obj.fromBody = fromBody;
            obj.toBody = toBody;
            obj.celBodyData = celBodyData;
        end

        function tf = shouldRestartIntegration(obj)
            tf = true;
        end

        function newStateLogEntry = getRestartInitialState(obj, stateLogEntry)
            bodyInfo = stateLogEntry.centralBody;
            ut = stateLogEntry.time;
            rVect = reshape(stateLogEntry.position,1,3);
            vVect = reshape(stateLogEntry.velocity,1,3);

            [rVectUp, vVectUp] = convertRVVectOnUpwardsSoITransition(bodyInfo, obj.celBodyData, ut, rVect, vVect);

            dcm = stateLogEntry.attitude.dcm;

            newStateLogEntry = stateLogEntry.deepCopy();
            newStateLogEntry.position = rVectUp;
            newStateLogEntry.velocity = vVectUp;
            newStateLogEntry.centralBody = obj.toBody;
            newStateLogEntry.steeringModel = stateLogEntry.steeringModel.deepCopy();

            if(newStateLogEntry.steeringModel.requiresReInitAfterSoIChange())
                newStateLogEntry.steeringModel.setContinuityTerms(true, true, true);
                newStateLogEntry.steeringModel.setConstsFromDcmAndContinuitySettings(dcm, ut, rVectUp, vVectUp, obj.toBody);
                newStateLogEntry.steeringModel.setT0(ut);
            end

            newStateLogEntry.lvState.clearCachedConnEnginesTanks();
        end
    end
end

author: Arrowstar

repo: ksptot

save_path: github-repos/MATLAB/Arrowstar-ksptot


text:
function [wordCounts] = updateCounts(wordCounts, data)
  wordCounts.total = wordCounts.total + data.numWords;
  wordCounts.word = wordCounts.word + data.numWords;
end

author: lmthang


text:
function x = perform_l1_recovery(D,y,options)

% perform_l1_recovery - run an L1 solver
%
%   x = perform_l1_recovery(D,y,options);
%
%   options.method can be
%       'bp', 'omp', 'itthresh' (nb.iter is options.niter_inversion).
%
%   Copyright (c) 2007 Gabriel Peyre

options.null = 0;

if isfield(options, 'method')
    method = options.method;
else
    method = 'bp';
end
if isfield(options, 's')
    s = options.s;
else
    s = 20;
end
if isfield(options, 'niter_inversion')
    mcaIters = options.niter_inversion;
else
    mcaIters = 200;
end

m = size(D,2);

% OMP options
maxItersOMP = s;
solFreq = 0; verbose = 0; lambdaStop = 0;

% BP options
maxIters = getoptions(options, 'niterbp', 20);
lambda_bp = getoptions(options, 'lambda_bp', 0);
OptTol = getoptions(options, 'tol', 1e-5);

switch lower(method)
    case 'bp'
        x = SolveBP(D, y, m, maxIters, lambda_bp, OptTol);
    case 'omp'
        % x = SolveOMP(D, y, m, maxItersOMP, lambdaStop, solFreq, verbose, OptTol);
        options.nbr_max_atoms = s;
        x = perform_omp(D,y,options);
    case 'itthresh'
        options.niter = mcaIters;
        [x,E] = perform_iterative_thresholding(D,y,options);
    otherwise
        error('Unknown method');
end

author: gpeyre

repo: matlab-toolboxes


text:
function product_mixed_weight_test ( dim_num, order_1d, order_nd, rule, alpha, beta )

%*****************************************************************************80
%
%% PRODUCT_MIXED_WEIGHT_TEST computes the weights of a mixed factor product rule.
%
%  Discussion:
%
%    This routine gets the sparse grid indices and determines the
%    corresponding sparse grid weights.
%
%  Licensing:
%
%    This code is distributed under the GNU LGPL license.
%
%  Modified:
%
%    05 March 2011
%
%  Author:
%
%    John Burkardt
%
%  Parameters:
%
%    Input, integer DIM_NUM, the spatial dimension.
%
%    Input, integer ORDER_1D(DIM_NUM), the order of the 1D rules.
%
%    Input, integer ORDER_ND, the order of the product rule.
%
%    Input, integer RULE(DIM_NUM), the rule in each dimension.
%     1, "CC",  Clenshaw Curtis, Closed Fully Nested rule.
%     2, "F2",  Fejer Type 2, Open Fully Nested rule.
%     3, "GP",  Gauss Patterson, Open Fully Nested rule.
%     4, "GL",  Gauss Legendre, Open Weakly Nested rule.
%     5, "GH",  Gauss Hermite, Open Weakly Nested rule.
%     6, "GGH", Generalized Gauss Hermite, Open Weakly Nested rule.
%     7, "LG",  Gauss Laguerre, Open Non Nested rule.
%     8, "GLG", Generalized Gauss Laguerre, Open Non Nested rule.
%     9, "GJ",  Gauss Jacobi, Open Non Nested rule.
%    10, "GW",  Golub Welsch, (presumed) Open Non Nested rule.
%    11, "CC_SE", Clenshaw Curtis Slow Exponential, Closed Fully Nested rule.
%    12, "F2_SE", Fejer Type 2 Slow Exponential, Closed Fully Nested rule.
%    13, "GP_SE", Gauss Patterson Slow Exponential, Closed Fully Nested rule.
%    14, "CC_ME", Clenshaw Curtis Moderate Exponential, Closed Fully Nested rule.
%    15, "F2_ME", Fejer Type 2 Moderate Exponential, Closed Fully Nested rule.
%    16, "GP_ME", Gauss Patterson Moderate Exponential, Closed Fully Nested rule.
%    17, "CCN", Clenshaw Curtis Nested, Linear, Closed Fully Nested rule.
%
%    Input, real ALPHA(DIM_NUM), BETA(DIM_NUM), parameters used for
%    Generalized Gauss Hermite, Generalized Gauss Laguerre, and Gauss Jacobi rules.
%
  weight_sum_exact = 1.0;

  for dim = 1 : dim_num

    if ( rule(dim) == 1 )
      weight_sum_exact = weight_sum_exact * 2.0;
    elseif ( rule(dim) == 2 )
      weight_sum_exact = weight_sum_exact * 2.0;
    elseif ( rule(dim) == 3 )
      weight_sum_exact = weight_sum_exact * 2.0;
    elseif ( rule(dim) == 4 )
      weight_sum_exact = weight_sum_exact * 2.0;
    elseif ( rule(dim) == 5 )
      weight_sum_exact = weight_sum_exact * sqrt ( pi );
    elseif ( rule(dim) == 6 )
      weight_sum_exact = weight_sum_exact * r8_gamma ( 0.5 * ( alpha(dim) + 1.0 ) );
    elseif ( rule(dim) == 7 )
      weight_sum_exact = weight_sum_exact * 1.0;
    elseif ( rule(dim) == 8 )
      weight_sum_exact = weight_sum_exact * r8_gamma ( alpha(dim) + 1.0 );
    elseif ( rule(dim) == 9 )
      arg1 = - alpha(dim);
      arg2 = 1.0;
      arg3 = beta(dim) + 2.0;
      arg4 = - 1.0;
      value1 = r8_hyper_2f1 ( arg1, arg2, arg3, arg4 );
      arg1 = - beta(dim);
      arg2 = 1.0;
      arg3 = alpha(dim) + 2.0;
      arg4 = - 1.0;
      value2 = r8_hyper_2f1 ( arg1, arg2, arg3, arg4 );
      weight_sum_exact = weight_sum_exact * ( ...
        value1 / ( beta(dim) + 1.0 ) + value2 / ( alpha(dim) + 1.0 ) );
    elseif ( rule(dim) == 10 )
      fprintf ( 1, '\n' );
      fprintf ( 1, 'PRODUCT_MIXED_WEIGHT_TEST - Fatal error!\n' );
      fprintf ( 1, '  Do not know how to handle rule 10.\n' );
      error ( 'PRODUCT_MIXED_WEIGHT_TEST - Fatal error!' );
    elseif ( rule(dim) == 11 )
      weight_sum_exact = weight_sum_exact * 2.0;
    elseif ( rule(dim) == 12 )
      weight_sum_exact = weight_sum_exact * 2.0;
    elseif ( rule(dim) == 13 )
      weight_sum_exact = weight_sum_exact * 2.0;
    elseif ( rule(dim) == 14 )
      weight_sum_exact = weight_sum_exact * 2.0;
    elseif ( rule(dim) == 15 )
      weight_sum_exact = weight_sum_exact * 2.0;
    elseif ( rule(dim) == 16 )
      weight_sum_exact = weight_sum_exact * 2.0;
    elseif ( rule(dim) == 17 )
      weight_sum_exact = weight_sum_exact * 2.0;
    else
      fprintf ( 1, '\n' );
      fprintf ( 1, 'PRODUCT_MIXED_WEIGHT_TEST - Fatal error!\n' );
      fprintf ( 1, '  Unexpected value of RULE = %d\n', rule(dim) );
      error ( 'PRODUCT_MIXED_WEIGHT_TEST - Fatal error!' );
    end

  end

  fprintf ( 1, '\n' );
  fprintf ( 1, 'PRODUCT_MIXED_WEIGHT_TEST:\n' );
  fprintf ( 1, '  Compute the weights of a mixed factor product grid.\n' );
  fprintf ( 1, '\n' );
  fprintf ( 1, '  As a simple test, sum these weights.\n' );
  fprintf ( 1, '  They should sum to exactly %f\n', weight_sum_exact );
  fprintf ( 1, '\n' );
  fprintf ( 1, '  Spatial dimension DIM_NUM = %d\n', dim_num );

  fprintf ( 1, '\n' );
  fprintf ( 1, ' Dimension      Rule     Order        Alpha          Beta\n' );
  fprintf ( 1, '\n' );

  for dim = 1 : dim_num
    fprintf ( 1, '  %8d  %8d  %8d', dim, rule(dim), order_1d(dim) );
    if ( rule(dim) == 6 | rule(dim) == 8 | rule(dim) == 9 )
      fprintf ( 1, '  %12e', alpha(dim) );
    end
    if ( rule(dim) == 9 )
      fprintf ( 1, '  %12e', beta(dim) );
    end
    fprintf ( 1, '\n' );
  end
%
%  Compute the weights and points.
%
  weight = product_mixed_weight ( dim_num, order_1d, order_nd, rule, alpha, beta );
%
%  Sum the weights.
%
  weight_sum = sum ( weight(1:order_nd) );

  weight_sum_error = abs ( weight_sum - weight_sum_exact );

  fprintf ( 1, '\n' );
  fprintf ( 1, '    Weight sum  Expected sum    Difference\n' );
  fprintf ( 1, '\n' );
  fprintf ( 1, '  %14e  %14e  %14e\n', ...
    weight_sum, weight_sum_exact, weight_sum_error );

  return
end

author: johannesgerer

repo: jburkardt-m


text:
function [binned_data_spike_counts binned_labels binned_site_info] = load_binned_data_and_convert_firing_rates_to_spike_counts(binned_data_file_name, bin_width)

% This function allows one to load binned-format data and convert the binned_data for each site into spike counts.
%   The reason this function is needed is because paricular classifiers, such as the Poisson Naive Bayes classifier,
%   operate on integer data, however create_time_averaged_binned_data_from_raster data
%   creates firing rates that are not integers, thus by using this method, the firing rate data will be converted into integer spike counts).
%
%
% Inputs arguments:
%
%   1.  binned_data_file_name: the file name of data that is in binned format (that contains binned_data which has firing rate data)
%
% Optional input arguemnts:
%
%   bin_width: the bin width that each column of binned_data{iSite} was averaged over to create firing rates. If this argument is a vector, then the values
%       correspond to the bin widths of each column of binned_data{iSite}; if this value is a scalar then it is assumed that all bin widths are the same size.
%       If this argument is not given then this method assumes there is a variable binned_site_info.binning_parameters.bin_width that will be used as the bin width (this variable
%       will exist if the function create_binned_data_from_raster_data was used to create the binned data.
%
% Output arguments:
%
%   1. binned_data_spike_counts:  binned_data that has been converted into spike counts
%   2. binned_labels:  the binned labels
%   3. binned_site_info: the binned site info
%

%==========================================================================

%     This code is part of the Neural Decoding Toolbox.
%     Copyright (C) 2013 by Ethan Meyers (emeyers@mit.edu)
%
%     This program is free software: you can redistribute it and/or modify
%     it under the terms of the GNU General Public License as published by
%     the Free Software Foundation, either version 3 of the License, or
%     (at your option) any later version.
%
%     This program is distributed in the hope that it will be useful,
%     but WITHOUT ANY WARRANTY; without even the implied warranty of
%     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
%     GNU General Public License for more details.
%
%     You should have received a copy of the GNU General Public License
%     along with this program.  If not, see <http://www.gnu.org/licenses/>.

%==========================================================================

   load(binned_data_file_name)

   if nargin < 2
        bin_width = binned_site_info.binning_parameters.bin_width;   % will either be a number, or if custom bin widths are used, this will be a vector
   end

   c = 1;
   for iSite = 1:size(binned_data, 2)   % go through each site and convert it into

       if isscalar(bin_width)
           binned_data_spike_counts{iSite} =  binned_data{iSite} .* bin_width;
       else
           binned_data_spike_counts{iSite} = binned_data{iSite} .* repmat(bin_width, size(binned_data{iSite}, 1), 1);
       end

       % check to make sure that binned_data_spike_counts only contains integers showing that the conversion worked correctly
       %if length(find(rem(binned_data_spike_counts{iSite}, 1) ~= 0))
       %if length(find(rem(binned_data_spike_counts{iSite}, 1) > 10^-12)) % changed it to this to deal with numerical precision issues

       % changed to make this work with Octave (rounding errors can occur in both directions)
       deviations_from_intergers_matrix = min(rem(binned_data_spike_counts{iSite}, 1), 1 - rem(binned_data_spike_counts{iSite}, 1));

       if length(find(deviations_from_intergers_matrix > 10^-12))
           sites_with_failed_conversions(c) = iSite;
           c = c + 1;
       else
           binned_data_spike_counts{iSite} = round(binned_data_spike_counts{iSite});  % round data to get rid of small numerical imprecisions
       end

   end

   if exist('sites_with_failed_conversions')
        warning(['The following sites did not correctly convert to spike counts: ' num2str(sites_with_failed_conversions)]);
   end

end

author: buzsakilab

repo: buzcode

save_path: github-repos/MATLAB/buzsakilab-buzcode


text:
V = (max(newt2.Latitude) - min(newt2.Latitude)) * (max(newt2.Longitude) - min(newt2.Longitude)) * 111*111 *1000*1000 *100 *100*30*1000*100;
dt = max(newt2.Date) - min(newt2.Date);
c = sum( 10.^(1.5*newt2.Magnitude + 16.1));
Msum = 2/3*( log10(c) - 16.1 )
strain = 1/(2*3*10^11*V*dt) * c
% annual deformation in mm
def = strain*(max(newt2.Latitude) - min(newt2.Latitude))*111*1000*100*10

%bdiff2
plotfmdsA1A2
c = 0; RE = [];
dt = 1;
for m = 2:0.1:9
    N = 10^(aw-bw*m);
    c = c + N*( 10.^(1.5*m + 16.1));
    Msum = 2/3*( log10(c) - 16.1 );
    strain = 1/(2*3*10^11*V*dt) * c;
    def = strain*(max(newt2.Latitude) - min(newt2.Latitude))*111*1000*100*10;
    RE = [RE ; m Msum strain def];
end

figure
pl = plot(RE(:,1),RE(:,4),'sk');
set(gca,'Yscale','log')
set(pl,'markerfacecolor','b');
xlabel('Mw')
ylabel('annual deformation (mm)');

author: CelsoReyes


text:
function I=montec(f,a,b,n)

%I=montec('f',a,b,k);
%Calculates integral using montecarlo method
for k=1:n
    s=2.^k;
    t=rand(1,s);
    x=a+t.*(b-a);

    for i=1:s
        y(i)=feval(f,x(i));
    end

    I(k)=((b-a)./s)*sum(y);
end
plot(I);


text:
classdef ScalarNodalPrinter < ScalarPrinter

    properties (Access = private)
        nDecimalPositions = 12
    end

    methods (Access = public)

        function obj = ScalarNodalPrinter(d)
            obj.init(d);
            obj.createFieldRepresenter();
            obj.print();
        end

    end

    methods (Access = private)

        function init(obj,d)
            fieldsNames = fieldnames(d);
            for ifield = 1:length(fieldsNames)
                fieldName = fieldsNames{ifield};
                fieldValue = d.(fieldName);
                obj.(fieldsNames{ifield}) = fieldValue;
            end
        end

        function roundFieldValues(obj)
            obj.fieldValues = round(obj.fieldValues,obj.nDecimalPositions);
        end

        function createFieldRepresenter(obj)
            s.fileID        = obj.fileID;
            s.fieldName     = obj.fieldName;
            s.simulationStr = obj.simulationStr;
            s.iter          = obj.iter;
            s.fieldType     = obj.fieldType;
            s.fieldPosition = obj.fieldPosition;
            s.fieldValues   = obj.fieldValues;
            s.nComp         = 1;
            obj.fieldRepresenter = NodalFieldPrinter(s);
        end

    end

end

author: SwanLab

repo: Swan

save_path: github-repos/MATLAB/SwanLab-Swan