Disponible uniquement en anglais
Sysquake Pro – Table of Contents
Sysquake for LaTeX – Table of Contents
String Functions
base32decode
Decode base32-encoded data.
Syntax
strb = base32decode(strt)
Description
base32decode(strt) decodes the contents of string strt which represents data encoded with base32. Characters which are not 'A'-'Z', '2'-'7', or '=' are ignored. Decoding stops at the end of the string or when '=' is reached.
See also
base32encode
Encode data using base32.
Syntax
strt = base32encode(strb)
Description
base32encode(strb) encodes the contents of string strb which represents binary data. The result contains only characters 'A'-'Z' and '2'-'7', and linefeed every 56 characters. It is suitable for transmission or storage on media which accept only uppercase letters and digits, without '0' or '1' easy to misinterpret as letters.
Each character of encoded data represents 5 bits of binary data; i.e. one needs eight characters for five bytes. The five bits represent 32 different values, encoded with the characters 'A' to 'Z' and '2' to '7' in this order. When the binary data have a length which is not a multiple of 5, encoded data are padded with 2, 3, 5 or 6 characters '=' to have a multiple of 8.
Base32 encoding is an Internet standard described in RFC 4648.
Example
s = base32encode(char(0:10)) s = AAAQEAYEAUDAOCAJBI====== d = double(base32decode(s)) d = 0 1 2 3 4 5 6 7 8 9 10
See also
base64decode
Decode base64-encoded data.
Syntax
strb = base64decode(strt)
Description
base64decode(strt) decodes the contents of string strt which represents data encoded with base64. Characters which are not 'A'-'Z', 'a'-'z', '0'-'9', '+', '/', or '=' are ignored. Decoding stops at the end of the string or when '=' is reached.
See also
base64encode
Encode data using base64.
Syntax
strt = base64encode(strb)
Description
base64encode(strb) encodes the contents of string strb which represents binary data. The result contains only characters 'A'-'Z', 'a'-'z', '0'-'9', '+', '/', and '='; and linefeed every 60 characters. It is suitable for transmission or storage on media which accept only text.
Each character of encoded data represents 6 bits of binary data; i.e. one needs four characters for three bytes. The six bits represent 64 different values, encoded with the characters 'A' to 'Z', 'a' to 'z', '0' to '9', '+', and '/' in this order. When the binary data have a length which is not a multiple of 3, encoded data are padded with one or two characters '=' to have a multiple of 4.
Base64 encoding is an Internet standard described in RFC 2045.
Example
s = base64encode(char(0:10)) s = AAECAwQFBgcICQo= double(base64decode(s)) 0 1 2 3 4 5 6 7 8 9 10
See also
char
Convert an array to a character array (string).
Syntax
s = char(A) S = char(s1, s2, ...)
Description
char(A) converts the elements of matrix A to characters, resulting in a string of the same size. Characters are stored in unsigned 16-bit words. The shape of A is preserved. Even if most functions ignore the string shape, you can force a row vector with char(A(:).').
char(s1,s2,...) concatenates vertically the arrays given as arguments to produce a string matrix. If the strings do not have the same number of columns, blanks are added to the right.
Examples
char(65:70) ABCDEF char([65, 66; 67, 68](:).') ABCD char('ab','cde') ab cde char('abc',['de';'fg']) abc de fg
See also
setstr, uint16, operator :, operator .', ischar, logical, double, single
deblank
Remove trailing blank characters from a string.
Syntax
s2 = deblank(s1)
Description
deblank(s1) removes the trailing blank characters from string s1. Blank characters are spaces (code 32), tabulators (code 9), carriage returns (code 13), line feeds (code 10), and null characters (code 0).
Example
double(' \tAB CD\r\n\0') 32 9 65 66 32 32 67 68 13 10 0 double(deblank(' \tAB CD\n\r\0'))) 32 9 65 66 32 32 67 68
See also
hmac
HMAC authentication hash.
Syntax
hash = hmac(hashtype, key, data) hash = hmac(hashtype, key, data, type=t)
Description
hmac(hashtype,key,data) calculates the authentication hash of data with secret key key and the method specified by hashtype: 'md5', 'sha1', 'sha224', 'sha256', 'sha384', or 'sha512'. Both arguments data and key can be strings (char arrays) which are converted to UTF-8, or int8 or uint8 arrays. The key can be up to 64 bytes; longer keys are truncated. The result is a string of hexadecimal digits whose length depends on the hash method, from 32 for HMAC-MD5 to 128 for HMAC-SHA512.
Named argument type can change the output type. It can be 'uint8' for an uint8 array of 16 or 20 bytes (raw HMAC-MD5 or HMAC-SHA1 hash result), 'hex' for its representation as a string of 32 or 40 hexadecimal digits (default), or base64 for its conversion to Base64 in a string of 24 or 28 characters.
HMAC is an Internet standard described in RFC 2104.
Examples
HMAC-MD5 of 'Authenticated message' using secret key 'secret':
hmac('md5', 'secret', 'Authenticated message') 4f557b1f67bc4790e6e9568e2f458cf0
Same result computed explicitly, with the notations of RFC 2104: B is the block length, L is the hash length (16 for HMAC-MD5 or 20 for HMAC-SHA1), K is the key padded with zeros to have size B, and H is the hash function, defined here to produce a uint8 hash instead of an hexadecimal string like the LME functions md5 or sha1.
B = 64; L = 16; H = @(a) uint8(sscanf(md5(a), '%2x')'); key = uint8('secret'); data = uint8('Authenticated message'); K = [key, zeros(1, B - length(key), 'uint8')]; hash = H([bitxor(K, 0x5cuint8), H([bitxor(K, 0x36uint8), data])]); sprintf('%.2x', hash)
Simple implementation of the HOTP and TOTP password algorithms (RFC 4226 and 6238) often used for two-factor authentication, with their default parameter values. The password is assumed to be base32-encoded.
function n = hotp(pass, cnt) k = uint8(base32decode(pass)); c = bwrite(cnt, 'uint64;b'); // or c=bwrite([floor(c/2^32),mod(c,2^32)],'uint32;b'); hs = hmac('sha1', k, c, type='uint8'); ob = mod(hs(20), 16); dt = mod(sread(hs(ob + (1:4)), [], 'uint32;b'), 2^31); n = mod(dt, 1e6); function n = totp(pass) t = floor(posixtime / 30); n = hotp(pass, t);
Simple implementation of the PBKDF2 key stretching algorithm (RFC 2898):
function dk = pbkdf2_hmac(hashtype, p, salt, c, dkLen) hLen = length(hmac(hashtype, '', '')) / 2; dk = uint8([]); for i = 1:ceil(dkLen / hLen) u = hmac(hashtype, p, [salt, bwrite(i, 'uint32;b')], type='uint8'); f = u; for j = 2:c u = hmac(hashtype, p, u, type='uint8'); f = bitxor(f, u); end dk = [dk, f]; end dk = dk(1:dkLen);
Test of PBKDF2-HMAC-SHA1 with values provided in RFC 6070 (output format is switched to hexadecimal for easier comparison):
format int x pbkdf2_hmac_sha1('sha1', 'password', 'salt', 4096, 20) 0x4b 0x0 0x79 0x1 0xb7 0x65 0x48 0x9a 0xbe 0xad 0x49 0xd9 0x26 0xf7 0x21 0xd0 0x65 0xa4 0x29 0xc1 format
See also
ischar
Test for a string object.
Syntax
b = ischar(obj)
Description
ischar(obj) is true if the object obj is a character string, false otherwise. Strings can have more than one line.
Examples
ischar('abc') true ischar(0) false ischar([]) false ischar('') true ischar(['abc';'def']) true
See also
isletter, isspace, isnumeric, islogical, isinteger, islist, isstruct, setstr, char
isdigit
Test for decimal digit characters.
Syntax
b = isdigit(s)
Description
For each character of string s, isdigit(s) is true if it is a digit ('0' to '9') and false otherwise. The result is a logical array with the same size as the input argument.
Examples
isdigit('a123bAB12* ') F T T T F F F T T F F
See also
isletter, isspace, lower, upper, ischar
isletter
Test for letter characters.
Syntax
b = isletter(s)
Description
For each character of string s, isletter(s) is true if it is an ASCII letter (a-z or A-Z) and false otherwise. The result is a logical array with the same size as the input argument.
isletter gives false for letters outside the 7-bit ASCII range; unicodeclass should be used for Unicode-aware tests.
Examples
isletter('abAB12*') T T T T F F F F
See also
isdigit, isspace, lower, upper, ischar, unicodeclass
isspace
Test for space characters.
Syntax
b = isspace(s)
Description
For each character of string s, isspace(s) is true if it is a space, a tabulator, a carriage return or a line feed, and false otherwise. The result is a logical array with the same size as the input argument.
Example
isspace('a\tb c\nd') F T F T F T F
See also
latex2mathml
Convert LaTeX equation to MathML.
Syntax
str = latex2mathml(tex) str = latex2mathml(tex, mml1, mml2, ...) str = latex2mathml(..., displaymath=b)
Description
latex2mathml(tex) converts LaTeX equation in string tex to MathML. LaTeX equations may be enclosed between dollars or double-dollars, but this is not mandatory. In string literals, backslash and tick characters must be escaped as \\ and \' respectively.
With additional arguments, which must be strings containing MathML, parameters #1, #2, ... in argument tex are converted to argument i+1.
The following LaTeX features are supported:
- variables (each letter is a separate variable)
- numbers (sequences of digit and dot characters)
- superscripts and subscripts, prime (single or multiple)
- braces used to group subexpressions or specify arguments with more than one token
- operators (+, -, comma, semicolon, etc.)
- control sequences for character definitions, with greek characters in lower case (\alpha, ..., \omega, \varepsilon, \vartheta, \varphi) and upper case (\Alpha, ..., \Omega), arrows (\leftarrow or \gets, \rightarrow or \to, \uparrow, \downarrow, \leftrightarrow, \updownarrow, \Leftarrow, \Rightarrow, \Uparrow, \Downarrow, \Leftrightarrow, \Updownarrow, nwarrow, nearrow, searrow, swarrow, mapsto, hookleftarrow, hookrightarrow, Longleftrightarrow, longmapsto), and symbols (\|, \ell, \partial, \infty, \emptyset, \nabla, \perp, \angle, \triangle, \backslash, \forall, \exists, \flat, \natural, \sharp, \pm, \mp, \cdot, \times, \star, \diamond, \cap, \cup, etc.)
- \not followed by comparison operator, such as \not< or \not\approx
- control sequences for function definitions (\arccos, \arcsin, \arctan, \arg, \cos, \cosh, \cot, \coth, \csc, \deg, \det, \dim, \exp, \gcd, \hom, \inf, \injlim, \ker, \lg, \liminf, \limsup, \ln, \log, \max, \min, \Pr, \projlim, \sec, \sin, \sinh, \sup, \tan, \tanh) and custom functions with operatorname
- accents (\hat, \check, \tilde, \acute, grave, \dot, \ddot, \dddot, breve, \bar, \vec, \overline, \widehat, \widetilde, \underline)
- \left and \right
- fractions with \frac or \over
- roots with \sqrt (without optional radix) or \root...\of...
- \atop, \overset, and \underset
- large operators (\bigcap, \bigcup, \bigodot, \bigoplus, \bigotimes, \bigsqcup, \biguplus, \bigvee, \bigwedge, \coprod, \prod, and \sum with implicit \limits for limits below and above the symbol; and \int, \iint, \iiint, \iiiint, \oint, and \oiint with implicit \nolimits for limits to the right of the symbol)
- \limits and \nolimits for functions and large operators
- matrices with \matrix, \pmatrix, \bmatrix, \Bmatrix, \vmatrix, \Vmatrix, \begin{array}{...}.../\end{array}; values are separated with & and rows with \cr or \\
- font selection with \rm for roman, \bf for bold face, and \mit for math italic
- color with \color{c} where c is black, red, green, blue, cyan, magenta, yellow, white, orange, violet, purple, brown, darkgray, gray, or lightgray
- hidden element with \phantom
- text with \hbox{...} (brace contents is taken verbatim)
- horizontal spaces with \, \: \; \quad \qquad and \!
LaTeX features not enumerated above, such as definitions and nested text and equations, are not supported.
latex2mathml has also features which are missing in LaTeX. Unicode is used for both LaTeX input and MathML output. Some semantics is recognized to build subexpressions which are revealed in the resulting MathML. For instance, in x+(y+z)w, (y+z) is a subpexpressions; so is (y+z)w with an implicit multiplication (resulting in the <mo>⁢<mo> MathML operator), used as the second operand of the addition. LaTeX code (like mathematical notation) is sometimes ambiguous and is not always converted to the expected MathML (e.g. a(b+c) is converted to a function call while the same notation could mean the product of a and b+c), but this should not have any visible effect when the MathML is typeset.
Operators can be used as freely as in LaTeX. Missing operands result in <none/>, as if there were an empty pair of braces {}. Consecutive terms are joined with implicit multiplications.
Named argument displaymath specifies whether the vertical space is tight, like in inline equations surrounded by text (false), or unconstrained, as rendered in separate lines (true). It affects the position of some limits. The default is true.
Examples
latex2mathml('xy^2') <mrow><mi>x</mi><mo>⁢</mo><msup><mi>y</mi><mn>2</mn></msup></mrow> mml = latex2mathml('\\frac{x_3+5}{x_1+x_2}'); mml = latex2mathml('$\\root n \\of x$'); mml = latex2mathml('\\pmatrix{x & \\sqrt y \\cr \\sin\\phi & \\hat\\ell}'); mml = latex2mathml('\\dot x = #1', mathml([1,2;3,0], false)); mml = latex2mathml('\\lim_{x \\rightarrow 0} f(x)', displaymath=true) mml = latex2mathml('\\lim_{x \\rightarrow 0} f(x)', displaymath=false)
See also
lower
Convert all uppercase letters to lowercase.
Syntax
s2 = lower(s1)
Description
lower(s1) converts all the uppercase letters of string s1 to lowercase, according to the Unicode Character Database.
Example
lower('abcABC123') abcabc123
See also
mathml
Conversion to MathML.
Syntax
str = mathml(x) str = mathml(x, false) str = mathml(..., Format=f, NPrec=n)
Description
mathml(x) converts its argument x to MathML presentation, returned as a string.
By default, the MathML top-level element is <math>. If the result is to be used as a MathML subelement of a larger equation, a second input argument equal to the logical value false can be specified to suppress <math>.
By default, mathml converts numbers like format '%g' of sprintf. Named arguments can override them: Format is a single letter format recognized by sprintf and NPrec is the precision (number of decimals).
Example
mathml(pi) <math> <mn>3.1416</mn> </math> mathml(1e-6, Format='e', NPrec=2) <math> <mrow><mn>1.00</mn><mo>·</mo><msup><mn>10</mn><mn>-6</mn></msup></mrow> </math>
See also
mathmlpoly, latex2mathml, sprintf
mathmlpoly
Conversion of a polynomial to MathML.
Syntax
str = mathmlpoly(pol) str = mathmlpoly(pol, var) str = mathmlpoly(..., power) str = mathmlpoly(..., false) str = mathmlpoly(..., Format=f, NPrec=n)
Description
mathmlpoly(coef) converts polynomial coefficients pol
to MathML presentation, returned as a string. The polynomial is given as a vector of
coefficients, with the highest power first; e.g.,
By default, the name of the variable is x. An optional second argument can specify another name as a string, such as 'y', or a MathML fragment beginning with a less-than character, such as '<mn>3</mn>'.
Powers can be specified explicitly with an additional argument, a vector which must have the same length as the polynomial coefficients. Negative and fractional numbers are allowed; the imaginary part, if any, is ignored.
By default, the MathML top-level element is <math>. If the result is to be used as a MathML subelement of a larger equation, an additional input argument (the last unnamed argument) equal to the logical value false can be specified to suppress <math>.
Named arguments format and NPrec have the same effect as with mathml.
Examples
Simple third-order polynomial:
mathmlpoly([1,2,5,3])
Polynomial with negative powers of variable q:
c = [1, 2.3, 4.5, -2]; mathmlpoly(c, 'q', -(0:numel(c)-1))
Rational fraction:
str = sprintf('<mfrac>%s%s</mfrac>', mathmlpoly(num, false), mathmlpoly(den, false));
See also
md5
Calculate MD5 digest.
Syntax
digest = md5(strb) digest = md5(fd) digest = md5(..., type=t)
Description
md5(strb) calculates the MD5 digest of strb which represents binary data. strb can be a string (only the least-significant byte of each character is considered) or an array of bytes of class uint8 or int8. The result is a string of 32 hexadecimal digits. It is believed to be hard to create the input to get a given digest, or to create two inputs with the same digest.
md5(fd) calculates the MD5 digest of the bytes read from file descriptor fd until the end of the file. The file is left open.
Named argument type can change the output type. It can be 'uint8' for an uint8 array of 16 bytes (raw MD5 hash result), 'hex' for its representation as a string of 32 hexadecimal digits (default), or base64 for its conversion to Base64 in a string of 24 characters.
MD5 digest is an Internet standard described in RFC 1321.
Examples
MD5 of the three characters 'a', 'b', and 'c':
md5('abc') 900150983cd24fb0d6963f7d28e17f72
This can be compared to the result of the command tool md5 found on many unix systems:
$ echo -n abc | md5 900150983cd24fb0d6963f7d28e17f72
The following statements calculate the digest of the file 'somefile':
fd = fopen('somefile'); digest = md5(fd); fclose(fd);
See also
regexp regexpi
Regular expression match.
Syntax
(startIx, endIx, length, grExt) = regexp(str, re) (startIx, endIx, grExt) = regexpi(str, re)
Description
regexp(str,re) matches regular expression re in string str. A regular expression is a string which contains meta-characters to match classes of characters, repetitions and alternatives, as described below.
Once a match is found, the remaining part of str is parsed from the end of the previous match to find more matches. The result of regexp is an array of start indices in str and an array of corresponding end indices. Empty matches have a length endIx-startIx-1=0.
The third output argument, if present, is set to a list whose items correspond to matches. Items are arrays of size 2-by-ng. Each row corresponds to a group, i.e. a subexpression in parentheses in the regular expression; the first column contains the index of the first character in str and the second column contains the index of the last character.
regexpi is similar to regexp, except that letter case is ignored.
The following regular expression elements are recognized:
- Any character other than those described below
- Literal match.
- . (dot)
- Any character.
- \0
- Nul (0).
- \t
- Tab (9).
- \n
- Newline (10).
- \v
- Vertical tab (11).
- \f
- Form feed (12).
- \r
- Carriage return (13).
- \P where P is one of \()[]{}?*+/
- P
- \xNN
- Character whose code is NN in hexadecimal.
- \uNNNN
- Character whose code is NNNN in hexadecimal.
- [...]
- Any of the characters in brackets. Characters can be enumarated (e.g. [ax2] to match a, x or 2), provided as ranges with a hyphen (e.g. [a-c] to match a, b or c) or any combination. Caret ^ must not appear first; closing bracket ] must appear first; and hyphen must not be used in a way which could be interpreted as a range.
- [^...]
- Any character not enumated in brackets (e.g. [^a-z] for any character except for lowercase letters).
- AB
- Catenation of A and B.
- A|B
- One of A or B. | has the lowest priority: ab|c matches ab or c.
- A?
- A (if possible) or nothing.
- A*
- As many repetitions of A as possible, including none.
- A+
- As many repetitions of A as possible, at least one.
- A{n}
- Exactly n repetitions of A.
- A{n,}
- At least n repetitions of A (as many as possible).
- A{n,m}
- Between n and m repetitions of A (as many as possible).
- A??
- Nothing (if possible) or A.
- A*?
- As few repetitions of A as possible, including none.
- A+?
- As few repetitions of A as possible, at least one.
- A{n,}?
- At least n repetitions of A (as few as possible).
- A{n,m}?
- Between n and m repetitions of A (as few as possible).
- A?+, A*?, A++, A{...}+
- Possessive repetitions: as many as possible, but once the maximum number has been found, does not try less repetitions should the remaining part of the regular expression fail to match anything.
- (A)
- Group; matches subexpression A, which is captured for further reference as \N.
- (?:A)
- Group without capture; just matches subexpression A.
- \N where N is a digit from 1 to 9
- Character substring which was matched by the N:th group delimited by parentheses.
- ^
- Matches beginning of string.
- $
- Matches end of string.
- \b
- Beginning or end of word.
- (?=A)
- Positive lookahead: succeeds if what follows matches A without consuming A.
- (?!A)
- Negative lookahead: succeeds if what follows does not match A without consuming A.
- (?# comment)
- Comment (ignored).
- \d
- Digit (can be used inside or outside brackets).
- \D
- Not a digit (can be used inside or outside brackets).
- \s
- White space (can be used inside or outside brackets).
- \S
- Not white space (can be used inside or outside brackets).
- \w
- Alphanumeric (can be used inside or outside brackets).
- \W
- Not alphanumeric (can be used inside or outside brackets).
- [:alnum:]
- Same as A-Za-z0-9 (must be used inside brackets, e.g. [[:alnum:]])
- [:alpha:]
- Same as A-Za-z (must be used inside brackets, e.g. [[:alpha:]])
- [:blank:]
- Same as \x20\x09, i.e. space or tab (must be used inside brackets, e.g. [[:blank:]])
- [:cntrl:]
- Same as \0-\x1f (must be used inside brackets, e.g. [[:cntrl:]])
- [:digit:]
- Same as 0-9 (must be used inside brackets, e.g. [[:digit:]])
- [:graph:]
- Same as \x21-\x7e, i.e. ASCII characters without space and control characters (must be used inside brackets, e.g. [[:graph:]])
- [:lower:]
- Same as a-z (must be used inside brackets, e.g. [^[:lower:][:digit:]] which is equivalent to [^a-z0-9])
- [:print:]
- Same as \x20-\x7e, i.e. ASCII characters without control characters (must be used inside brackets, e.g. [[:print:]])
- [:punct:]
- Same as !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ (must be used inside brackets, e.g. [[:punct:]])
- [:space:]
- Same as \x20\x09\x0a\x0c\x0d or \s (must be used inside brackets, e.g. [[:space:]])
- [:upper:]
- Same as A-Z (must be used inside brackets, e.g. [[:upper:]])
- [:word:]
- Same as [:alnum:]_ (must be used inside brackets, e.g. [[:word:]])
- [:xdigit:]
- Same as 0-9A-Fa-f (must be used inside brackets, e.g. [[:xdigit:]])
Quantifiers ?, * and +, and their lazy and possessive versions (suffixed with ? or + respectively) have the highest priority. Priority can be changed with parentheses, e.g. (abc)* or (a|bc)d.
Examples
Simple match without metacharacter:
(startIx, endIx) = regexp('Some random string', 'om') startIx = 2 10 endIx = 3 11
Dot to match any character:
regexp('Some random string', 'S..e') 1
Anchor to end of string:
regexp('Some random string', '..$') 17
Repetition:
regexp('Some random string', 'r.*m') 6
By default, repetitions are greedy (as many as possible):
(startIx, endIx) = regexp('Some random string', '.*m') startIx = 1 endIx = 11
Lazy repetition (as few as possible):
(startIx, endIx) = regexp('Some random string', '.*?m') startIx = 1 4 endIx = 3 11
Possessive repetitions keep the largest number of repetitions which provides a match regardless of subsequent failures:
(startIx, endIx) = regexp('Some random string', '.*m ') startIx = 1 endIx = 12 (startIx, endIx) = regexp('Some random string', '.*+m ') startIx = [] endIx = []
Since backslash is an escape character in LME strings, it must be escaped itself:
(startIx, endIx) = regexp('Some random string', '\\b\\w.+?\\b') startIx = 1 6 13 endIx = 4 11 18
Reference to a captured group:
(startIx, endIx) = regexp('xx-ab-ab', '(.+)-\\1') startIx = 4 endIx = 8
Positive lookahead to find words followed by a colon without picking the colon itself:
(startIx, endIx) = regexp('mailto:foo@example.com', '\\b\\w+(?=:)') startIx = 1 endIx = 6
Group (the extent of the whole match is ignored using placeholder output arguments ~):
(~, ~, grExt) = regexp('Regexp are fun', '\\b(\\w+)\\s+(\\w+)\\s+(\\w+)\\b'); grExt{1} 1 6 8 10 12 14
Match ignoring case:
regexpi('Some random string', 'some') 1
Case-explicit character classes are still case-significant, but character enumerations or ranges are not:
regexpi('Some random string', '^[[:lower:]]') [] regexpi('Some random string', '^[a-z]') 1
See also
setstr
Conversion of an array to a string.
Syntax
str = setstr(A)
Description
setstr(A) converts the elements of array A to characters, resulting in a string of the same size. Characters are stored in unsigned 16-bit words.
Example
setstr(65:75) ABCDEFGHIJK
See also
sha1 sha2
Calculate SHA-1 or SHA-2 digest.
Syntax
digest = sha1(strb) digest = sha1(fd) digest = sha1(..., type=t) digest = sha2(...) digest = sha2(..., variant=v)
Description
sha1(strb) calculates the SHA-1 digest of strb which represents binary data. strb can be a string (only the least-significant byte of each character is considered) or an array of bytes of class uint8 or int8. The result is a string of 40 hexadecimal digits. It is believed to be hard to create the input to get a given digest, or to create two inputs with the same digest.
sha1(fd) calculates the SHA-1 digest of the bytes read from file descriptor fd until the end of the file. The file is left open.
Named argument type can change the output type. It can be 'uint8' for an uint8 array of 20 bytes (raw SHA-1 hash result), 'hex' for its representation as a string of 40 hexadecimal digits (default), or base64 for its conversion to Base64 in a string of 28 characters.
SHA-1 digest is an Internet standard described in RFC 3174.
sha2 calculates the SHA-256 digest, a 256-bit variant of the SHA-2 hash algorithm. Its arguments are the same as those of sha1. In addition, named argument variant can specify one of the supported SHA-2 variants: 224, 256 (default), 384, or 512.
Example
SHA-1 digest of the three characters 'a', 'b', and 'c':
sha1('abc') a9993e364706816aba3e25717850c26c9cd0d89d
SHA-224 digest of the empty message '':
sha2('', variant=224) d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f
See also
split
Split a string.
Syntax
L = split(string, separator)
Description
split(string,separator) finds substrings of string separated by separator and return them as a list. Empty substring are discarded. sepatator is a string of one or more characters.
Examples
split('abc;de;f', ';') {'abc', 'de', 'f'} split('++a+++b+++','++') {'a', '+b', '+'}
See also
strcmp
String comparison.
Syntax
b = strcmp(s1, s2) b = strcmp(s1, s2, n)
Description
strcmp(s1, s2) is true if the strings s1 and s2 are equal (i.e. same length and corresponding characters are equal). strcmp(s1, s2, n) compares the strings up to the n:th character. Note that this function does not return the same result as the strcmp function of the standard C library.
Examples
strcmp('abc','abc') true strcmp('abc','def') false strcmp('abc','abd',2) true strcmp('abc','abd',5) false
See also
strcmpi, operator ===, operator ~==, operator ==, strfind, strmatch
strcmpi
String comparison with ignoring letter case.
Syntax
b = strcmpi(s1, s2) b = strcmpi(s1, s2, n)
Description
strcmpi compares strings for equality, ignoring letter case. In every other respect, it behaves like strcmp.
Examples
strcmpi('abc','aBc') true strcmpi('Abc','abd',2) true
See also
strcmp, operator ===, operator ~==, operator ==, strfind, strmatch
strfind
Find a substring in a string.
Syntax
pos = strfind(str, sub)
Description
strfind(str,sub) finds occurrences of string sub in string str and returns a vector of the positions of all occurrences, or the empty vector [] if there is none. Occurrences may overlap.
Examples
strfind('ababcdbaaab','ab') 1 3 10 strfind('ababcdbaaab','ac') [] strfind('aaaaaa','aaa') 1 2 3
See also
find, strcmp, strrep, split, strmatch, strtok
strmatch
String match.
Syntax
i = strmatch(str, strMatrix) i = strmatch(str, strList) i = strmatch(..., 'exact')
Description
strmatch(str,strMatrix) compares string str with each row of the character matrix strMatrix; it returns the index of the first row whose beginning is equal to str, or 0 if no match is found. Case is significant.
strmatch(str,strList) compares string str with each element of list or cell array strList, which must be strings.
With a third argument, which must be the string 'exact', str must match the complete row or element of the second argument, not only the beginning.
Examples
strmatch('abc',['axyz';'uabc';'abcd';'efgh']) 3 strmatch('abc',['axyz';'uabc';'abcd';'efgh'],'exact') 0 strmatch('abc',{'ABC','axyz','abcdefg','ab','abcd'}) 3
See also
strrep
Replace a substring in a string.
Syntax
newstr = strrep(str, sub, repl)
Description
strrep(str,sub,repl) replaces all occurrences of string sub in string str with string repl.
Examples
strrep('ababcdbaaab','ab','X') 'XXcdbaaX' strrep('aaaaaaa','aaa','12345') '1234512345a'
See also
strfind, strcmp, strmatch, strtok
strtok
Token search in string.
Syntax
(token, remainder) = strtok(str) (token, remainder) = strtok(str, separators)
Description
strtok(str) gives the first token in string str. A token is defined as a substring delimited by separators or by the beginning or end of the string; by default, separators are spaces, tabulators, carriage returns and line feeds. If no token is found (i.e. if str is empty or contains only separator characters), the result is the empty string.
The optional second output is set to what follows immediately the token, including separators. If no token is found, it is the same as str.
An optional second input argument contains the separators in a string.
Examples
Strings are displayed with quotes to show clearly the separators.
strtok(' ab cde ') 'ab' (t, r) = strtok(' ab cde ') t = 'ab' r = ' cde ' (t, r) = strtok('2, 5, 3') t = '2' r = ', 5, 3'
See also
strtrim
Remove leading and trailing blank characters from a string.
Syntax
s2 = strtrim(s1)
Description
strtrim(s1) removes the leading and trailing blank characters from string s1. Blank characters are spaces (code 32), tabulators (code 9), carriage returns (code 13), line feeds (code 10), and null characters (code 0).
Example
double(' \tAB CD\r\n\0') 32 9 65 66 32 32 67 68 13 10 0 double(strtrim(' \tAB CD\n\r\0'))) 65 66 32 32 67 68
See also
unicodeclass
Unicode character class.
Syntax
cls = unicodeclass(c)
Description
unicodeclass(c) gives the Unicode character class (General_Category property in the Unicode Character Database) of its argument c, which must be a single-character string. The result is one of the following two-character strings:
Class | Description | Class | Description |
---|---|---|---|
'Lu' | Letter, Uppercase | 'Pi' | Punctuation, Initial qupte |
'Ll' | Letter, Lowercase | 'Pf' | Punctuation, Final Quote |
'Lt' | Letter, Titlecase | 'Po' | Punctuation, Other |
'Lm' | Letter, Modifier | 'Sm' | Symbol, Math |
'Lo' | Letter, Other | 'Sc' | Symbol, Currency |
'Mn' | Mark, Non-Spcacing | 'Sk' | Symbol, Modifier |
'Mc' | Mark, Spacing Combining | 'So' | Symbol, Other |
'Me' | Mark, Enclosing | 'Zs' | Separator, Spcace |
'Nd' | Number, Decimal Digit | 'Zl' | Separator, Line |
'Nl' | Number, Letter | 'Zp' | Separator, Paragraph |
'No' | Number, Other | 'Cc' | Other, Control |
'Pc' | Punctuation, Connector | 'Cf' | Other, Format |
'Pd' | Punctuation, Dash | 'Cs' | Other, Surrogate |
'Ps' | Punctuation, Open | 'Co' | Other, Private Use |
'Pe' | Punctuation, Close | 'Cn' | Other, Not Assigned |
See also
upper
Convert all lowercase letters to lowercase.
Syntax
s2 = upper(s1)
Description
upper(s1) converts all the lowercase letters of string s1 to uppercase, according to the Unicode Character Database.
Example
upper('abcABC123') ABCABC123
See also
utf32decode
Decode Unicode characters encoded with UTF-32.
Syntax
str = utf32decode(b)
Description
utf32decode(b) decodes the contents of uint32 or int32 array b which represents Unicode characters encoded with UTF-32 (basically, Unicode code point). The result is a standard character array with a single row, usually encoded with UTF-16. Invalid codes are ignored.
If all the codes in b correspond to the Basic Multilingual Plane (16-bits, and not surrogate 0xd800-0xdfff), the result is equivalent to char(b).
See also
utf32encode
Encode a string of Unicode characters using UTF-32.
Syntax
b = utf32encode(str)
Description
utf32encode(str) encodes the contents of character array str using UTF-32. Each Unicode character in str, made of 1 or 2 UTF-16 words, corresponds to one UTF-32 code. The result is an array of unsigned 32-bit integers.
If all the characters in str correspond to the Basic Multilingual Plane (16-bits, and no surrogate pairs), the result is equivalent to uint32(str).
Examples
utf32encode('abc') 1x3 uint32 array 97 98 99 str = utf32decode(65872uint32); double(str) 55296 56656 utf32encode(str) 65872uint32
See also
utf8decode
Decode Unicode characters encoded with UTF-8.
Syntax
str = utf8decode(b)
Description
utf8decode(b) decodes the contents of uint8 or int8 array b which represents Unicode characters encoded with UTF-8. Each Unicode character corresponds to up to 4 bytes of UTF-8 code. The result is a standard character array with a single row; characters are usually encoded as UTF-16, with 1 or 2 words per character. Invalid codes (for example when the beginning of the decoded data does not correspond to a character boundary) are ignored.
See also
utf8encode
Encode a string of Unicode characters using UTF-8.
Syntax
b = utf8encode(str)
Description
utf8encode(str) encodes the contents of character array str using UTF-8. Each Unicode character in str corresponds to up to 4 bytes of UTF-8 code. The result is an array of unsigned 8-bit integers.
If the input string does not contain Unicode characters, the output is invalid.
Example
b = utf8encode(['abc', 200, 2000, 20000]) b = 1x10 uint8 array 97 98 99 195 136 223 144 228 184 160 str = utf8decode(b); double(str) 97 98 99 200 2000 20000