Это третья статья из цикла о LabVIEW NXG, в которой мы рассмотрим простые типы данных и несложные преобразования между ними.

Система типов LabVIEW весьма похожа на "классические" языки программирования. В данной статье мы рассмотрим базовые типы — численные, булевские и строки (хотя формально строки не относятся к простым скалярным типам).

Самый простой способ понять систему типов — сделать небольшой инструмент с контролами и индикаторами разных типов:

и соединим их на диаграмме вот так:

Чтобы подчеркнуть различие контролов и индикаторов, я добавил к именам " In" и " Out". Это общепринятая практика в LabVIEW, так как подчёркивает принцип потоков данных, когда контролы и индикаторы используются как терминалы подприборов (о которых мы ещё поговорим).

В случае с численными индикаторами мы можем один из четырнадцати доступных нам типов — знаковые и беззнаковые целые, занимающие 8, 16, 32 или 64 бита, числа с плавающей точкой одинарной или двойной точности (они будут занимать 4 или 8 байт), комплексные числа также одинарной или двойной точности и числа с фиксированной точностью — также простые или комплексные. Тип переключается вот здесь в контекстном меню:

Или вот здесь в панели свойств:

При первом присоединении числового индикатора к проводнику он автоматически меняет тип на тип проводника (а тип проводника совпадает с типом контрола, к которому он подключён). Что произойдёт, если тип индикатора будет отличаться от типа проводника? Вот смотрите:

У нас "загорелись" красные точки (которые называются Coercion Dots), которые говорят нам о том, что в местах подсоединения происходит неявное преобразование типа.

В случае если мы преобразуем SGL в DBL или, скажем, U8 в I32, то ничего страшного не произойдёт, однако преобразование в обратном направлении DBL->SGL, либо DBL->I32 или I32->U8 может привести к потере точности, либо округлениям:

Хорошим "тоном" программирования на LabVIEW считается полное отсутствие Coercion Dots на диаграмме, тем более что каждая такая точка будет добавлять вам предупреждение:

Как поступить в том случае, если вам действительно нужны явные преобразования типов? Для этого есть соответствующие примитивы преобразования, которые находятся вот здесь в палитре Data Types->Numeric->Conversion:

А в контекстном меню эти функции находятся вот здесь:

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

Неявное преобразование типов также распространяется и на математические примитивы, например, если вы хотите прибавить целое к числу с плавающей точкой, то вначале целое будет приведено к типу DBL, и лишь затем будет выполнено сложение:

Кстати, вы можете использовать несколько терминалов при использовании некоторых арифметических операций, для этого надо просто потянуть вниз или вверх вот здесь (в классической LabVIEW приходилось менять этот примитив на Compound Arithmetic):

По сравнению с классическими текстовыми языками у LabVIEW есть некоторые отличия. Допустим, вы хотите поделить два целых:

double res;
res = 5/3;
Console.WriteLine(res);

результат будет "1".

А в LabVIEW будет выполнено приведение типов, и результат будет 1,66 (1,66666666666667 если быть дотошным):

Следует отметить, что LabVIEW предоставляет вам немножко больше свободы, чем, скажем, C# (степень "типизированности" у всех языков разная).

Вот, к примеру, мы хотим сложить два байта:

Как видите, здесь не возникает никаких предупреждений и никакого приведения. Самом собой, мы получим переполнение, но мы получаем именно то, что хотим:

В то время как в C# такое даже компилятор не пропустит (ибо операция сложения для байтов не определена, они будут неявно перобразованы в int, затем сложены, а неявное преобразование обратно в байт невозможно:

        static void Main(string[] args)
        {
        byte x_U8 = 200, y_U8 = 200, res_U8;

        res_U8 = x_U8 + y_U8;

            Console.WriteLine(res_U8);
        }

И вам придётся сделать вот так:

        res_U8 = (byte)(x_U8 + y_U8);

Обратите внимание, что подобное приведение можно сделать и в LabVIEW, явно указав тип терминалов операции сложения, при этом LabVIEW укажет нам, на то, что мы вручную изменили тип синей точкой на выходе (при этом предупреждения не будет):

Но лучше всего при подобных перобразованиях делать вот так, причём можно использовать комментарии на проводниках, чтобы подчеркнуть тип данных:

Ещё одна особенность LabVIEW (которая присутствует и во многих "традиционных" языках) — наличие бесконечности и неопределённости.

Прежде чем продолжить с LabVIEW мне хотелось бы расчехлить C# и бросить камушек в огород компании Microsoft, ибо вот такой несложный код:

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(5.0/0.0);
    }
}

выдаёт мне "8". Но, разумеется, это не "восемь", это "Infinity", просто надо голову повернуть набок. Ирония в том, что это .NET Core — продукт компании Микрософт, запускаемый в консоли Микрософт и под управлением операционной системы Микрософт (и да, я только что поставил новый, "с иголочки" Windows 10 версии 2004). В принципе исходники открыты, и, вероятно, убив некоторое количество времени, я могу разобраться в чём там дело, но если вы считаете, что это нормально, бросьте этот камушек в меня обратно.

Ну, как бы то ни было, давайте поделим на нуль в LabVIEW:

Результат деления на нуль — бесконечность. Минус нуль у нас тоже есть и получится минус бесконечность:

Ну а если делить нуль на нуль, то будет NaN (Not a Number):

Мы можем проанализировать если мы получаем NaN при помощи примитива Not a Number? из палитры сравнения:

Результат этого кода — истина.

Чуть сложнее с целыми.

В С# данный код компилятор не пропустит:

static void Main(string[] args)
{
    Console.WriteLine(5/0);
}

но я могу схитрить...

static void Main(string[] args)
{
    int zero = 0; 
    Console.WriteLine(5/zero);
}

… и получирть исключение System.DivideByZeroException, однако в LabVIEW вы этого не дождётесь — здесь вы получите нуль, так что будьте аккуратны.

Преобразования между числами и строками

Напрямую (неявным) образом выполнить такое преобразование нельзя:

Для этого в палитре Conversions предусмотрены соответствующие функции:

Применяется вот так:

В обратную сторону преобразование выполняется аналогичным образом, с той лишь разницей, что функции преобразования находятся в палитре работы со строками:

Применяется вот так:

Ещё один маленький и, возможно, неочевидный нюанс со строками для тех кто привык делать вот так:

    static void Main(string[] args)
    {
    string hello = "Hello, ";
    string habr = "Habr!";

        Console.WriteLine(hello + habr);
    }

В LabVIEW "один в один" не получится, для этого есть отдельная функция объединения строк:

Базовые операции с булевским типом

Ровно тоже самое и с булевским типом. Вы не можете соединить численный проводник с булевским терминалом напрямую и наоборот, но вы можете использовать функции сравнения и примитив Boolean to Integer для обратного преобразования:

Особенности сравнения чисел с плавающей точкой справедливы и для LabVIEW. Данный код вернёт False:

Машинный эпсилон находится в разделе констант, вот здесь:

Type Cast

Ну и напоследок хотелось бы затронуть тему преобразования "Type Cast", которая часто вводит в заблуждение. Я имею ввиду вот эту функцию:

У неё есть дополнительный терминал "Type", который задаёт выходной тип. Ключевой момент здесь в словах "by flattening it and unflattening". Самый ближайший аналог "сериализация/десериализация".

Предположим, для простоты я возьму четырёхбайтный тип SGL и преобразую его в I32:

Чему будет равен output? Правильный ответ "1040187392". Почему такое странное число?

Давайте переключим индикатор в шестнадцатиричное представление и всё станет понятнее:

Это 0x3E000000. Здесь происходит следующее — четыре байта числа с плавающей точкой реинтерпретируются как четырёхбайтное целое. Я намеренно взял число 0,125, потому что если вы посмотрите на представление 0,125 согласно IEEE754, то увидите, что там всего пять битов мантиссы установлено — это и даёт нам значение 3Е в старшем байте.

После трёх статей мы должны достаточно уверенно работать с тремя типами данных:

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

LabVIEW NXG — простые типы данных и приведение типов