5.4.2 Числовые данные и строки ¶

Помимо функций конкатенации строк (см. Конкатенация строк), которые преобразуют числовые данные в соответствующие символы, закодированные в UTF-8, существуют несколько функций для форматирования числовых данных в виде строк. mat2str и num2str преобразуют вещественные или комплексные матрицы, а int2str преобразует целочисленные матрицы. int2str извлекает вещественную часть комплексных значений и округляет дробные значения до целых. Более гибкий способ форматирования числовых данных в виде строк — функция sprintf (см. Форматированный вывод, sprintf).

: s = mat2str (x, n) ¶

: s = mat2str (x, n, "class") ¶

Форматирует вещественные, комплексные и логические матрицы в виде строк.

Возвращённая строка может быть использована для восстановления исходной матрицы с помощью функции eval.

Точность значений задаётся параметром n. Если n — скаляр, то действительная и мнимая части матрицы выводятся с одинаковой точностью. В противном случае n(1) определяет точность действительной части, а n(2) определяет точность мнимой части. По умолчанию n равен 15.

Если задан аргумент "class", то класс x включается в строку таким образом, что eval позволит восстановить матрицу того же класса.

mat2str ([ -1/3 + i/7; 1/3 - i/7 ], [4 2])
     ⇒ "[-0.3333+0.14i;0.3333-0.14i]"

mat2str ([ -1/3 +i/7; 1/3 -i/7 ], [4 2])
     ⇒ "[-0.3333+0i 0+0.14i;0.3333+0i -0-0.14i]"

mat2str (int16 ([1 -1]), "class")
     ⇒ "int16([1 -1])"

mat2str (logical (eye (2)))
     ⇒ "[true false;false true]"

isequal (x, eval (mat2str (x)))
     ⇒ 1

См. также: sprintf, num2str, int2str.

: str = num2str (x) ¶

: str = num2str (x, precision) ¶

: str = num2str (x, format) ¶

Преобразует число (или массив) в строку (или символьный массив).

Необязательный второй аргумент может задать количество значащих цифр (precision), которые будут использоваться в выводе, или строку шаблона формата (format), как в sprintf (см. Форматированный вывод). num2str также может обрабатывать комплексные числа.

Примеры:

num2str (123.456)
  ⇒ 123.456

num2str (123.456, 4)
  ⇒ 123.5

s = num2str ([1, 1.34; 3, 3.56], "%5.1f")
  ⇒ s =
       1.0  1.3
       3.0  3.6
whos s
  ⇒ Variables in the current scope:
        Attr Name        Size                     Bytes  Class
        ==== ====        ====                     =====  =====
             s           2x8                         16  char
     Total is 16 elements using 16 bytes

num2str (1.234 + 27.3i)
  ⇒ 1.234+27.3i

Функция num2str не очень гибкая. Для лучшего контроля над результатами используйте sprintf (см. Форматированный вывод).

Примечания по программированию:

Для совместимости с MATLAB ведущие пробелы удаляются перед возвратом строки.

Целые числа, большие чем flintmax, могут не отображаться корректно.

Для комплексного x строка формата может содержать только одну спецификацию преобразования вывода и ничего больше. В противном случае результаты будут непредсказуемыми.

Любой необязательный format, указанный программистом, используется без изменений. Это отличается от MATLAB, которая изменяет format на основе внутренних эвристик.

См. также: sprintf, int2str, mat2str.

: str = int2str (n) ¶

Преобразует целое число (или массив целых чисел) в строку (или символьный массив).

int2str (123)
  ⇒ 123

s = int2str ([1, 2, 3; 4, 5, 6])
  ⇒ s =
        1  2  3
        4  5  6

whos s
  ⇒ Variables in the current scope:
        Attr Name        Size                     Bytes  Class
        ==== ====        ====                     =====  =====
             s           2x7                         14  char
     Total is 14 elements using 14 bytes

Эта функция не очень гибкая. Для лучшего контроля над результатами используйте sprintf (см. Форматированный вывод).

Примечания по программированию:

Нецелые числа округляются до целых перед отображением. Отображается только действительная часть комплексных чисел.

См. также: sprintf, num2str, mat2str.

: d = str2double (str) ¶

Преобразует строку в вещественное или комплексное число.

Строка должна быть в одном из следующих форматов, где a и b — вещественные числа, а комплексная единица — 'i' или 'j':

• a + bi
• a + b*i
• a + i*b
• bi + a
• b*i + a
• i*b + a

Если присутствуют, a и/или b имеют вид [+-]d[,.]d[[eE][+-]d], где скобки указывают необязательные аргументы, а 'd' обозначает ноль или более цифр. Также принимаются специальные входные значения Inf, NaN, и NA.

str может быть строкой, матрицей символов или массивом ячеек. Для матриц символов преобразование выполняется для каждой строки, и возвращается вещественная или комплексная матрица. Пустые строки в s удаляются и не возвращаются в числовом массиве. Для массивов ячеек каждый элемент строки обрабатывается, и возвращается вещественная или комплексная матрица тех же размеров, что и str.

Для необрабатываемого скалярного или строкового входного значения str2double возвращает NaN. Аналогично, для входного значения матрицы символов str2double возвращает NaN для любой строки s, которая не могла быть преобразована. Для массива ячеек str2double возвращает NaN для любого элемента s, для которого преобразование не удалось. Обратите внимание, что числовые элементы в смешанном строковом/числовом массиве ячеек не являются строками, и для этих элементов преобразование завершится неудачей и вернёт NaN.

Примечание по программированию: str2double может заменить str2num, является более эффективным и избегает риска безопасности при использовании eval с неизвестными данными.

См. также: str2num.

: x = str2num (s) ¶

: [x, state] = str2num (s) ¶

Преобразует строку (или символьный массив) s в число (или массив).

Примеры:

str2num ("3.141596")
      ⇒ 3.141596

str2num (["1, 2, 3"; "4, 5, 6"])
      ⇒ 1  2  3
         4  5  6

Необязательный второй выходной параметр state логически истинен, когда преобразование успешно. Если преобразование завершилось неудачей, числовой выходной параметр x пуст, а state — ложь.

Внимание: Поскольку str2num использует функцию eval для выполнения преобразования, str2num выполнит любой код, содержащийся в строке s. Используйте str2double для более безопасного и быстрого преобразования.

Для массива ячеек строк используйте str2double.

См. также: str2double, eval.

: d = bin2dec (str) ¶

Возвращает десятичное число, соответствующее двоичному числу, представленному строкой str.

Например:

bin2dec ("1110")
     ⇒ 14

Пробелы игнорируются во время преобразования и могут использоваться для повышения удобочитаемости двоичного числа.

bin2dec ("1000 0001")
     ⇒ 129

Если str — матрица строк, возвращает столбец с одним преобразованным числом на строку str; некорректные строки оцениваются как NaN.

Если str — массив ячеек строк, возвращает столбец с одним преобразованным числом на каждый элемент ячейки в str.

См. также: dec2bin, base2dec, hex2dec.

: bstr = dec2bin (d) ¶

: bstr = dec2bin (d, len) ¶

Возвращает строку из единиц и нулей, представляющую преобразование целого числа d в двоичное число.

Если d является матрицей или массивом ячеек, возвращает строковую матрицу с одной строкой для каждого элемента в d, дополненную ведущими нулями до ширины наибольшего значения.

Необязательный второй аргумент len задаёт минимальное количество цифр в результате.

Для отрицательных элементов d возвращает двоичное значение дополнительного кода. Результат дополняется ведущими единицами до 8, 16, 32 или 64 битов соответственно величине входных данных. Положительные входные элементы дополняются ведущими нулями до той же ширины.

Примеры:

dec2bin (14)
     ⇒ "1110"

dec2bin (-14)
     ⇒ "11110010"

Совет по программированию: dec2bin отбрасывает любую дробную часть входных данных. Если вам нужна конвертация дробной части, вызовите dec2base с ненулевым количеством десятичных знаков. Также можно использовать fix или round для дробных входных данных, чтобы обеспечить предсказуемое поведение округления.

См. также: bin2dec, dec2base, dec2hex.

: hstr = dec2hex (d) ¶

: hstr = dec2hex (d, len) ¶

Возвращает строку, представляющую преобразование целого числа d в шестнадцатеричное (основание 16) число.

Если d отрицательно, возвращает шестнадцатеричное дополнение d.

Если d является матрицей или массивом ячеек, возвращает строковую матрицу с одной строкой для каждого элемента в d, дополненную ведущими нулями до ширины наибольшего значения.

Необязательный второй аргумент len задаёт минимальное количество цифр в результате.

Примеры:

dec2hex (2748)
     ⇒ "ABC"

dec2hex (-2)
     ⇒ "FE"

Совет по программированию: dec2hex отбрасывает любую дробную часть входных данных. Если вам нужна конвертация дробной части, вызовите dec2base с ненулевым количеством десятичных знаков. Также можно использовать fix или round для дробных входных данных, чтобы обеспечить предсказуемое поведение округления.

См. также: hex2dec, dec2base, dec2bin.

: d = hex2dec (str) ¶

Возвращает целое число, соответствующее шестнадцатеричному числу, представленному строкой str.

Например:

hex2dec ("12B")
      ⇒ 299
hex2dec ("12b")
      ⇒ 299

Если str является строковой матрицей, возвращает столбец со значениями, преобразованными из каждой строки str; некорректные строки дают NaN.

Если str является массивом ячеек строк, возвращает столбец со значениями, преобразованными из каждого элемента ячейки в str.

См. также: dec2hex, base2dec, bin2dec.

: str = dec2base (d, base) ¶

: str = dec2base (d, base, len) ¶

: str = dec2base (d, base, len, decimals) ¶

Возвращает строку символов в системе счисления base, соответствующую значению d.

dec2base (123, 3)
   ⇒ "11120"

Если d отрицательное, результат будет представлять d в дополнительном коде. Например, отрицательные двоичные числа представлены в дополнительном коде, аналогично для других систем счисления.

Если d является матрицей или массивом ячеек, возвращает строковую матрицу с одной строкой на каждый элемент в d, дополненную ведущими нулями до ширины наибольшего значения.

Если base является строкой, символы из base используются как символы для цифр d. Пробелы (пробелы, табуляции, новые строки и т. д.) не могут использоваться как символ.

dec2base (123, "aei")
   ⇒ "eeeia"

Необязательный третий аргумент len задаёт минимальное количество цифр в целой части результата. Если он опущен, dec2base использует достаточно цифр для размещения входных данных.

Необязательный четвёртый аргумент decimals задаёт количество цифр для представления дробной части входных данных. Если он опущен, он устанавливается в ноль, и dec2base возвращает целочисленный результат для обратной совместимости.

dec2base (100*pi, 16)
⇒ "13A"
dec2base (100*pi, 16, 4)
⇒ "013A"
dec2base (100*pi, 16, 4, 6)
⇒ "013A.28C59D"
dec2base (-100*pi, 16)
⇒ "EC6"
dec2base (-100*pi, 16, 4)
⇒ "FEC6"
dec2base (-100*pi, 16, 4, 6)
⇒ "FEC5.D73A63"

Совет по программированию: При передаче отрицательных входных данных в dec2base, лучше явно указать требуемую длину результата.

См. также: base2dec, dec2bin, dec2hex.

: d = base2dec (str, base) ¶

Преобразует str из строки цифр в системе счисления base в целое десятичное число (основание 10).

base2dec ("11120", 3)
   ⇒ 123

Если str является строковой матрицей, возвращает столбец со значениями для каждой строки str. Если строка содержит некорректные символы, соответствующее значение будет NaN.

Если str является массивом ячеек строк, возвращает столбец со значениями для каждого элемента ячейки в str.

Если base является строкой, символы из base используются как символы для цифр str. Пробел (’ ’) не может использоваться как символ.

base2dec ("yyyzx", "xyz")
   ⇒ 123

См. также: dec2base, bin2dec, hex2dec.

: s = num2hex (n) ¶

: s = num2hex (n, "cell") ¶

Преобразует числовой массив в массив шестнадцатеричных строк.

Например:

num2hex ([-1, 1, e, Inf])
⇒ "bff0000000000000
    3ff0000000000000
    4005bf0a8b145769
    7ff0000000000000"

Если аргумент n — число с одинарной точностью или вектор, возвращаемая строка имеет длину 8. Например:

num2hex (single ([-1, 1, e, Inf]))
⇒ "bf800000
    3f800000
    402df854
    7f800000"

С необязательным вторым аргументом "cell", возвращается массив ячеек строк вместо символьного массива.

См. также: hex2num, hex2dec, dec2hex.

: n = hex2num (s) ¶

: n = hex2num (s, class) ¶

Приведение шестнадцатеричного символьного массива или массива ячеек строк к массиву чисел.

По умолчанию входной массив интерпретируется как шестнадцатеричное число, представляющее значение двойной точности. Если дано меньше 16 символов, строки дополняются справа символами '0'.

Для строковой матрицы hex2num каждая строка обрабатывается как отдельное число.

hex2num (["4005bf0a8b145769"; "4024000000000000"])
   ⇒ [2.7183; 10.000]

Необязательный второй аргумент class может быть использован для интерпретации входного массива как значения другого типа. Возможные значения:

Вариант	Символы
"int8"	2
"uint8"	2
"int16"	4
"uint16"	4
"int32"	8
"uint32"	8
"int64"	16
"uint64"	16
"char"	2
"single"	8
"double"	16

Например:

hex2num (["402df854"; "41200000"], "single")
   ⇒ [2.7183; 10.000]

См. также: num2hex, hex2dec, dec2hex.

: [a, …] = strread (str) ¶

: [a, …] = strread (str, format) ¶

: [a, …] = strread (str, format, format_repeat) ¶

: [a, …] = strread (str, format, prop1, value1, …) ¶

: [a, …] = strread (str, format, format_repeat, prop1, value1, …) ¶

Эта функция устарела. Используйте textscan вместо неё.

Чтение данных из строки.

Строка str разбивается на слова, которые многократно сопоставляются со спецификаторами в format. Первое слово сопоставляется с первым спецификатором, второе — со вторым и так далее. Если слов больше, чем спецификаторов, этот процесс повторяется до обработки всех слов.

Строка format описывает, как слова в str должны быть обработаны. Она может содержать любую комбинацию следующих спецификаторов:

%s

Слово обрабатывается как строка.

%f

%n

Слово обрабатывается как число и преобразуется в double.

%d

%u

Слово обрабатывается как число и преобразуется в int32.

%*

%*f

%*s

Слово пропускается.

Для %s и %d, %f, %n, %u и соответствующих %*s … спецификаторов, можно указать необязательную ширину, например, %Ns, где N — целое число > 1. Для %f допускаются спецификаторы формата, такие как %N.Mf.

literals

Кроме того, формат может содержать буквальные строковые литералы; они будут пропущены во время чтения.

Обработанное слово, соответствующее первому спецификатору, возвращается в первом выходном аргументе, и так далее для остальных спецификаторов.

По умолчанию, format равно "%f", что означает, что числа читаются из str. Это будет работать, если str содержит только числовые поля.

Например, строка

str = "\
Bunny Bugs   5.5\n\
Duck Daffy  -7.5e-5\n\
Penguin Tux   6"

может быть прочитана с помощью

[a, b, c] = strread (str, "%s %s %f");

Необязательный числовой аргумент format_repeat может использоваться для ограничения числа считываемых элементов:

-1

(по умолчанию) считывает всю строку до конца.

N

Считывает N раз nargout элементов. 0 (ноль) является допустимым значением для format_repeat.

Поведение strread можно изменить с помощью пар свойство-значение. Признаются следующие свойства:

"commentstyle"

Части str считаются комментариями и будут пропущены. value — стиль комментария и может быть любым из следующих.

• "shell" Всё от # символов до ближайшей строки.
• "c" Всё между /* и */.
• "c++" Всё от // символов до ближайшей строки.
• "matlab" Всё от % символов до ближайшей строки.
• пользовательский. Два варианта: (1) Одна строка или 1x1 ячейка строк: Пропустить всё справа от неё; (2) 2x1 ячейка массива строк: Пропустить всё между левой и правой строками.

"delimiter"

Любой символ в value будет использоваться для разделения str на слова (значение по умолчанию — любой пробельный символ). Обратите внимание, что пробелы неявно добавляются в набор разделительных символов, если не предоставлен спецификатор формата "%s"; см. параметр "whitespace" ниже. Набор разделительных символов не может быть пустым; при необходимости Octave заменяет пробелом.

"emptyvalue"

Значение для возврата для пустых числовых значений в данных, разделённых не пробелами. Значение по умолчанию — NaN. Когда тип данных не поддерживает NaN (например, int32), значение по умолчанию — ноль.

"multipledelimsasone"

Рассматривать серию последовательных разделителей без пробелов между ними как один разделитель. Последовательные серии разделителей не обязательно должны быть вертикальными "aligned".

"treatasempty"

Рассматривать отдельные вхождения (окружённые разделителями или пробелами) строки(строк) в value как пропущенные значения.

"returnonerror"

Если value истинно (1, по умолчанию), игнорировать ошибки чтения и возвращаться нормально. Если ложно (0), возвращать ошибку.

"whitespace"

Любой символ в value будет интерпретироваться как пробел и обрезаться; строка, определяющая пробелы, должна быть заключена в двойные кавычки для правильной обработки специальных символов, таких как "\t". В каждом поле данных несколько последовательных пробельных символов сводятся к одному пробелу, и ведущие и хвостовые пробелы удаляются. Значение по умолчанию для пробелов — " \b\r\n\t" (обратите внимание на пробел). Пробелы всегда добавляются в набор разделительных символов, если не указан хотя бы один спецификатор формата "%s"; в этом случае только пробелы, явно указанные в "delimiter", сохраняются как разделители и удаляются из набора пробельных символов. Если пробельные символы должны сохраняться как есть (например, в строках), укажите пустое значение (т.е. "") для "whitespace"; очевидно, тогда пробелы не могут быть разделителями.

Когда количество слов в str не соответствует точному кратному количеству спецификаторов формата, поведение strread зависит от последнего символа str:

последний символ = "\n"

Столбцы данных дополняются пустыми полями или NaN, чтобы все столбцы имели одинаковую длину

последний символ не "\n"

Столбцы данных не дополняются; strread возвращает столбцы разной длины

См. также: textscan, sscanf.