虽然这些都是在帮助上找到的（如help num2hex），但有些人不懂MATLAB会有这些功能，而不懂得充分利用，所以贴出来共享,对于用FPGA做数字信号处理非常有效！
BIN2NUM Binary string to numeric array conversion
X = BIN2NUM(Q,B) converts binary string B to numeric matrix X. The
attributes of the number are specified by quantizer object Q. If B is a
cell array containing binary strings, then X will be a cell array of the
same dimension containing numeric matrices. The fixed-point binary
representation is two's complement. The floating-point binary
representation is IEEE style.
If there are fewer binary digits than are necessary to represent the number,
then fixed-point zero-pads on the left, and floating-point zero-pads on the
right.
[X1,X2,...] = BIN2NUM(Q,B1,B2,...) converts binary strings B1, B2,... to
numeric matrices X1, X2, ....
BIN2NUM and NUM2BIN are inverses of each other, except that NUM2BIN
always returns a column.
For example, all of the 3-bit fixed-point two's-complement numbers in
fractional form are given by:
q = quantizer([3 2]);
b = ['011 111'
'010 110'
'001 101'
'000 100'];
x = bin2num(q,b)
x =
0.7500 -0.2500
0.5000 -0.5000
0.2500 -0.7500
0 -1.0000
///////////////////////////////////////////////////////////////////////////
NUM2BIN Number to binary string
B = NUM2BIN(Q,X) converts numeric matrix X to binary string B. The
attributes of the number are specified by quantizer object Q. If X
is a cell array containing numeric matrices, then B will be a cell
array of the same dimension containing binary strings. The
fixed-point binary representation is two's complement. The
floating-point binary representation is IEEE style.
[B1,B2,...] = NUM2BIN(Q,X1,X2,...) converts numeric matrices X1, X2,
... to binary strings B1, B2, ....
NUM2BIN and BIN2NUM are inverses of each other, except that NUM2BIN
always returns a column.
For example, all of the 3-bit fixed-point two's complement numbers in
fractional form are given by:
q = quantizer([3 2]);
x = [0.75 -0.25
0.50 -0.50
0.25 -0.75
0 -1 ];
b = num2bin(q,x)
b =
011
010
001
000
111
110
101
100
///////////////////////////////////////////////////////////////////
HEX2BIN Convert hexadecimal strings to binary strings
B = HEX2BIN(Q,H) converts hexadecimal strings vectorized in a column H to
binary strings B. The wordlength is derived from quantizer Q. This is a
private function that is used by NUM2BIN.
Example:
q = quantizer('fixed',[8 7]);
h = ['ff'; 'fe'];
b = hex2bin(q,h)
b =
11111111
11111110
////////////////////////////////////////////////////////////////////////
NUM2HEX Number to hexadecimal string
H = NUM2HEX(Q,X) converts numeric matrix X to hexadecimal string H.
The attributes of the number are specified by Quantizer object Q.
If X is a cell array containing numeric matrices, then H will be a
cell array of the same dimension containing hexadecimal strings.
The fixed-point hexadecimal representation is two's complement. The
floating-point hexadecimal representation is IEEE style.
[H1,H2,...] = NUM2HEX(Q,X1,X2,...) converts numeric matrices X1, X2,
... to hexadecimal strings H1, H2, ....
NUM2HEX and HEX2NUM are inverses of each other, except that NUM2HEX
always returns a column.
For example, all of the 4-bit fixed-point two's complement numbers in
fractional form are given by:
q = quantizer([4 3]);
x = [0.875 0.375 -0.125 -0.625
0.750 0.250 -0.250 -0.750
0.625 0.125 -0.375 -0.875
0.500 0 -0.500 -1.000];
h = num2hex(q,x)
h =
7
6
5
4
3
2
1
0
f
e
d
c
b
a
9
8
//////////////////////////////////////////////////////////////////
HEX2NUM Hexadecimal string to numeric array conversion
X = HEX2NUM(Q,H) converts hexadecimal string H to numeric matrix X.
The attributes of the number are specified by quantizer object Q.
If H is a cell array containing hexadecimal strings, then X will be
a cell array of the same dimension containing numeric matrices.
The fixed-point hexadecimal representation is two's complement. The
floating-point hexadecimal representation is IEEE style.
If there are fewer hex digits than are necessary to represent the
number, then fixed-point zero-pads on the left, and floating-point
zero-pads on the right.
[X1,X2,...] = HEX2NUM(Q,H1,H2,...) converts hexadecimal strings H1,
H2, ... to numeric matrices X1, X2, ....
HEX2NUM and NUM2HEX are inverses of each other, except that NUM2HEX
always returns a column.
For example, all of the 4-bit fixed-point two's complement numbers in
fractional form are given by:
q = quantizer([4 3]);
h = ['7 3 F B'
'6 2 E A'
'5 1 D 9'
'4 0 C 8'];
x = hex2num(q,h)
x =
0.8750 0.3750 -0.1250 -0.6250
0.7500 0.2500 -0.2500 -0.7500
0.6250 0.1250 -0.3750 -0.8750
0.5000 0 -0.5000 -1.0000
///////////////////////////////////////////////////////////////////////////////////
HEX2NUM Convert IEEE hexadecimal string to double precision number.
HEX2NUM(S), where S is a 16 character string containing
a hexadecimal number, returns the IEEE double precision
floating point number it represents. Fewer than 16
characters are padded on the right with zeros.
If S is a character array, each row is interpreted as a double
precision number.
NaNs, infinities and denorms are handled correctly.
Example:
hex2num('400921fb54442d18') returns Pi.
hex2num('bff') returns -1.
////////////////////////////////////////////////////////////////////
NUM2HEX Convert singles and doubles to IEEE hexadecimal strings.
If X is a single or double precision array with n elements,
NUM2HEX(X) is an n-by-8 or n-by-16 char array of the hexadecimal
floating point representation. The same representation is printed
with FORMAT HEX.
Examples:
num2hex([1 0 0.1 -pi Inf NaN]) is
3ff0000000000000
0000000000000000
3fb999999999999a
c00921fb54442d18
7ff0000000000000
fff8000000000000
num2hex(single([1 0 0.1 -pi Inf NaN])) is
3f800000
00000000
3dcccccd
c0490fdb
7f800000
ffc00000
////////////////////////////////////////////////////////////
DEC2HEX Convert decimal integer to hexadecimal string.
DEC2HEX(D) returns a 2-D string array where each row is the
hexadecimal representation of each decimal integer in D.
D must contain non-negative integers smaller than 2^52.
DEC2HEX(D,N) produces a 2-D string array where each
row contains an N digit hexadecimal number.
Example
dec2hex(2748) returns 'ABC'.
/////////////////////////////////////////////////////////////////
HEX2DEC Convert hexadecimal string to decimal integer.
D = HEX2DEC(H) interprets the hexadecimal string H and returns in D the
equivalent decimal number.
If H is a character array or cell array of strings, each row is interpreted
as a hexadecimal string.
EXAMPLES:
hex2dec('12B') and hex2dec('12b') both return 299
///////////////////////////////////////////////////////////////////////////
BIN2DEC Convert binary string to decimal integer.
X = BIN2DEC(B) interprets the binary string B and returns in X the
equivalent decimal number.
If B is a character array, or a cell array of strings, each row is
interpreted as a binary string.
Embedded, significant spaces are removed. Leading spaces are converted to
zeros.
Example
bin2dec('010111') returns 23
bin2dec('010 111') also returns 23
bin2dec(' 010111') also returns 23
///////////////////////////////////////////////////////////////////////////
DEC2BIN Convert decimal integer to a binary string.
DEC2BIN(D) returns the binary representation of D as a string.
D must be a non-negative integer smaller than 2^52.
DEC2BIN(D,N) produces a binary representation with at least
N bits.
Example
dec2bin(23) returns '10111'
/////////////////////////////////////////////////////////////////////////