Updates Note

• Feb. 23, 2014, Version 8.1
  • Support UTF-8.
  • New built-ins: getpid/1, bp_current_resource/1.
  • Bug fixes and improvements:
    • Planner
    • between/3.
    • subtract/3.
    • Multiplication constraint
• Sep. 21, 2013, Version 8.0
  • The executable (BProlog/bp.exe for Windows and BProlog/bp for Unix) is a standalone application. It's unnecessary to set the environment variable BPDIR.
  • Interface with MiniSAT for Windows (Lingeling is used for Unix).
  • Performance improvements (compile time, tabled programs, the multiplication constraint).
  • Built-ins for planning problems (bp_plan/2-4, bp_plan_unbounded/2-4, bp_best_plan/2-4, bp_best_plan_unbounded/2-4).
  • The maximum arity of structures is extended to 268435455 (2**28-1).
  • Bug fixes
• Apr. 2, 2013, Version 7.8#5
  • Modeling for linear programming/mixed integer programming and SAT solvers ( Examples )
  • Improve the hash function used in tabling and hash-consing.
  • The debug command 'r' shows spy points without user's intervention.
• Jan. 5, 2012, Version 7.7
  • Sharing of ground compound terms in tabled subgoals and answers through hash-consing.
  • The eager_consume strategy is no longer supported. For planning problems, table mode declaration should be used instead to limit the number of answers to be tabled.
  • The new built-in acyclic_term/1 is added.
  • A bug fix in time_out/3 for Unix.
  • New hashing strategy is used to speed up findall and tabling.
  • Improvement of sort/2.
  • Improvement of the code generator for once(Call)
  • Use lookup3 by Bob Jenkins for the symbol table.
• Oct. 3, 2011, Version 7.6
  • Support of big integers (input, output, and all arithmetic functions), based on the package by Matt McCutchen.
  • Sharing of ground compound terms in generators and answers for findall/bagof/setof.
  • Disenable semi-naive optimization in tabling
  • Decouple the memory manager for findall/bagof/setof from that for dynamic clauses.
  • ISO-compliant assert/retract that fully reuses memory even with cuts and exceptions
  • The built-in set_call_cleanup/3 works with cuts and exceptions
  • A new C function named call_bp_term_catch(term) that regains control when an exception occurs during execution of term
  • New debugging features, including printing backtrace, undo, and setting print depth.
  • Suppress unnecessary "redo" and "fail" messages in traces for determinate calls.
  • Internal system predicates are no longer displayed in the trace in debug mode.
  • The parser prints out the source code rather than a list of tokens when reporting syntax errors.
  • Bug fixes in the compiler
  • A new flag, named compiling, which has three possible values: compactcode, debugcode, and profilecode.
  • An improvement of sort/2 avoids sorting when the given list is a sorted (ascending or descending) integer list.
  • In cumulative(Ss,Ds,Rs,Limit), Limit can be an integer or an integer domain variable.
  • Re-implementation of format/2,3.
  • ISO-related (updated to pass most of Ulrich Neumerkel's test cases)
  • '.' is no longer an operator.
  
  
• May 12, 2011, Version 7.5
  • '|' becomes a permanent operator. The following operators are permanent and cannot be redefined: '[]', '{}', ',', '.', ':-', and '|'.
  • writeq is redefined to be (almost?) compliant with the standard.
  • New arithmetic functions: atan2, xor, and div.
  • A change in the tokenizer makes it possible to parse terms such as 9..-1..1.
  • The notation Begin..Step..End is accepted in domain declarations. E.g., X :: 1..2..10.
  • The notation Begin..Step..End is accepted in foreach and list comprehensions. Examples:
    • foreach(X in 10..-1..1, writeln(X)).
    • L @= [X : X in 10..-1..1].
    • foreach(X in 0..0.1..1, writeln(X)).
    • L @= [X : X in 0..0.1..1]
  • Array access and list comprehension notations can occur on both sides of X @= Y and X @:= Y.
  • New labeling options in labeling(Opts,Vars): degree, down, updown, split, and reverse_split.
  • New indomain built-ins: indomain_down(Var), indomain_updown(Var), indomain_split(Var), and indomain_reverse_split(Var).
  • New built-in fd_degree/2. fd_degree(V,N) binds N with the degree of the variable V, i.e., the number of connected variables of V in the constraint network.
  • The global constraint count(V,L,Rel,Count) can occur in Boolean constraints (e.g., X#>2 #=> count(V,L,#=,2))
  • New global constraints path_from_to/3-4 and paths_from_to/2.
    • path_from_to(Start,End,[V1,V2,...,Vn]) ensures that there is a path from Start to End in the directed graph represented by the domain variables V1,...,Vn (same representation as in circuit([V1,V2,...,Vn])).
    • path_from_to(Start,End,[node(LabV1,V1),....,node(LabVn,Vn)],Lab) ensures that there is a path of vertices from Start to End (both are integers between 1 and n) all labeled with Lab (an integer) in the directed graph represented by the domain variables V1,V2,...,Vn where Labi (an integer domain variable) is the label assigned to Vi.
    • paths_from_to([(Start1,End1,Lab1),...,(StartK,EndK,LabK)],[node(LabV1,V1),....,node(LabVn,Vn)]) is a generalization of path_from_to/4 for multiple paths. It ensures that for each connection (Starti,Endi,Labi) there is a path of vertices all labeled with Labi from Starti to Endi in the directed graph represented by the domain variables V1,...,Vn such that no path intersects at any vertices.
  • Improvement in the GC policy. The new policy uses a water mark for the local stack and another water mark for the heap, and invokes GC whenever either water mark is reached. It is also smarter in deciding when and by how much to expand the stacks.
  • An improvement in the unification procedure for domain variables
  • Improve the implementation of mode-directed tabling
  • Bug fixes: in tabling, the entailment constraint, and the GC for the 64-bit version.
  
  
• March 9, 2010, Version 7.4
  • Support foreach/2-n and list comprehensions. A foreach call takes the form of foreach(E1 in D1, ..., Ek in Dk,Accs,LocalVars,Goal) or foreach(E1 in D1, ..., Ek in Dk,LocalVars,Accs,Goal), where LocalVars and Accs are optional, and a list comprehension takes the form of [T : E1 in D1, ..., Ek in Dk, LocalVars,Goal], where LocalVars and Goal are optional. See more details here.
  • Array subscript notation for lists and structures in arithmetic expressions, arithmetic constraints, and calls to @=/2. Examples: T=f(1,2,3),X is T[1]+T[2]+T[3].
  • The two atoms, minint and maxint, can be used as integers in arithmetic expressions. For example, X :: 0..maxint declares that X be a non-negative integer.
  • Improvements in the garbage collection policy (thanks to Bart Demoen for the benchmarks that revealed the weaknesses in the early garbage collector).
  • A bug fix in the LP/MIP interface.
  • New Prolog flags: contiguous_warning and stratified_warning
  • New syntax for matching clauses: A determinate matching clause takes the form 'H,G => B' and a nondeterminate matching clause takes the form 'H,G ?=> B'.
  
  
• Oct. 1, 2009, Version 7.3
  • Table constraints. A table or extensional constraint is either positive or negative. A positive constraint takes the form 'X in R' and a negative constraint takes the form 'X notin R' where X is a tuple variables (X1,...,Xn) or a list of tuples of variables [(X11,...,X1n),...,(Xm1,...,Xmn)], and R is a table defined as a set of tuples of integers where each tuple takes the form (a1,...,an).
  • Support of table modes. A table declaration takes the form ':-table p(M1,...,Mn):N.' where p/n is a predicate, Mi is a mode (which can be 'min','max','+','-',or '?'), and N is a limit on the number of answers to be tabled. If no limit is given, then it is assumed that only one answer is tabled.
  • Iteration built-ins: foreach(Iterators,LocalVars,Goal) and foreach(Iterators,LocalVars,Accumulators,Goal)
  • New global constraints: post_neqs/1 and post_disjunctive_tasks/1.
  • Time events are handled with top priority.
  • Binary equality constraints are further specialized.
  • Added global constraints: serialized/2, assignment/2, and assignment0/2.
  • 'Var in D' and 'Var notin D' can occur in Boolean constraints.
  • The unknown flag works again.
  • Improved version of call_cleanup/2.
  • A bug fix in the compiler.
  • A bug fix in the glpk interface.
  
  
• Feb. 8, 2009, Version 7.2
  • A glitch that results in slow-down because of gc is fixed by using time stamps and a better compaction algorithm.
  • Specialization of propagators for linear constraints.
  • Update of print_ans for displaying top-level answers: (1) no solicitation of ';' if it's known that no further answer exists; (2) bindings of variables whose names begin with '_' are not displayed; (3) ordering of variables is respected.
  • Change "%d" to "%\ld" so that long integers can be correctly printed on 64-bit machines. Change "ULONG" to "BPULONG" to avoid a name conflict with Windows.
  • Shorten start-up time.
  • A change was made so that L and U in "X in L..U" and "X notin L..U" can be any expressions that give integers.
  
  
• June 25, 2008, Version 7.1
  • Stack initialization are made unnecessary in TOAM Jr.. This improvement gives about a 10% speedup over Version 7.0 for Prolog programs. By and large, during the past year B-Prolog's speed for standard Prolog programs has been boosted on average by 65% on Windows and over 90% on Linux and Mac thanks to the new virtual machine TOAM Jr.
  • An improvement in compile speed for programs with large numbers of clauses.
  • An improvement of the performance of the memory manager. There is only a short pause now when the stack or the table area is expanded. The interrupt event (ctl-c) is handled with almost no delay.
  • An improvement of the debugger which leads to an order-of-magnitude reduction in memory consumption by programs run in the debug mode.
  • New functions added: log(Base,X), 'e' (2.7182818284590455), min(L), max(L), sum(L), float_fractional_part(X), and float_integer_part(X).
  • Redefinition of mod. Now X mod Y is equal to X-(integer(floor(X/Y))*Y).
  • A bug fix in directory_files/2.
  • The number of streams that can be open at a time is increased to 40 from 20.
  • The code generator generates faster code for if-then-else than before.
  • The following built-ins are modified to accept string file names: cl/1, consult/1,[]/1, compile/1, and load/1.
  • The compiler issues error messages when a program to be compiled contains an atom that is longer than 225 characters or a structure whose arity is bigger than 225.
  • A fix of a memory leak in findall when used with catch/throw.
  • Change of throw/1 to make it ISO compliant.
  • A critical section is used to control Timer threads and the main thread when shared data are accessed.
  • New global constraint: disjunctive_tasks(Starts,Durations) which is equivalent to cumulative(Starts,Durationss,Resources,Limit) where Resources and Limit are all unit. An edge finding algorithm is employed.
  • Improvements in constraint propagators: Global constraints (element/3, cumulative/3, X#=min(L), X#=max(L)), nonlinear constraints (X#=abs(Y),X#=abs(Y-Z)), and disjunctive constraints.
  • statistics/0 and statistics/2 are extended to show statistics on numbers of backtracks in labeling finite domain variables.
  • New directive multifile/1 added.
  
  
• June 8, 2007, Version 7.0
  • The redesigned virtual machine boosts the speed by 50% on average on Windows and between 60-80% on Linux.
  • Runtime test performed in tagging/untagging so that the Linux version runs on all Linux machines including RedHad and Suse.
  • Variable-length meta-calls (call/1..n)
  • The unifier posts dom and dom_any events when unifying two domain variables
  • Use /tmp if the current working directory or the specified directory is not writable
  • Speed improvement in the Java interface
  • Bug fixes and improvements in CGLIB
  • New built-ins (table_remove0 and table_remove(Goal)) for cleaning up table entries
  • New labeling built-ins and options.
    • labeling_mix/4,labeling_mix/3, and labeling_mix/2.
    • labeling_min/1,labeling_max/1
    • New options in labeling(Options,Vars): min,max,forward,backward,inout,ff_forward,ff_backward,ff_inout,ffc_forward,ffc_backward,ffc_inout,time_out(Time),and time_out(Time,Res).
  • New built-ins on directories and files (thanks to Paulo Moura for the draft standard):
    • call_cleanup/2
    • copy_file/2
    • delete_directory/1
    • delete_file/1
    • directory_exists/1
    • directory_files/2
    • file_base_name/2
    • file_directory_name/2
    • file_exists/1
    • file_property/2
    • file_stat/2
    • make_directory/1
    • rename_file/1
    • working_directory/1
  • The interface to GLPK 4.9 works in Windows, Linux and Mac versions but not the Solaris version.
  
  
• September 21, 2006, Version 6.9
  • A new memory manager is added, which allows automatic expansion of stacks (local and trail), heap, and other areas (table and program).
  • Changes made to make version 6.9 pass Peter Szabo and Peter Sszeredi's ISO Prolog compliance test suite (thanks to Peter Szabo for his help with the test).
  • Built-ins added: select/3, nextto/3, delete/3, nth0/3, nth1/3, last/2, permutation/2, flatten/2, sumlist/2, numlist/3, is_set/1, eliminate_duplicate/2, intersection/3, union/3, subset/2, subtract/3, and forall/2.
  • Global constraints scalar_product/4 and global_cardinality/2 added.
  • copy_term/2, findall/3, setof/3, and bagof/3 allow suspension variables in terms.
  • Attributed variables added: attvar/1,put_attr/3,get_attr/3,and del_attr/2.
  • copy_term_nat/2 added.
  • Improvements made so that large clauses (with tens of thousand subgoals) can be compiled and asserted.
  • An action rule can specify multiple event patterns of event(X,O) as long as the second arguments of the patterns share the same variable.
  • The post_event(Channels,O) can post the event object O to conjunctive and disjunctive channels. For a conjunctive channel (C1 /\ C2), only agents attached to both channel C1 and channel C2 receive the event. The call post_event(C1\/C2,O) posts the event to agents on both channels.
  • The primitive post_event_df(Channels,O) is similar to post_event(Channels,O) but agents on the channels are activated one at a time. While post_event does breadth-first posting, post_event_df does depth-first posting. The post_event_df(Channels,Flag,O) stops posting the event to the agents once Flag becomes non-variable.
  • Improvement of the unification procedure for suspension variables
  • event(X,O) can co-exist with ins events in action rules.
  • Bug fixes: setarg, global_heap_get/set, memory manager
  • Bug fixes in action rules (thanks to Bart Demoen), and in declaration of predefined predicates (thanks to Paulo Moura).
  • Changes needed to port Leuven version of CHR to B-Prolog (added option @ in format, term_variables/2, and portray_clause/[1,2]).
  • Added primitives for global heap variables (global_heap_get/2 and global_heap_set/2). The primitives on global heap variables can be used to implement term_ref/2 in GNU-Prolog and (partially) b_setval/2 and b_getval/2 in SWI-Prolog.
  • Environment variables are allowed in file names for compile/1, cl/1, consult/1, load/1, tell/1, and see/1.
  • Initialization code is executed after each binary code module in a file if the file contains multiple modules.
  
  
• Dec. 8, 2005, Version 6.8
  • Added interface to LP/MIP packages (GNU GLPK and CPLEX)
  • The tokenizer is modified such that $ can be part of an operator (needed for CPLEX constraints X $= Y, X $>= Y, and X =< Z).
  • Improvement of reification and global constraints: element, all_distinct, and circuit
  • Improvement of binary inequality constraints
  • Improvement of abs(X) #= Y
  • Improvement of circuit(L)
  • Re-implementation of X in D and X notin D.
  • Register overflow fixed.
  
  
• July 28, 2005, Version 6.7 #3
  • Re-implementation of cumulative/4.
  • New global constraint circuit/1
  • slight speed-up of the FD solver (around 3%)
  
  
• May 18, 2005, Version 6.7 #2
  • Fix of a memory leak in assert/retract/abolish.
  • Improvement of the performance of dynamic clauses.
  • Addition of a new built-in, get_cwd(X), for getting the current working directory.
  • An integer domain expression in X::D can be a list of intervals [l1..u1,...,ln..un].
  
  
• March 31, 2005, Version 6.7
  • Hashtables are all dynamic now. The size of a hashtable is expanded automatically if the number of elements is double the size of the bucket.
  • Modes are used in the compiler to generate more specialized programs. A predicate may be indexed on multiple arguments if mode is given.
  • Compile time is shortened for large programs because of the use of dynamic hashtables in the compiler.
  • Introduction of a new directive ":-eager_consume F/N" which informs the system to use the eager consumption strategy for the predicate "F/N". For tabled predicates that contain cuts or that reside in the scopes of cuts, the eager strategy should be used.
  • Speed improvement of the tabling system. For some programs in the CHAT benchmark suite and the parser atr, speed is almost doubled.
  • Macros are expanded at compile time. A predicate is treated as a macro if it is cut-free and contains only one clause. This optimization can be suppressed by setting the flag "macro_expansion" to "off".
  • Modified to support large memory address spaces used in Linux systems such as RedHad Enterprise.
  • Performance improvement of arithmetic equality (#=) and disequality (#>=) constraints (more than 10% speed-up over version 6.6).
  • Significant speed-up (more than 3 times faster than version 6.6) for CNF-form Boolean constraints (Conjunctive Normal Form, i.e., L1 #\/...#\/Ln #= 1).
  • Change of the definition of Vars :: D to represent sparse domains more efficiently.
  • New event types "generated" and "bound(X)" are introduced. The event type "mimmax(X)" is obsolete now.
  • Improvement of the debugger to enable the debugging of tabled predicates and action rules.
  • A watermark is used to check if garbage collection is needed. Garbage collection is invoked each time the top of the heap hits the watermark.
  • An unquoted file name like abc.txt in consult or compile is converted into quoted one automatically.
  • More frequent check of control-c during execution.
  • Bug fix in dynamic clauses that occurred with RedHat Linux.
  • Bug fix in unify_with_occurs_check/2.
  • All exceptions thrown by a user program are caught by the system if not caught by the user program.
  
  
• May 25, Version 6.6 #1
  • Significant performance improvement of tabling (see a paper published in ACM PPDP'04 for the latest experimental results).
  • The size limit of hash tables is removed so that programs that need big hash tables can be compiled and loaded.
  • Bug fixes in tabling.
  • Bug fixes in format/2.
  
  
• Sep. 2003, Version 6.5
  • Events are posted to Prolog only when there are handlers waiting for them, and events are combined if doing so does not change the behaviors of programs. This change leads to significant enhancement of performance.
  • Scrollbar is provided as a basic component type and several different types of cursors are supported. CGLIB supports all JAVA AWT components now.
  • Attributes are divided into constrainable and non-constrainable ones. While constrainable attributes can occur in constraints, non-constrainable attributes must be updated and accessed by using the cgSet and cgGet primitives. Programs developed for early versions may need to be changed to run on this new version.
  
  
• March 2003, Version 6.4
  • A significantly improved tabling system.
  • Bug fix in format/2 and write_canonical/1.
  • Slight improvement of the CLP(FD) solver.
  • Dynamic hashing adopted for interpreted clauses.
  • A bug fix in the Solaris version.
  • Space-efficient findall.
  
  
• June, 2002, Version 6.2
  • Timers and timer events (for Windows only)

    
          timer(T,Interval) 
               Create a timer T that posts a time(T) event every Interval milliseconds
           timer_start(T)
                Start the timer T.
           timer_stop(T)
                Stop the timer T.
           timer_kill(T)
                Kill the timer T.
           timer_set_interval(T,Interval)
                Set the interval of the timer T to Interval
    

  • CLP(Set) Constraints over finite sets

    
          Set variables
    
               X :: L..U
                    Declarae the domain of X. For example, X :: {}..{a,b,c}, Y::{1}..{1..3}
               clpset_var(V)
                    V is a set variable.
               clpset_low(V,Low)
                    The current lower bound of V is Low.
               clpset_up(V,Up) 
                    The current upper bound of V is Up.
               clpset_added(E,V) 
                    E is a definite element, i.e., an element included in the lower bound.
               clpset_excluded(E,V)
                    E has been forbidden for V. In other words, E has been excluded from the upper bound of V.
    
           Set expressions:
                 constant sets
                 variables
                 X /\ Y : intersection
                 X \/ Y : union
                 X \ Y : difference
                 \ X : complement
                 #X : cardinality
    
    
           Set constraints
               X #= Y
                 Sets X and Y are equal. 
               X #\= Y
                 Sets X and Y are different
               X subset Y
                 Sets X and Y are different
               X #<- Y
                 X is an element in Y
               X #<\- Y
                 X is not an element in Y
              X #<> Y
                 X and Y are disjoint
    
            Boolean constraints
               X #= Y : 
               X #\= Y
               X #==> Y : e.g. (X #<- S1) #=> (X #<- S2)
               X #\/ Y
               X #/\ Y
    
         

  • Formatted output

    
        format(Format,Data),
        format(Stream,Format,Data)
        

  • Standalone applications: The B-Prolog run-time system is initialized before the main() function is called. The user's applications do not need to call initialize_bp to initialize the B-Prolog runtime system.
  • More examples and applications added: clocks.pl, xml parser, klic compiler, etc.
  
  
• December 15th, 2001, Version 6.1
  • Finite-domains of ground terms supported.
  • Threaded dispatch of instructions. This gives 30-50% speedup on Linux, Solaris, and MacOsX.
  • Built-ins cannot be overwritten.
  • Performance improvement of the finite-domain constraint solver.
  • Bug fix in the unification procedure for bit-vector finite-domains.
  • Bug fix in profiler.
  • New built-ins.
    • A^rows @= Rows
    • A^columns @= Cols
    • susp_attach_term(X,T)
    • susp_attached_term(X,T)
    • cumulative/4

      
          cumulative(S,D,R,L)
             S: [S1,S2,...,Sn] is a list of variables representing start times for jobs
             D: [D1,D2,...,Dn] is a list of integers representing durations
             R: [R1,R2,...,Rn] is a list of integers representing units of a resource
             L: total units of the resource available at any one time.
      

    • diffn/1

      
           diffn([[X1,X2,..,Xn,L1,L2,..,Ln],...])
                The n-dimensional rectangles R1=[X1,X2...,Xn,L1,L2,...,Ln],...,Rn do 
                not overlap. Two rectangles R1=[P11,P12,...,P1n,L11,L12,...,L1n] and 
                R2=[P21,P22,...,P2n,L21,L22,...,L2n] do not overlap if there exists 
                at least one i such that the two edges  and 
                do not overlap.
      

    • count/3

      
           count(Val,List,RelOp,Count) : 
                The number of elements Elm in List that satisfies Elm RelOp Val is Count.
      

  
  
• August 15th, 2001, Version 6.0
  • Improvements of CGLIB: thick lines, lines with arrows, and text boxes.
  • in-line expansion of if-then-else.
  • Performance improvement of the reader.
  
  
• July, 2001, Version 6.0 beta
  • The constraint-based graphics library, CGLIB, supports event handling. This makes it possible to develop interactive user interfaces in B-Prolog and opens new application areas to B-Prolog such as drawing editors, interactive user interfaces, animation, information visualization, intelligent agents, and games. See the manual (Volume 2 on Graphics Programming, http://www.probp.com/download/cglib.htm ) for details and see http://www.probp.com/examples/index.html for dozens of examples.
  • The finite-domain constraint solver is improved significantly. The new solver is on average over 70% faster than the one in version 5.0 (measured on Linux) and consumes several times less space for certain programs.
  • New built-ins are introduced on arrays, hashtables, random numbers, date, time, and environment variables. See the manual (Volume 1, Chapter 2 on Data Types and Built-ins, http://www.probp.com/manual/node30.htm) for details.
  • A new construct, called action rules, is introduced, which replaces delay clauses as the construct for programming concurrency, event handling, constraint propagators and interactive user interfaces. User-defined events are supported. See the manual (Volume 1, Chapter 11 on Action Rules and Events, http://www.probp.com/manual/node71.html ) for details.
  • The manager for dynamic clauses employs a dynamic hashing algorithm now. Dynamic clauses can be asserted and accessed faster especially for large database programs.
  • All kinds of exceptions including those caused by built-ins and user's interruptions (control-c) can be caught and handled by using catch/3.
  • The interface with C is improved. Now it is possible to write C functions that extract solutions from Prolog programs incrementally. The interface with Java is remedied such that Java strings are converted into lists of character codes rather than atoms. This protocol is compliant with the original JIPL developed by Kino.
  • Other built-ins: environ/2, parse_atom/2, parse_string/2.