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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1136
 -- [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: 860
 -- 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: 847
 -- 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: 620
 -- 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: 291
 -- 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
mapstd


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1271
 -- 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: 1701
 -- 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: 818
 -- 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: 543
 -- 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: 844
 -- 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: 151
 -- 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: 158
 -- 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: 683
 -- 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: 98
 -- 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: 880
 -- 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: 904
 -- 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: 117
 -- 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: 1630
 -- 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: 222
 -- 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: 612
 -- 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: 445
 -- 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: 382
 -- [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.





