# doc-cache created by Octave 11.3.0
# 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: 511
 -- 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.  Otherwise, the
     return value is a uint8 row vector.

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

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


# 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: 632
 -- 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: 810
 -- 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


# 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: 1912
 -- 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.





