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.

: num2str (x) ¶

: num2str (x, precision) ¶

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

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

: str2double (s) ¶

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

Строка должна быть в одном из следующих форматов, где 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.

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

Для необрабатываемого скалярного или строкового входного значения 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.

: bin2dec (s) ¶

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

Например:

bin2dec ("1110")
     ⇒ 14

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

bin2dec ("1000 0001")
     ⇒ 129

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

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

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

: dec2bin (d) ¶

: dec2bin (d, len) ¶

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

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

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

Примеры:

dec2bin (14)
     ⇒ "1110"

dec2bin (-14)
     ⇒ "11110010"

Примечания по программированию: Наибольшее отрицательное значение, которое может быть преобразовано в дополнение до двух, равно - (flintmax () / 2).

Известная несовместимость с MATLAB: MATLAB’s dec2bin допускает нецелочисленные значения для d, усекая значение с помощью эквивалента fix (d) для положительных значений, но, начиная с R2020b и в противоречии с опубликованной документацией, похоже, использует round (d) для отрицательных значений. Для согласованности с dec2hex и dec2base, Octave выдает ошибку для нецелочисленных значений ввода для d. Пользователи, желающие получить совместимый код для нецелочисленных значений ввода, должны использовать fix или round соответственно.

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

: dec2hex (d) ¶

: dec2hex (d, len) ¶

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

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

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

Примеры:

dec2hex (2748)
     ⇒ "ABC"

dec2hex (-2)
     ⇒ "FE"

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

: hex2dec (s) ¶

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

Например:

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

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

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

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

: dec2base (d, base) ¶

: dec2base (d, base, len) ¶

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

dec2base (123, 3)
   ⇒ "11120"

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

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

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

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

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

: base2dec (s, base) ¶

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

base2dec ("11120", 3)
   ⇒ 123

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

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

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

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.