# doc-cache created by Octave 4.2.2
# name: cache
# type: cell
# rows: 3
# columns: 24
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
dividerand


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1139
 -- [ITR,IVAL,ITEST] = dividerand (N,TRAINRATIO,VALRATIO,TESTRATIO)
 -- [ITR,IVAL,ITEST] = dividerand (ALLTARGETS)
 -- [ITR,IVAL,ITEST] = dividerand (ALLTARGETS,TRAINRATIO)
 -- [ITR,IVAL,ITEST] = dividerand (ALLTARGETS,TRAINRATIO,VALRATIO)
 -- [ITR] = dividerand (...)
 -- [ITR,IVAL] = dividerand (...)

     Divide indices in training, validation and test group according to
     the informed ratios.

     If N is a number, it represents the number of indices you want to
     divide randomly.  The function returns three sets of indices
     according to the ratio coefficients provided.

     If N is a matrix, the function divides the columns of the matrix in
     the three sets and it returns them.

     TRAINRATIO,VALRATIO,TESTRATIO are the ratio coefficients provided
     by the user.  If not specified, the default value is TRAINRATIO =
     0.7, VALRATIO = 0.15, TESTRATIO = 0.15.  If the value of the ratios
     are not probabilities, they are normalized.

     Example:


          [indextrain,indexvalidation,indextest] = dividerand (30);
          [indextrain,indexvalidation,indextest] = dividerand (eye(100),56,12,14);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Divide indices in training, validation and test group according to the
informed 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
hardlim


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 859
 -- A = hardlim (N, FP)
 -- A = hardlim (N)
 -- INFO = hardlim ('CODE')
     Hard-limit transfer function.

     Return a matrix of size equal to N, with values of 1 when N is
     larger than or equal to 0, and 0 otherwise.

             / 0, N < 0
             |
             \ 1, N >= 0

     N is a S-by-Q matrix of input, while FP is a struct of function
     parameters, ignored by hardlim

     You can retrieve some information about the transfer function
     passing a string as first argument:

     'hardlim ('NAME')' returns the name of the transfer function

     'hardlim ('OUTPUT')' returns the minimum and maximum of the output
     range

     'hardlim ('ACTIVE')' returns the minimum and maximum of the active
     input range

     It is equivalent to:

          double (N >= 0)

     See also: hardlims, purelin, satlin, satlins, tansig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 29
Hard-limit transfer function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
hardlims


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 846
 -- A = hardlims (N, FP)
 -- A = hardlims (N)
 -- INFO = hardlims ('CODE')
     Hard-limit symmetric transfer function.

     Return a matrix of size equal to N, with values of 1 when N is
     larger than or equal to 0, and -1 otherwise.  It is equivalent to:

             / -1, N < 0
             |
             \  1, N >= 0

     N is a S-by-Q matrix of input, while FP is a struct of function
     parameters, ignored by hardlims

     You can retrieve some information about the transfer function
     passing a string as first argument:

     'hardlims ('NAME')' returns the name of the transfer function

     'hardlims ('OUTPUT')' returns the minimum and maximum of the output
     range

     'hardlims ('ACTIVE')' returns the minimum and maximum of the active
     input range

     See also: hardlim, purelin, satlin, satlins, tansig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 39
Hard-limit symmetric transfer function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
ind2vec


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 623
 -- VEC = ind2vec (IND, N)
 -- VEC = ind2vec (IND)

     Convert indices to sparse vector representation

     IND can be a row vector or a cell array of row vectors (not
     supported yet) of indices.  'ind2vec (IND)' returns a sparse matrix
     of column vectors, with 1 in each column corresponding with the
     index in IND.

     N is an integer greater or equal than the maximum index provided in
     IND.  If you provide the second argument to the function, 'ind2vec
     (IND, N)' will return a N x M matrix, with zeros in the last N-M
     rows.


          vec = ind2vec ([1 4 3 2], 6);
          full (vec);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Convert indices to sparse vector representation



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
isposint


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 289
 -- Function File: F = isposint(N)
     'isposint' returns true for positive integer values.

            isposint(1)   # this returns TRUE
            isposint(0.5) # this returns FALSE
            isposint(0)   # this also return FALSE
            isposint(-1)  # this also returns FALSE


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
'isposint' returns true for positive integer values.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
logsig


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1523
 -- A = logsig (N)
      -- : A = logsig (N FP)
           -- : A = logsig ('DN', N)
                -- : A = logsig ('DN', N, A)
                     -- : A = logsig ('DN', N, A, FP)
                          -- : INFO = logsig ('CODE')

                              'logsig' is a non-linear transfer function
                              used to train neural networks.

                              Return the log-sigmoid of every element or
                              the derivative of the log-sigmoid if the
                              input 'dn' is given.

                              N is a S-by-Q matrix of input, while FP is
                              a struct of function parameters, ignored
                              by logsig

                              You can retrieve some information about
                              the transfer function passing a string as
                              first argument:

                              'logsig ('NAME')' returns the name of the
                              transfer function

                              'logsig ('OUTPUT')' returns the minimum
                              and maximum of the output range

                              'logsig ('ACTIVE')' returns the minimum
                              and maximum of the active input range

                              This function can be used in newff(...)
                              to create a new feed forward multi-layer
                              neural network.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
'logsig' is a non-linear transfer function used to train neural
networks.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
mapstd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1269
 -- Function File: [YY,PS] = mapstd (XX,YMEAN,YSTD)
     Map values to mean 0 and standard derivation to 1.

          [YY,PS] = mapstd(XX,ymean,ystd)

             Apply the conversion and returns YY as (YY-ymean)/ystd.

          [YY,PS] = mapstd(XX,FP)

             Apply the conversion but using an struct to inform target mean/stddev.
             This is the same of [YY,PS]=mapstd(XX,FP.ymean, FP.ystd).

          YY = mapstd('apply',XX,PS)

             Reapply the conversion based on a previous operation data.
             PS stores the mean and stddev of the first XX used.

          XX = mapstd('reverse',YY,PS)

             Reverse a conversion of a previous applied operation.

          dx_dy = mapstd('dx',XX,YY,PS)

             Returns the derivative of Y with respect to X.

          dx_dy = mapstd('dx',XX,[],PS)

             Returns the derivative (less efficient).

          name = mapstd('name');

             Returns the name of this convesion process.

          FP = mapstd('pdefaults');

             Returns the default process parameters.

          names = mapstd('pnames');

             Returns the description of the process parameters.

          mapstd('pcheck',FP);

             Raises an error if FP has some inconsistent.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 50
Map values to mean 0 and standard derivation to 1.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
minmax


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1711
 -- Function File: PR = minmax (PP)
     Calculate maximum and mininum of rows.

     For each row of the matrix PP, outputs its minimum and maximum on
     the first and second column of PR respectively.  PR will have the
     same number of rows as PP and 2 columns.

          Pp = [5 7 9 2 5 0 6
                5 3 6 2 7 9 3
                8 3 2 3 5 6 8]
          minmax (Pp)
            => 0 9
               2 9
               0 8

     PP can also be a cell array of matrices in wich case they all must
     have the same number of columns, and all matrices on each row of
     cells must have the same number of rows.  In this case, matrices of
     each row of PP are concatenated horizontally for calculating the
     minimum ad maximum values.  PR will be a single column cell array
     with same number of rows as PP.  For example:

          Pp = {[0 1; 1 2; 4 6] [2 3; 8 0; 3 1] [9 1; 5 2; 4 8];
                 [1 2; 9 7] [5 2; 3 1] [7 6; 0 3]}
          minmax (Pp)
            => {
                 [1,1] =
                    0   9
                    0   8
                    1   8
                 [2,1] =
                    1   7
                    0   9
               }

     If drawn on a table, it would look like:

       2x3 cell array      2x1 cell array
     
      0 1   2 3   9 1   >      0 9
      1 2   8 0   5 2   >      0 8
      4 6   3 1   4 8   >      1 8
     
      1 2   5 2   7 6   >      1 7
      9 7   3 1   0 3   >      0 9

     Note how on this example: the number of columns (3) in the cell
     array is irrelevant but the output has the same number of rows (2);
     all matrices have the same number of columns (2).

     See also: cell2mat, max, min.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Calculate maximum and mininum of rows.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
newff


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 817
 -- Function File: NET = newff (PR,SS,TRF,BTF,BLF,PF)
     'newff' create a feed-forward backpropagation network

          Pr - R x 2 matrix of min and max values for R input elements
          Ss - 1 x Ni row vector with size of ith layer, for N layers
          trf - 1 x Ni list with transfer function of ith layer,
                default = "tansig"
          btf - Batch network training function,
                default = "trainlm"
          blf - Batch weight/bias learning function,
                default = "learngdm"
          pf  - Performance function,
                default = "mse".

          EXAMPLE 1
          Pr = [0.1 0.8; 0.1 0.75; 0.01 0.8];
               it's a 3 x 2 matrix, this means 3 input neurons

          net = newff(Pr, [4 1], {"tansig","purelin"}, "trainlm", "learngdm", "mse");


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
'newff' create a feed-forward backpropagation network



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
newp


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 541
 -- Function File: NET = newp (PR,SS,TRANSFUNC,LEARNFUNC)
     'newp' create a perceptron

          PLEASE DON'T USE THIS FUNCTIONS, IT'S STILL NOT FINISHED!
          =========================================================
          Pr - R x 2 matrix of min and max values for R input elements
          ss - a scalar value with the number of neurons
          transFunc - a string with the transfer function
                default = "hardlim"
          learnFunc - a string with the learning function
                default = "learnp"


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
'newp' create a perceptron



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
poslin


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 843
 -- A = poslin (N, FP)
 -- A = poslin (N)
 -- INFO = poslin ('CODE')
     Linear Positive transfer function.

     Return a matrix of size equal to N, with values equal to N when N
     is larger than or equal to 0, and 0 otherwise.  It is equivalent
     to:

             / 0, N < 0
             |
             \ n, N >= 0

     N is a S-by-Q matrix of input, while FP is a struct of function
     parameters, ignored by poslin

     You can retrieve some information about the transfer function
     passing a string as first argument:

     'poslin ('NAME')' returns the name of the transfer function

     'poslin ('OUTPUT')' returns the minimum and maximum of the output
     range

     'poslin ('ACTIVE')' returns the minimum and maximum of the active
     input range

     See also: hardlim, poslin, purelin, satlin, satlins, tansig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 34
Linear Positive transfer function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
poststd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 150
 -- Function File: [PP,TT] = poststd(PN,MEANP,,STDP,TN,MEANT,STDT)
     'poststd' postprocesses the data which has been preprocessed by
     'prestd'.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
'poststd' postprocesses the data which has been preprocessed by
'prestd'.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
prestd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 157
 -- Function File: [PN,MEANP,STDP,TN,MEANT,STDT] =prestd(P,T)
     'prestd' preprocesses the data so that the mean is 0 and the
     standard deviation is 1.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
'prestd' preprocesses the data so that the mean is 0 and the standard
deviation 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
purelin


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 682
 -- A = purelin (N, FP)
 -- A = purelin (N)
 -- INFO = purelin ('CODE')
     Linear transfer function.

     Return a matrix of size equal to N, with same values of N

     N is a S-by-Q matrix of input, while FP is a struct of function
     parameters, ignored by purelin

     You can retrieve some information about the transfer function
     passing a string as first argument:

     'purelin ('NAME')' returns the name of the transfer function

     'purelin ('OUTPUT')' returns the minimum and maximum of the output
     range

     'purelin ('ACTIVE')' returns the minimum and maximum of the active
     input range

     See also: hardlim, hardlims, satlin, satlins, tansig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
Linear transfer function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
radbas


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 96
 -- Function File: radbas (N)
     Radial basis transfer function.

     'radbas(n) = exp(-n^2)'


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 31
Radial basis transfer function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
satlin


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 879
 -- A = satlin (N, FP)
 -- A = satlin (N)
 -- INFO = satlin ('CODE')
     Saturating linear transfer function.

     Return a matrix of size equal to N, with values of 0 or 1 when N is
     less than 0 or larger than 1, and same values of N when N is
     between 0 and 1.

             / 0, if N < 0
             | n, if 0 < N < 1
             \ 1, if N > 1

     N is a S-by-Q matrix of input, while FP is a struct of function
     parameters, ignored by satlin

     You can retrieve some information about the transfer function
     passing a string as first argument:

     'satlin ('NAME')' returns the name of the transfer function

     'satlin ('OUTPUT')' returns the minimum and maximum of the output
     range

     'satlin ('ACTIVE')' returns the minimum and maximum of the active
     input range

     See also: hardlim, hardlims, logsig, purelin, satlins, tansig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Saturating linear transfer function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
satlins


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 903
 -- A = satlins (N, FP)
 -- A = satlins (N)
 -- INFO = satlins ('CODE')
     Symmetric saturating linear transfer function.

     Return a matrix of size equal to N, with values of -1 or 1 when N
     is less than -1 or larger than 1, and same values of N when N is
     between -1 and 1.

             / -1, if N < -1
             |  n, if -1 < N < 1
             \  1, if N > 1

     N is a S-by-Q matrix of input, while FP is a struct of function
     parameters, ignored by satlins

     You can retrieve some information about the transfer function
     passing a string as first argument:

     'satlins ('NAME')' returns the name of the transfer function

     'satlins ('OUTPUT')' returns the minimum and maximum of the output
     range

     'satlins ('ACTIVE')' returns the minimum and maximum of the active
     input range

     See also: hardlim, hardlims, logsig, poslin, purelin, tansig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Symmetric saturating linear transfer function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
saveMLPStruct


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 116
 -- Function File: saveMLPStruct (NET,STRFILENAME)
     'saveStruct' saves a neural network structure to *.txt files


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
'saveStruct' saves a neural network structure to *.txt files



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
sim


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 213
 -- Function File: NETOUTPUT = sim (NET, MINPUT)
     'sim' is usuable to simulate a before defined neural network.
     'net' is created with newff(...) and MINPUT should be the
     corresponding input data set!


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
'sim' is usuable to simulate a before defined neural network.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
subset


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1616
 -- Function File: [MTRAIN, MTEST, MVALI] = subset
          (MDATA,NTARGETS,IOPTI,FTEST,FVALI)
     'subset' splits the main data matrix which contains inputs and
     targets into 2 or 3 subsets depending on the parameters.

     The first parameter MDATA must be in row order.  This means if the
     network contains three inputs, the matrix must be have 3 rows and x
     columns to define the data for the inputs.  And some more rows for
     the outputs (targets), e.g.  a neural network with three inputs and
     two outputs must have 5 rows with x columns!  The second parameter
     NTARGETS defines the number or rows which contains the target
     values!  The third argument 'iOpti' is optional and can have three
     status: 0: no optimization 1: will randomise the column order and
     order the columns containing min and max values to be in the train
     set 2: will NOT randomise the column order, but order the columns
     containing min and max values to be in the train set default value
     is '1' The fourth argument 'fTest' is also optional and defines how
     much data sets will be in the test set.  Default value is '1/3' The
     fifth parameter 'fTrain' is also optional and defines how much data
     sets will be in the train set.  Default value is '1/6' So we have
     50% of all data sets which are for training with the default
     values.

            [mTrain, mTest] = subset(mData,1)
            returns three subsets of the complete matrix
            with randomized and optimized columns!
            [mTrain, mTest] = subset(mData,1,)
            returns two subsets


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
'subset' splits the main data matrix which contains inputs and targets
into 2 or



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
tansig


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 221
 -- Function File: A = tansig (N)
     'tansig' is a non-linear transfer function used to train neural
     networks.  This function can be used in newff(...)  to create a new
     feed forward multi-layer neural network.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 73
'tansig' is a non-linear transfer function used to train neural
networks.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
train


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 607
 -- Function File: [NET] = train (MLPNET,MINPUTN,MOUTPUT,[],[],VV)
     A neural feed-forward network will be trained with 'train'

          [net,tr,out,E] = train(MLPnet,mInputN,mOutput,[],[],VV);

          left side arguments:
            net: the trained network of the net structure MLPnet

          right side arguments:
            MLPnet : the untrained network, created with newff
            mInputN: normalized input matrix
            mOutput: output matrix (normalized or not)
            []     : unused parameter
            []     : unused parameter
            VV     : validize structure


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
A neural feed-forward network will be trained with 'train'



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
trastd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 437
 -- Function File: PN = trastd (P,MEANP,STDP)
     'trastd' preprocess additional data for neural network simulation.

            p    : test input data
            meanp: vector with standardization parameters of prestd(...)
            stdp : vector with standardization parameters of prestd(...)

            meanp = [2.5; 6.5];
            stdp = [1.2910; 1.2910];
            p = [1 4; 2 5];

            pn = trastd(p,meanp,stdp);


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 66
'trastd' preprocess additional data for neural network simulation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 7
vec2ind


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 383
 -- [IND,N] = vec2ind (VEC)
 -- IND = vec2ind (VEC)

     Convert a matrix of vectors into indices.

     VEC is a matrix with a 1 on each column.

     'vec2ind (IND, N)' will return 2 arguments: IND is a row vector
     containing for each column of VEC the index where the 1 is.  N is
     the number of rows in VEC.


          [ind, n] = vec2ind ([1 0 1; 0 1 0; 0 0 0; 0 0 0]);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 41
Convert a matrix of vectors into indices.





