# doc-cache created by Octave 4.4.1
# 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: 488
 -- 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) i



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 637
 -- 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: 835
 -- 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: 1923
 -- 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.





