Верная булевская переменная - положительный 1 или отрицательный 1?
Если вы переписываете свою задачу математически, вы можете показать, что она эквивалентна:
dim(x) <- c(3 * N, 3)
dim(y) <- c(3 * N, 3)
gg2 <- crossprod(x, y)
, которая должна быть очень быстрой и не должна делать никаких копий.
11 ответов
0 ложь, потому что процессор имеет флаг, который установлен, когда регистр обнуляется.
Никакие другие флаги не установлены ни на каком другом значении (0x01, 0xff, и т.д.) - но нулевой флаг имеет значение false, когда существует ненулевое значение в регистре.
Так ответы, здесь защищающие определение 0, поскольку, ложь и что-либо еще как верные корректны.
Если Вы хотите "определить" значение по умолчанию для истинного, то 0x01 лучше, чем большинство:
- Это представляет то же число в каждой длине в битах и со знаком
- Только тестированию требуется один бит, если Вы хотите знать, верно ли это, должен нулевой флаг быть недоступным, или дорогостоящим для использования
- Никакая потребность волноваться о расширении знака во время преобразования в другие типы
- Логические и арифметические выражения действуют то же на него
- Adam
Почему Вы выбираете это, ненулевые значения верны? В верной Ada Истина и ложь, ЛОЖЬ. Нет никакого неявного преобразования типов к и от БУЛЕВСКОЙ ПЕРЕМЕННОЙ.
Это не имеет значения, пока это удовлетворяет правила для внешнего представления.
Я понял бы намек от C здесь, где ложь определяется абсолютно, как 0, и верный определяется как не ложь. Это - важное различие, по сравнению с абсолютным значением для истинного. Если у Вас нет типа, который только имеет два состояния, необходимо объяснить все значения в том типе значения, что верно, и что является ложью.
Используя-1 имеет преимущество на языке со слабым контролем типов - если Вы портите и используете поразрядное and оператор вместо логического and оператор, Ваше условие все еще оценит правильно целый один из операндов, был преобразован в каноническое булево представление. Это не верно, если каноническое представление равняется 1.
0xffffffff & 0x00000010 == 0x00000010 (true)
0xffffffff && 0x00000010 == 0xffffffff (true)
но
0x00000001 & 0x00000010 == 0x00000000 (false)
0x00000001 && 0x00000010 == 0xffffffff (true)
IMO, если Вы хотите придерживаться false=0x00, необходимо использовать 0x01. 0xFF обычно:
- знак, что некоторая переполненная операция
или
- ошибочный маркер
И в обоих случаях, это, вероятно, означает ложь. Следовательно *отклоняют конвенцию возвращаемого значения от исполняемых файлов, это true=0x00, и любое ненулевое значение является ложью.
0xff является нечетным выбором, так как он имеет неявное предположение, что 8 битов являются Вашим минимальным устройством хранения данных. Но дело не в этом редкий, чтобы хотеть сохранить булевы значения более сжато, чем это.
Возможно, Вы хотите перефразировать путем размышления о том, производят ли булевы операторы что-то, что является всего одним 0 или 1 бит (который работает независимо от расширения знака), или, все-обнуляет или все-(и зависит от расширения знака two's-дополнительных количеств со знаком для поддержания все-в любой длине).
Я думаю, что Ваша жизнь более проста с 0 и 1.
Профессионалы не ни один, и недостатки не ни один, также. Пока Вы обеспечиваете автоматическое преобразование от целого числа до булевской переменной, это будет произвольно, таким образом, это действительно не будет иметь значения, какие числа Вы выбираете.
С другой стороны, если бы Вы не позволили это автоматическое преобразование, то у Вас было бы про: у Вас не было бы некоторого совершенно произвольного правила на Вашем языке. Вы не имели бы (7 - 4 - 3) == false, или 3 * 4 + 17 == "Hello", или "Hi mom!" == Complex(7, -2).
Разработайте язык так, чтобы 0 была ложь, и ненулевой верно. Нет никакой потребности "преобразовать" что-либо, и размышление "ненулевого" вместо некоторого определенного значения поможет Вам написать код правильно.
Если у Вас есть встроенные символы как "Истинный", затем идут вперед и выбирают значение, но всегда думают "ненулевые, верно" вместо "0x01, верно".
Независимо от того, что Вы делаете, после того как Вы выбираете свои значения, не изменяют их. В FORTH-77 истина и ложь была определена как 1 и 0. Затем FORTH-83 переопределил их как-1 и 0. Были не немногие (хорошо хорошо, только некоторые, это - Forth, мы говорим о), проблемы, вызванные этим.
- 1 длиннее для ввода, чем 1...
В конце это не имеет значения, с тех пор 0 ложь, и что-либо еще верно, и Вы никогда не будете выдерживать сравнение с точным представлением истинных.
Редактирование, для тех, которые вниз голосуют, объясните почему. Этот ответ является по существу тем же как один в настоящее время расчетный в +19. Таким образом, это - 21 различие в голосах для того, что является тем же основным ответом.
Если это из-за этого-1 комментария, это верно, человек, который на самом деле определяет "верный" (например: разработчик компилятора), оказывается перед необходимостью использовать-1 вместо 1, предполагая, что они приняли решение использовать точное представление.-1 собирается занять больше времени для ввода, чем 1, и конечным результатом будет то же. Оператор глуп, он был предназначен для подоконника, потому что нет никакой реальной разницы между двумя (1 или-1).
Если Вы собираетесь отметить что-то, по крайней мере, обеспечивают объяснение для него.
Я думаю, что метод C является способом пойти. 0 лжи средств, что-либо еще означает верный. Если Вы идете с другим отображением для истинного, то Вас оставляют с проблемой наличия неопределенных значений - которые не являются ни верными, ни ложными.
Если это - язык, который Вы будете компилировать для набора конкретной инструкции, который имеет специальную поддержку особого представления, то я позволил этому вести Вас. Но отсутствующий любая дополнительная информация, для 'стандартного' внутреннего представления, я пошел бы с-1 (все 1's в двоичном файле). Это значение расширяется хорошо на любую булевскую переменную размера, которую Вы хотите (единственный бит, 8-разрядный, 16, и т.д.), и если Вы разбиваете "TRUE" или "ЛОЖЬ" в меньшего "TRUE" или "ЛОЖЬ", все еще то же. (где при повреждении TRUE=0x0001 на 16 битов, Вы получили бы FALSE=0x00 и TRUE=0x01).