# doc-cache created by Octave 4.0.3
# name: cache
# type: cell
# rows: 3
# columns: 4
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
base64decode


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 489
 -- Function File: RVAL = base64decode (CODE)
 -- Function File: RVAL = base64decode (CODE, AS_STRING)
     Convert a base64 CODE  (a string of printable characters according
     to RFC 2045) into the original ASCII data set of range 0-255. If
     option AS_STRING is passed, the return value is converted into a
     string.

          base64decode ('SGFrdW5hIE1hdGF0YQ==', true)
            => Hakuna Matata

     See: http://www.ietf.org/rfc/rfc2045.txt

     See also: base64encode.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Convert a base64 CODE  (a string of printable characters according to
RFC 2045) 



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
base64encode


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 638
 -- Function File: Y = base64encode (X)
 -- Function File: Y = base64encode (X, ROW_VECTOR)
     Convert X into string of printable characters according to RFC
     2045.

     The input may be a string or a matrix of integers in the range
     0..255.

     If want the output in the 1-row of strings format, pass the
     ROW_VECTOR argument as `true'.  Otherwise the output is a 4-row
     character matrix, which contains 4 encoded bytes in each column
     for each 3 bytes from the input.

     Example:
          base64encode ('Hakuna Matata', true)
            => SGFrdW5hIE1hdGF0YQ==

     See also: base64decode, base64_encode.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
Convert X into string of printable characters according to RFC 2045.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 838
 -- Function File: RVAL = cstrcmp (S1, S2)
     Compare strings S1 and S2 like the C function.

     Aside the difference to the return values, this function API is
     exactly the same as Octave's `strcmp' and will accept cell arrays
     as well.

     RVAL indicates the relationship between the strings:
        * A value of 0 indicates that both strings are equal;

        * A value of +1 indicates that the first character that does
          not match has a greater value in S1 than in S2.

        * A value of -1 indicates that the first character that does
          not match has a match has a smaller value in S1 than in S2.

          cstrcmp ("marry", "marry")
            =>  0
          cstrcmp ("marry", "marri")
            =>  1
          cstrcmp ("marri", "marry")
            => -1

     See also: strcmp, strcmpi.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 46
Compare strings S1 and S2 like the C function.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
editdistance


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1920
 -- Function File: [DIST, L] = editdistance (STR1, STR2)
 -- Function File: [DIST, L] = editdistance (STR1, STR2, WEIGHTS)
 -- Function File: [DIST, L] = editdistance (STR1, STR2, WEIGHTS, MODUS)
     Compute the Levenshtein edit distance between the two strings.

     The optional argument WEIGHTS specifies weights for the deletion,
     matched, and insertion operations; by default it is set to +1, 0,
     +1 respectively, so that a least editdistance means a closer match
     between the two strings. This function implements the Levenshtein
     edit distance as presented in Wikipedia article, accessed Nov
     2006. Also the levenshtein edit distance of a string with the
     empty string is defined to be its length.

     For the special case that there are no weights given and the array
     L is not requested, an algorithm of Berghel and Roach, which
     improves an algorithm introduced by Ukkonen in 1985, will be
     applied. This algorithm is significantly faster most of the times.
     Its main strength lies in cases with small edit distances, where
     huge speedups and memory savings are suspectible.  The time (and
     space) complexity is O(((dist^2 - (n - m)^2)/2) + dist), where n
     and m denote the length of both strings.

     The optional argument MODUS specifies the algorithm to be used. For
     MODUS = 0, Berghel and Roach's algorithm will be used whenever
     possible. For MODUS = 1, the classic algorithm by Fisher and Wagner
     will be used. If L is omitted, and MODUS = 1, a variant of Fisher
     and Wagner's algorithm using only a linear amount of memory with
     respect to the input length, but O(m*n) runtime, will be used.
     Again, n and m denote the length of both strings.

     The default return value DIST is the edit distance, and the other
     return value L is the distance matrix.

          editdistance ('marry', 'marie')
            =>  2



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Compute the Levenshtein edit distance between the two strings.





