Release Notes¶
Version 0.28¶
Moved the PicoSAT and Espresso code to a top-level thirdparty
directory.
Did lots of work in the boolexpr
library.
Primary change was to get rid of all dynamic stack allocations,
replacing them with heap allocations.
Most of this was internal stuff which won’t be noticeable at the UI.
This includes a mega rename of boolexpr
public functions and variables
to have a BX_*
prefix.
Also added a new simplification:
>>> Xor(a, Xnor(b, c))
Not(Xor(a, b, c))
Release 0.27¶
Version 0.27.3¶
Fixed two more issues with C extensions:
Version 0.27.1¶
Fixed a segfault issue with the to_dnf
and to_cnf
functions.
See Issue 109 for details.
Version 0.27.0¶
Note
This release involves many backwards-incompatible changes, so please browse through these release notes when upgrading from 0.26 to 0.27.
The major new feature in this release is the addition of a high performance C
extension for Boolean expressions.
See Issue 98 for some details,
but the idea is fairly simple.
Since expressions are basically the central data type of PyEDA,
it was about time they received the proper performance attention.
So I spent a couple months hacking on a C extension located in
extension/boolexpr
.
Now most of the expensive transformations are handled at the C level.
For example, simplification and conversion to DNF/CNF are much faster.
The C library uses reference counting for memory management,
and I have done some extensive testing to make sure it doesn’t leak memory.
The API isn’t documented to the level of a finished product,
but if you want to figure out the broad strokes just read the boolexpr.h
header file.
The algorithms are all single-threaded at the moment.
In a future release I would like to experiment with using OpenMP tasks to
accelerate the work.
With that said, here’s a list of changes.
The deprecated Expression.factor
method went away,
replaced by the to_nnf
method.
Also, the deprecated Expression.invert
method went away.
The simplification and NNF transformation algorithms are more efficient now,
so you really don’t need this anyways.
The Expression.to_unicode
and Expression.to_latex
methods went away.
They may come back in the future, but they were undocumented and broken anyways.
The Expression
class hierarchy is now completely different.
Expressions are split up into two categories: Atom
and Operator
.
Atoms are sub-divided into Constant
and Literal
,
and literals are further subdivided into Complement
, and Variable
.
Note that it is Variable
, not ExprVariable
.
Operators now have completely different class names.
Instead of ExprOr
, it is now OrOp
. ExprNot
becomes NotOp
, etc.
Probably the other most noticeable change to the UI is that using overloaded operators no longer automatically simplifies expressions. For example:
>>> a, b, c, d = map(exprvar, 'abcd')
>>> a & b & c & d
And(And(And(a, b), c), d)
The reason I made this change is that simplification costs a bit of CPU time, and we should avoid that when creating large expressions. The factory operators still simplify by default:
>>> And(a, b, c, d)
And(a, b, c, d)
You can no longer count on the ordering of clauses in a two-level expression. This was done for performance reasons as well. It is very wasteful to to the computations necessary for figuring out a canonical ordering, and the return on investment isn’t very high. If you have written tests that rely on some fixed operand ordering, they will probably break. Literals within clauses, on the other hand, are still ordered by their uniqid values.
There is now an Expression.size
method,
which returns the number of nodes in the tree.
This number is a nice proxy for memory usage if you multiply it by the size
of a BoolExpr
node.
The Expression.absorb
method is now gone,
but if you use Expression.to_dnf
or Expression.to_cnf
,
it will automatically apply absorption for you.
Also, it is much faster than it was before.
My apologies to anybody using Windows, because I have not had the necessary machines for testing a build on that platform. Feel free to submit a pull request if you find something that is not portable.
Though this addition is very exciting, there is still plenty of room for improvement in the performance area. I would like to experiment with using OpenMP “tasks” to accelerate big tree transformations. Currently, the SAT implementation does not happen directly in the C layer. That requires further integration between the two C APIs. Also, annoyingly, the Tseitin transformation code is still written in Python. This is due to the problem that this transformation requires the ability to create new variable objects, which is currently handled at the Python level. This is not an unsolvable problem, but requires some work.
I’m almost positive I missed a few details. Feel free to email with comments and suggestions.
Happy programming!
Version 0.26¶
Another small, incremental release.
The most important changes were related to Issue 99. Simplified the expression class hierarchy a bit. Got rid of Nor, Nand, and Xnor expression classes, because they’re not all that useful. Eliminated auto-simplification of degenerate forms.
Updated to PicoSAT version 960.
Got rid of some old DPLL cruft. The PicoSAT extension is so superior to my amateurish Python implementation, no point in keeping it around anymore.
Changed the names of various exceptions from something like LexError
to lex.Error
.
I was influenced by the Exceptions section
from the Google Python Style Guide.
Deprecated expression factor
methods in favor of the more hip
negation normal form (NNF) terminology.
See Issue 101 for details.
Updated the formatting of truth table strings. Now the inputs are aligned beneath their variable names.
Previously:
inputs: x2 x1 x0
000 0
001 0
010 0
011 1
100 0
101 1
110 1
111 1
Now:
x2 x1 x0
0 0 0 : 0
0 0 1 : 0
0 1 0 : 0
0 1 1 : 1
1 0 0 : 0
1 0 1 : 1
1 1 0 : 1
1 1 1 : 1
Version 0.25¶
This is a small, incremental release. I recently changed jobs and moved, so development will definitely slow down for a while.
Function array concatenation and repetition for MDAs is now a bit smarter
(Issue 96).
Rather than simply flattening,
the operators will attempt to retain the shape of the MDAs if possible.
For example, a 2x6x7 + 2x6x7
concatenation will return 4x6x7
,
and 2x6x7 * 2
repetition will return 4x6x7
.
Got rid of a[0][1][2]
expression parsing syntax.
Use a[0,1,2]
instead.
Also got rid of the bitvec
function.
Use the exprvars
function (or bddvars
, ttvars
) instead.
Finally all vestiges of the legacy BitVector
MDA methodology are gone.
Everything else was just miscellaneous code/test/documentation cleanup.
Version 0.24¶
Variables names are now required to be C-style identifiers.
I.e., [a-zA-Z_][a-zA-Z0-9_]*
.
The expression parser now handles both a[1][2][3]
and a[1,2,3]
syntaxes
(Issue 91).
The a[1][2][3]
is deprecated.
Got rid of expression is_neg_unate
, is_pos_unate
,
and is_binate
functions.
I haven’t been able to find an efficient algorithm for this,
so just convert expressions and BDDs to truth tables first.
If your function is too big to fit in a truth table,
it’s probably also too big to expand to a canonical expression.
Not(Not(...))
double negation is now automatically reduced,
just like Not(Nand(...))
, etc.
Cleaned up the definition of expression depth (Issue 92). This is not backwards compatible.
Fixed Issue 93, picosat script fails with trivial zero input:
$ picosat
p cnf 0 1
0
Changed RegexLexer
to yield EndToken
at the end of a token stream.
This makes parsing nicer, avoiding catching StopIteration
everywhere.
Got rid of factor=False
on expression factory functions.
This was overly designed UI.
The expression restrict
method is a little faster now.
Especially for big functions.
Added lots of new reference documentation.
Added new farray
documentation chapter.
Fixed several little issues with function arrays during this process.
The constructor now takes an ftype=None
parameter.
Negative indices make more sense now.
Slices behave more like Python tuple slices.
Fixed several inconsistencies with empty arrays.
Deprecated bitvec
function.
Version 0.23¶
This version introduces a new picosat
script.
Now you can solve DIMACS CNF files from the command-line.
See http://pyeda.readthedocs.org/en/latest/expr.html#picosat-script
for details.
Finally there is a proper documentation chapter for binary decision diagrams! While writing this documentation, I noticed, and fixed some obscure bugs related to incorrect usage of weak references to BDD nodes.
Made some minor changes to the public interface of the bdd
module.
Replaced the traverse
method with three options for BDD iteration:
bdd.dfs_preorder
- Depth-first search pre-order traversalbdd.dfs_postorder
- Depth-first search post-order traversalbdd.bfs()
- Breadth-first search
Got rid of the deprecated uint2bv
and int2bv
functions.
Use the uint2exprs
, int2exprs
functions instead.
Changed the pyeda.parsing.parse_pla
function so it takes a string input.
This makes it much easier to test.
Deprecated the is_neg_unate
, is_pos_unate
, is_binate
methods for expressions.
I haven’t found a correct algorithm that is better than just 1) converting
to a truth table, and 2) checking for monotonicity in the cofactors.
As of this release, I will be dropping support for Python 3.2.
Version 0.22¶
A couple features, and some good bug-fixes in this release.
Fixed Issue 80.
Apparently, I forgot to implement the right-side version of XOR operator: 0 ^ x
.
Fixed Issue 81.
I continue finding bugs with degenerate forms.
This particular one comes up when you try to do something similar to
Or(Or(a, b))
.
The __new__
method was implemented incorrectly,
so I moved the Or(a) = a
(and similar) rules to the simplify
method.
To match the notation used by Univ of Illinois VLSI class, I changed BDD low/high nodes to “lo”, and “hi”.
Got rid of the “minus” operator, a - b
.
This was previously implemented as a | ~b
,
but I don’t think it has merit anymore.
The farray
type now uses the +
operator for concatenation,
and *
for repetition.
These are very important features in SystemVerilog.
See Issue 77 for details.
Implemented the farray.__setitem__
method.
It is very useful to instantiate an farray
using exprzeros
,
and then programmatically assign indices one-by-one.
See Issue 78 for details.
To demonstrate some of the fancy, new farray
features,
I added the AES algorithm to the logic
package.
It manages to complete all the logic assignments,
but I haven’t been able to test its correctness yet,
because it explodes the memory on my machine.
At a bare minimum, it will be a nice test case for performance optimizations
necessary to handle large designs.
Version 0.21¶
Important bug fix! Issue 75.
Harnesser pointed out that Espresso was
returning some goofy results for
degenerate inputs (a literal or AND(lit, lit, ...)
).
The major new feature in this release is the farray
mult-dimensional
array (MDA) data type.
The implementation of BitVector
was a kludge –
it was built around the Expression
function type,
and didn’t support all the fancy things you could do with numpy slices.
All usage of the old Slicer
and BitVector
types has been eliminated,
and replaced by farray
.
This includes the bitvec
, uint2bv
, and int2bv
functions,
and the contents of the pyeda.logic
package (addition, Sudoku, etc).
Both uint2bv
and int2bv
are deprecated,
superceded by uint2exprs
and int2exprs
(or uint2bdds
, etc).
So far I haven’t deprecated bitvec
,
because it’s a very commonly-used function.
See Issue 68 for some details
on the farray
type.
My favorite part is the ability to multiplex an farray
using Python’s
slice syntax:
>>> xs = exprvars('x', 4)
>>> sel = exprvars('s', 2)
>>> xs[sel]
Or(And(~s[0], ~s[1], x[0]), And(s[0], ~s[1], x[1]), And(~s[0], s[1], x[2]), And(s[0], s[1], x[3]))
This even works with MDAs:
>>> xs = exprvars('x', 4, 4)
>>> sel = exprvars('s', 2)
>>> xs[0,sel]
Or(And(~s[0], ~s[1], x[0][0]), And(s[0], ~s[1], x[0][1]), And(~s[0], s[1], x[0][2]), And(s[0], s[1], x[0][3]))
Added AchillesHeel
function to expression parsing engine.
Eliminated the +
and *
operators for Boolean OR, AND, respectively.
This is annoying, but I need these operators for
Issue 77.
Sorry for any trouble, but that’s what major version zero is for :).
Version 0.20¶
Probably the most useful feature in this release is the espresso
script:
$ espresso -h
usage: espresso [-h] [-e {fast,ness,nirr,nunwrap,onset,strong}] [--fast]
[--no-ess] [--no-irr] [--no-unwrap] [--onset] [--strong]
[file]
Minimize a PLA file
positional arguments:
file PLA file (default: stdin)
optional arguments:
...
This script implements a subset of the functionality of the original
Espresso
command-line program.
It uses the new parse_pla
function in the pyeda.parsing.pla
module
to parse common PLA files.
Note that the script only intends to implement basic truth-table functionality
at the moment.
It doesn’t support multiple-valued variables,
and various other Espresso built-in features.
Added Espresso get_config
and set_config
functions,
to manipulate global configuration
New Bitvector
methods:
unor
- unary norunand
- unary nanduxnor
- unary xnor
Made BitVector
an immutable type.
As a result, dropped item assignment X[0] = a
,
zero extension X.zext(4)
, sign extension X.sext(4)
,
and append
method.
The BitVector
type now supports more overloaded operators:
X + Y
concatenate two bit vectorsX << n
return the bit vector left-shifted byn
placesX >> n
return the bit vector right-shifted byn
places
Both left shift and right shift are simple shifts–they use the default “carry-in” of zero.
Got rid of boolify
utility function.
It had been replaced over time by more sophisticated techniques.
There is a new Mux
factory function,
for multiplexing arbitrarily many input functions.
Update to PicoSAT 959. Check the homepage for details, but it looks like the only changes were related to header file documentation.
Added a neat capability to specify assumptions for SAT-solving using a with
statement.
It supports both literal and product-term forms:
>>> f = Xor(a, b, c)
>>> with a, ~b:
... print(f.satisfy_one())
{a: 1, b: 0, c: 0}
>>> with a & ~b:
... print(f.satisfy_one())
{a: 1, b: 0, c: 0}
At the moment, this only works for the satisfy_one
method,
because it is so handy and intuitive.
Version 0.19¶
Release 0.19.3¶
Enhanced error handling in the Espresso C extension.
Release 0.19.2¶
Added the espresso_tts
function,
which allows you to run Espresso on one or more TruthTable
instances.
Release 0.19.1¶
Fixed a bone-headed mistake: leaving espresso.h
out of the source
distribution.
One of these days I will remember to test the source distribution for all the
necessary files before releasing it.
Release 0.19.0¶
This is a very exciting release! After much hard work, PyEDA now has a C extension to the famous Espresso logic minimization software from Berkeley! See the new chapter on two-level logic minimization for usage information.
Also, after some feedback from users, it became increasingly obvious that
using the -+*
operators for NOT, OR, AND was a limitation.
Now, just like Sympy, PyEDA uses the ~|&^
operators for symbolic algebra.
For convenience, the legacy operators will issue deprecation warnings for now.
In some upcoming release, they will no longer work.
After other feedback from users, I changed the way Expression
string
representation works.
Now, the __str__
method uses Or
, And
, etc, instead of ascii
characters.
The idea is that the string representation now returns valid Python that can
be parsed by the expr
function (or the Python interpreter).
To provide support for fancy formatting in IPython notebook,
I added the new to_unicode
and to_latex
methods.
These methods also return fancy string representations.
For consistency, the uint2vec
and int2vec
functions have been renamed
to uint2bv
and int2bv
, respectively.
Since is_pos_unate
, is_neg_unate
, and is_binate
didn’t seem like
fundamental operations,
I remove them from the Function
base class.
Version 0.18¶
Release 0.18.1¶
Three minor tweaks in this release:
expr
/bdd
to_dot
methods now return undirected graphs.- Added
AchillesHeel
factory function toexpr
. - Fixed a few obscure bugs with simplification of
Implies
andITE
.
Release 0.18.0¶
New stuff in this release:
- Unified the
Expression
andNormalform
expression types, getting rid of the need for thenfexpr
module. - Added
to_dot
methods to bothExpression
andBinaryDecisionDiagram
data types.
Mostly incremental changes this time around.
My apologies to anybody who was using the nfexpr
module.
Lately, Expression
has gotten quite fast, especially with the addition
of the PicoSAT C extension.
The normal form data type as set(frozenset(int))
was not a proper
implementation of the Function
class,
so finally did away with it in favor of the new “encoded” representation that
matches the Dimacs CNF convention of mapping an index 1..N to each variable,
and having the negative index correspond to the complement.
So far this is only useful for CNF SAT-solving,
but may also come in handy for any future, fast operations on 2-level covers.
Also, somewhat awesome is the addition of the to_dot
methods.
I was playing around with IPython extensions,
and eventually hacked up a neat solution for drawing BDDs into the notebook.
The magic functions are published in my
ipython-magic repo.
See the
usage notes.
Using subprocess
is probably not the best way to interface with Graphviz,
but it works well enough without any dependencies.
Version 0.17¶
Release 0.17.1¶
Got rid of the assumptions
parameter from boolalg.picosat.satisfy_all
function, because it had no effect.
Read through picosat.h
to figure out what happened,
and you need to re-apply assumptions for every call to picosat_sat
.
For now, the usage model seems a little dubious, so just got rid of it.
Release 0.17.0¶
New stuff in this release:
- Added
assumptions=None
parameter to PicoSATsatisfy_one
andsatisfy_all
functions. This produces a very nice speedup in some situations. - Got rid of extraneous
picosat.py
Python wrapper module. Now the PicoSAT Python interface is implemented bypicosatmodule.c
. - Updated Nor/Nand operators to secondary status. That is, they now can be natively represented by symbolic expressions.
- Added a Brent-Kung adder to logic.addition module
- Lots of other miscellaneous cleanup and better error handling
Version 0.16¶
Release 0.16.3¶
Fixed bug: absorption algorithm not returning a fully simplified expression.
Release 0.16.2¶
Significantly enhance the performance of the absorption algorithm
Release 0.16.1¶
Fixed bug: PicoSAT module compilation busted on Windows
Release 0.16.0¶
New stuff in this release:
- Added Expression
complete_sum
method, to generate a normal form expression that contains all prime implicants. - Unicode expression symbols, because it’s awesome
- Added new Expression ForEach, Exists factory functions.
- Changed
frozenset
implementation ofOrAnd
andEqualBase
arguments back totuple
. The simplification aspects had an unfortunate performance penalty. Useabsorb
to get rid of duplicate terms in DNF/CNF forms. - Added flatten=False/True to Expression to_dnf, to_cdnf, to_cnf, to_ccnf methods. Often, flatten=False is faster at reducing to a normal form.
- Simplified absorb algorithm using Python sets.
- Expression added a new splitvar property, which implements a common heuristic to find a good splitting variable.
Version 0.15¶
Release 0.15.1¶
- Thanks to Christoph Gohlke, added build support for Windows platforms.
Release 0.15.0¶
This is probably the most exciting release of PyEDA yet! Integration of the popular PicoSAT fast C SAT solver makes PyEDA suitable for industrial-strength applications. Unfortunately, I have no idea how to make this work on Windows yet.
Here are the full release notes:
- Drop support for Python 2.7. Will only support Python 3.2+ going forward.
- Integrate PicoSAT, a compact SAT solver written in C.
- Added lots of new capabilities to Boolean expression parsing:
s ? d1 : d0
(ITE),p => q
(Implies), andp <=> q
(Equal) symbolic operators.- Full complement of explicit form Boolean operators:
Or
,And
,Xor
,Xnor
,Equal
,Unequal
,Nor
,Nand
,OneHot0
,OneHot
,Majority
,ITE
,Implies
,Not
- The
expr
function now simplifies by default, and hassimplify=True
, andfactor=False
parameters.
- New
Unequal
expression operator. - New
Majority
high-order expression operator. OneHot0
,OneHot
, andMajority
all have both disjunctive (conj=False
) and conjunctive (conj=True
) forms.- Add new
Expression.to_ast
method. This might replace theexpr2dimacssat
function in the future, - Fixed bug:
Xor.factor(conj=True)
returns non-equivalent expression. - Changed the meaning of
conj
parameter inExpression.factor
method. Now it is only used by the top-level, and not passed recursively. - Normal form expression no longer inherit from
Function
. They didn’t implement the full interface, so this just made sense. - Replaced
pyeda.expr.expr2dimacscnf
with a newpyeda.expr.DimacsCNF
class. This might be unified with normal form expressions in the future.
Version 0.14¶
Release 0.14.2¶
Fixed Issue #42.
There was a bug in the implementation of OrAnd
,
due to the new usage of a frozenset to represent the argument container.
With 0.14.1
, you could get this:
>>> And('a', 'b', 'c') == Or('a', 'b', 'c')
True
Now:
>>> And('a', 'b', 'c') == Or('a', 'b', 'c')
False
The ==
operator is only used by PyEDA for hashing,
and is not overloaded by Expression
.
Therefore, this could potentially cause some serious issues with Or
/And
expressions that prune arguments incorrectly.
Release 0.14.1¶
Fixed Issue #41.
Basically, the package metadata in the 0.14.0
release was incomplete,
so the source distribution only contained a few modules. Whoops.
Release 0.14.0¶
This release reorganizes the PyEDA source code around quite a bit, and introduces some awesome new parsing utilities.
Probably the most important new feature is the addition of the
pyeda.boolalg.expr.expr
function.
This function takes int
or str
as an input.
If the input is a str
instance, the function parses the input string,
and returns an Expression
instance.
This makes it easy to form symbolic expression without even having to declare
variables ahead of time:
>>> from pyeda.boolalg.expr import expr
>>> f = expr("-a * b + -b * c")
>>> g = expr("(-x[0] + x[1]) * (-x[1] + x[2])")
The return value of expr
function is not simplified by default.
This allows you to represent arbitrary expressions, for example:
>>> h = expr("a * 0")
>>> h
0 * a
>>> h.simplify()
0
- Reorganized source code:
- Moved all Boolean algebra (functions, vector functions) into a new package,
pyeda.boolalg
. - Split
arithmetic
intoaddition
andgray_code
modules. - Moved all logic functions (addition, gray code) into a new package,
pyeda.logic
. - Created new Sudoku module under
pyeda.logic
.
- Moved all Boolean algebra (functions, vector functions) into a new package,
- Awesome new regex-based lexical analysis class,
pyeda.parsing.RegexLexer
. - Reorganized the DIMACS parsing code:
- Refactored parsing code to use
RegexLexer
. - Parsing functions now return an abstract syntax tree,
to be used by
pyeda.boolalg.ast2expr
function. - Changed
dimacs.load_cnf
topyeda.parsing.dimacs.parse_cnf
. - Changed
dimacs.load_sat
topyeda.parsing.dimacs.parse_sat
. - Changed
dimacs.dump_cnf
topyeda.boolalg.expr2dimacscnf
. - Changed
dimacs.dump_sat
topyeda.boolalg.expr2dimacssat
.
- Refactored parsing code to use
- Changed constructors for
Variable
factories. Unifiednamespace
as just a part of thename
. - Changed interactive usage. Originally was
from pyeda import *
. Now usefrom pyeda.inter import *
. - Some more miscellaneous refactoring on logic expressions:
- Fixed weirdness with
Expression.simplified
implementation. - Added new private class
_ArgumentContainer
, which is now the parent ofExprOrAnd
,ExprExclusive
,ExprEqual
,ExprImplies
,ExprITE
. - Changed
ExprOrAnd
argument container to afrozenset
, which has several nice properties for simplification of AND/OR expressions.
- Fixed weirdness with
- Got rid of
pyeda.alphas
module. - Preliminary support for logic expression
complete_sum
method, for generating the set of prime implicants. - Use a “computed table” cache in BDD
restrict
method. - Use weak references to help with BDD garbage collection.
- Replace distutils with setuptools.
- Preliminary support for Tseitin encoding of logic expressions.
- Rename
pyeda.common
topyeda.util
.
Version 0.13¶
Wow, this release took a huge leap from version 0.12. We’re probably not ready to declare a “1.0”, but it is definitely time to take a step back from API development, and start focusing on producing useful documentation.
This is not a complete list of changes, but here are the highlights.
- Binary Decision Diagrams! The recursive algorithms used to implement this datatype are awesome.
- Unification of all Variable subclasses by using separate factory functions
(
exprvar
,ttvar
,bddvar
), but a common integer “uniqid”. - New “untyped point” is an immutable 2-tuple of variable uniqids assigned
to zero and one.
Also a new
urestrict
method to go along with it. Most important algorithms now use untyped points internally, because the set operations are very elegant and avoid dealing with which type of variable you are using. - Changed the Variable’s
namespace
argument to a tuple of strings. - Restricting a function to a 0/1 state no longer returns an integer. Now every function representation has its own zero/one representations.
- Now using the fantastic Logilab PyLint program!
- Truth tables now use the awesome stdlib array.array for internal representation.
- Changed the names of almost all Expression sublasses to ExprSomething.
the Or/And/Not operators are now functions.
This simplified lots of crummy
__new__
magic. - Expression instances to not automatically simplify,
but they do if you use Or/And/Not/etc with default
**kwargs
. - Got rid of
constant
andbinop
modules, of dubious value. - Added
is_zero
,is_one
,box
, andunbox
to Function interface. - Removed
reduce
,iter_zeros
, anditer_ones
from Function interface. - Lots of refactoring of SAT methodology.
- Finally implemented
unate
methods correctly for Expressions.
Version 0.12¶
- Lots of work in
pyeda.table
:- Now two classes,
TruthTable
, andPCTable
(for positional-cube format, which allowsX
outputs). - Implemented most of the
boolfunc.Function
API. - Tables now support
-
,+
,*
, andxor
operators.
- Now two classes,
- Using a set container for And/Or/Xor argument simplification results in about 30% speedup of unit tests.
- Renamed
boolfunc.iter_space
toboolfunc.iter_points
. - New
boolfunc.iter_terms
generator. - Changed
dnf=True
toconf=False
on several methods that give the option of returnin an expression in conjunctive or disjunctive form. - Added
conj=False
argument to all expressionfactor
methods. - New
Function.iter_domain
andFunction.iter_image
iterators. - Renamed
Function.iter_outputs
toFunction.iter_relation
. - Add
pyeda.alphas
module for a convenience way to grab all the a, b, c, d, … variables. Xor.factor
now returns a flattened form, instead of nested.
Version 0.11¶
Release 0.11.1¶
- Fixed bug #16:
Function.reduce
only implemented by Variable
Release 0.11.0¶
- In
pyeda.dimacs
changedparse_cnf
method name toload_cnf
- In
pyeda.dimacs
changedparse_sat
method name toload_sat
- In
pyeda.dimacs
added new methoddump_cnf
, to convert expressions to CNF-formatted strings. - In
pyeda.dimacs
added new methoddump_sat
, to convert expressions to SAT-formatted strings. - Variables now have a
qualname
attribute, to allow referencing a variable either by its local name or its fully-qualified name. - Function gained a
reduce
method, to provide a standard interface to reduce Boolean function implementations to their canonical forms. - Expressions gained a
simplify
parameter, to allow constructing unsimplified expressions. - Expressions gained an
expand
method, to implement Shannon expansion. - New if-then-else (ITE) expression type.
- NormalForm expressions now both support
-
,+
, and*
operators.