标签: boolean-operations

我在Arduino环境中有一些代码,它需要x(以8为增量)布尔值,这些布尔值可以在运行时为某些移位寄存器代码操作.所以目前我正在使用像这样的布尔数组:

 #define number_of_shiftRegisters 220 //num of 8 bit shift registers

 #define numOfRegisterPins number_of_shiftRegisters * 8 //number of booleans needed

 boolean registers[numOfRegisterPins]; //boolean array

但是我的RAM耗尽了大约200(1600布尔)并且不知道为什么直到我看到它,即使布尔值为1位,它们也存储在8位数据中.

正如我之前所说,所需的bool数量总是增加8,所以我不知道这是否对我有利.

是否有更高内存效率的方式来存储1000多个布尔值,仍然能够通过索引引用它们？

或者......至少更高的内存效率,不会花费更多的CPU时间来设置和迭代？

我曾想过一个char数组,然后对每个字符进行掩码以访问各个位.但我不知道是否有更简单的方法,或者这是否会占用更多的CPU时间.

我正在处理布尔函数,我只能(但安全地)假设它们作为SOP进入并且不包含否定(例如(A && B && C)||(A && B && D)).析取的数量通常> 5,连词的数量通常> 10.

因为在我的情况下计算每个变量的值很难并且结果被认为是短暂的,我需要能够最小化关于变量出现的所述函数.这种最小化的结果不需要是任何正常形式,并且允许任意深度嵌套.

在问过类似问题之前,SO 指出了使用扇出最小化,卡诺图,QM或BDD的一般解决方案.在处理这些方法之前 - 这会大大夸大我的代码 - 我想仔细检查输入函数的先验已知事实是否不会产生使用较小但较不通用的最小化方法的可能性.

应用吸收和分配规律的AFAICS将始终提供最小的形式.是否有可能利用这些功能作为SOP而没有否定的事实？在我看来,对变量应该有一个简单的交集和并集运算的递归算法,它将产生所需的结果.

可以描述一下这个算法吗？

编辑:征求意见:在对该主题做了一些研究之后,在我看来,这里提出的问题等同于找到给定函数的简化BDD的最优变量排序.

背景:最小化的函数被传递到作业队列以计算所有必需变量的值.之后评估该功能.考虑应用示例:

• 输入函数 (A && B && C)|| (A && B && D)可以写成A && B &&(C || D),这样就不必再评估A和B两次.C和D的评估在作业队列中被序列化,因为只需要证明其中一个是真的.
• (A && B && C)|| (A && B && C && D)|| (A && B && X && E)减少为A && B &&(C ||(X …

我听说除了0以外通常"一切"都是真的.但现在我发生了很奇怪的事情......或者我只是认为我这样做是正确的,而我却没有.这是发生了什么:

当我要检查,如果一个相当于b,我可以使用NOT(a XOR b).例如,当我检查它时unsigned char,一切都很好

unsigned char a = 5;
unsigned char b = 3;
unsigned char c = ~(a^b);

给了我c == 249:

a是:00000101,即5.

b是:00000011,即3.

〜(a ^ b)是:11111001,即249.

现在,让我们试试吧bool.

cout << ~(true^true) << ~(true^false) << ~(false^true) << ~(false^false) << endl;
cout << ~(~(true^true)) << ~(~(true^false)) << ~(~(false^true)) << ~(~(false^false)) << endl;

if (~(true^true) == true)
    cout << "true";
else …

我嵌套了代表 SAT 论坛的真值列表，如下所示：

[[[0, True, False], [0, True, False], [0, True, 1]], [[0, True, True], [2, True, True], [3, False, True]], [[1, False, False], [1, False, False], [3, False, True]]]

代表

([x0=0] + [x0=0] + [x0=1]) * ([x0=1] + [x1=1] + [-x2=1]) * ([-x3=0] + [-x3=0] + [-x2=1])

我想计算整个公式的真值。第一步是将每个子句中文字的真值相加。

像这样：

clause_truth_value = None

for literal in clause:
    # multiply polarity of literal with its value
    # sum over all literals
    clause_truth_value += literal[1]*literal[2]

如果clause_truth_value是True在求和之后，则该子句整体为真。

但我没有得到我所期望的：

True …

我有一堆方法都返回bool.

如果一个方法返回false,则调用以下方法没有任何价值,特别是因为其中一些方法是"昂贵的"操作.

哪个更有效率？

bool result = method1();
if (result) result = method2();
if (result) result = method3();
return result;

要么

return method1() && method2() && method3();

据我所知,第二种形式应该在其中一种方法返回false时停止评估,对吧？

我在c ++中找到了一个关于布尔转换器,*布尔表达式(语法)解析器的非常好的例子

我现在在想的是做一个进一步的步骤,转换(!T|F)&T成F或者0,这样计算一个很长的布尔表达式非常方便.

有一些使用精神的例子吗？我所做的是首先制作一个计算器,然后让它计算'(T +!F*T)',它等于(T||!F&&T)但是当我输入时(),有一个错误.如何修改？非常感谢!

#include <iostream>  
#include <stack>  
#include <boost/lexical_cast.hpp>  
#include <boost/config/warning_disable.hpp>  
#include <boost/spirit/include/qi.hpp>  
#include <boost/spirit/include/phoenix.hpp>  

using namespace std;  
namespace phoenix = boost::phoenix;  
namespace qi = boost::spirit::qi;  
namespace ascii = boost::spirit::ascii;  

struct calculator  
{  
    bool interpret(const string& s);  
    void do_neg();  
    void do_add();  
    void do_sub();  
    void do_mul();  
    void do_div();  
    void do_number(const char* first, const char* last);  
    int val() const;  
private:  
    stack<int> values_;  
    int *pn1_, n2_;  
    void …

我有一个向量v,我想找到所有那些值在4到7之间的元素.v = c(1:9)

# indices of elements with values larger than 4
which(v > 4)
# indices of elements with values smaller than 7
which(v < 7)

v>4并v<7给出布尔向量,我想结合起来.我试过以下,这对我不起作用,......

# combination?
matching = which(v>4 && v<7)  # does not work

如何在两个布尔向量上应用布尔运算,这给了我一个结果向量？

我有这个:

if(!A or (A and B))   //pseudocode

我想否定 if语句:

这应该工作:

if(!(!A or (A and B)))  //pseudocode

但我相信有一种方法可以简化它,现在它正在逃避我.

我想使用占位符控制函数的执行,但不断收到错误"不允许使用tf.Tensor作为Python bool".以下是产生此错误的代码:

import tensorflow as tf
def foo(c):
  if c:
    print('This is true')
    #heavy code here
    return 10
  else:
    print('This is false')
    #different code here
    return 0

a = tf.placeholder(tf.bool)  #placeholder for a single boolean value
b = foo(a)
sess = tf.InteractiveSession()
res = sess.run(b, feed_dict = {a: True})
sess.close()

我没有运气就改变if c了if c is not None.如何foo通过打开和关闭占位符来控制a呢？

更新:正如@nessuno和@nemo指出的那样,我们必须使用tf.cond而不是if..else.我的问题的答案是重新设计我的功能,如下所示:

import tensorflow as tf
def foo(c):
  return tf.cond(c, func1, func2)

a …

为什么评估这个False？

1==0 <= 1/0

首先请注意,在Python中:

bols = [False, True] for A in bols: for B in bols: print(f'{str(A):>5}, {str(B):>5}, {str(A<=B):>5}') 输出:

False, False, True False, True, True True, False, False True, True, True 如果你熟悉布尔逻辑,这对你来说应该很自然.

现在它变得奇怪了:

print(1==1 <= 1/1, 1==0 <= 1/1)

日期: True, False

现在它变得更奇怪了:

print(1==0 <= 1/0)

日期: False

为什么最后一个不会抛出一个例外？

我的第一个猜测是因为解析问题.例如,先前的比较我们可以修复添加括号:

print(1==1 <= 1/1, (1==0) <= 1/1)

日期: True, True

但是,如果这个问题是一个解析问题,那么当我们除以0时,为什么python不会引发异常呢？

如果我们在最后一次比较中添加括号,我们可以强制Python提高ZeroDivision Exeption:

print((1==0) <= 1/0)

日期: ZeroDivisionError: division by zero

另外,为什么以下引发异常？

1==1 <= 1/0

日期: ZeroDivisionError: …