| Index Entry | | Section |
|---|
|
| ! | | |
|---|
| !, cut: | | ref-sem-ctr-cut |
| !/0 (built-in, ref page): | | mpg-ref-cut |
| !/0, cut: | | ref-sem-ctr-cut |
|
| # | | |
|---|
| # /2, boolean eor: | | CLPB Introduction |
| #/\ /2 (clpfd): | | Propositional Constraints |
| #< /2 (clpfd): | | Arithmetic Constraints |
| #<= /2 (clpfd): | | Propositional Constraints |
| #<=> /2 (clpfd): | | Reified Constraints |
| #<=> /2 (clpfd): | | Propositional Constraints |
| #= /2 (clpfd): | | Arithmetic Constraints |
| #=/2 (all_different/2 option): | | Arithmetic-Logical Constraints |
| #=/2 (all_distinct/2 option): | | Arithmetic-Logical Constraints |
| #=< /2 (clpfd): | | Arithmetic Constraints |
| #=> /2 (clpfd): | | Propositional Constraints |
| #> /2 (clpfd): | | Arithmetic Constraints |
| #>= /2 (clpfd): | | Arithmetic Constraints |
| #\ /1 (clpfd): | | Propositional Constraints |
| #\ /2 (clpfd): | | Propositional Constraints |
| #\/ /2 (clpfd): | | Propositional Constraints |
| #\= /2 (clpfd): | | Arithmetic Constraints |
|
| ' | | |
|---|
| '$VAR': | | ref-iou-tou-dis |
| 'SU_messages':generate_message/3: | | Message Handling Predicates |
| 'SU_messages':generate_message/3 (hook, ref page): | | mpg-ref-generate_message |
| 'SU_messages':query_abbreviation/3: | | Query Handling Predicates |
| 'SU_messages':query_abbreviation/3 (hook, ref page): | | mpg-ref-query_abbreviation |
| 'SU_messages':query_class/5: | | Query Handling Predicates |
| 'SU_messages':query_class/5 (hook, ref page): | | mpg-ref-query_class |
| 'SU_messages':query_hook/6 (hook, ref page): | | mpg-ref-query_hook |
| 'SU_messages':query_input/3: | | Query Handling Predicates |
| 'SU_messages':query_input/3 (hook, ref page): | | mpg-ref-query_input |
| 'SU_messages':query_map/4: | | Query Handling Predicates |
| 'SU_messages':query_map/4 (hook, ref page): | | mpg-ref-query_map |
|
| * | | |
|---|
| * /2, boolean and: | | CLPB Introduction |
| * /2, multiplication (evaluable): | | ref-ari-aex |
| ** /2, float power (evaluable): | | ref-ari-aex |
|
| + | | |
|---|
| + (CHR mode): | | CHR Constraint Declaration |
| + /1, identity (evaluable): | | ref-ari-aex |
| + /2, addition (evaluable): | | ref-ari-aex |
| + /2, boolean ior: | | CLPB Introduction |
| +, mode annotation: | | mpg-ref-mod |
|
| , | | |
|---|
| , atom: | | ref-syn-trm-ato |
| ,/2 (built-in, ref page): | | mpg-ref-and |
| ,/2 (iterator): | | ref-sem-ctr-dol |
| ,/2 (iterator): | | mpg-ref-do |
| ,/2 (when/2 condition): | | mpg-ref-when |
| ,/2, conjunction: | | ref-sem-ctr |
|
| - | | |
|---|
| - (CHR mode): | | CHR Constraint Declaration |
| - /1, negation (evaluable): | | ref-ari-aex |
| - /2, subtraction (evaluable): | | ref-ari-aex |
| -, mode annotation: | | mpg-ref-mod |
| -->, grammar rules: | | ref-gru-dcg |
| -/2 (debugger show control): | | Action Variables |
| -> /2 ;/2, if then else: | | ref-sem-ctr-ite |
| -> /2, if then: | | ref-sem-ctr-ite |
| -> ;, if-then-else: | | ref-sem-ctr-ite |
| ->/2 (built-in, ref page): | | mpg-ref-if_then |
|
| . | | |
|---|
| . /2, identity (evaluable): | | ref-ari-aex |
| ., functor: | | ref-syn-cpt-lis |
| .emacs Emacs initialization file: | | Quick-Start |
|
| / | | |
|---|
| / /2, floating division (evaluable): | | ref-ari-aex |
| // /2, integer truncated division (evaluable): | | ref-ari-aex |
| /\ /2, bitwise conjunction (evaluable): | | ref-ari-aex |
|
| 0 | | |
|---|
| 0’ notation for character conversion: | | ref-syn-trm-int |
|
| : | | |
|---|
| : /2, module qualifier: | | ref-sem-ctr-oth |
| :, use in meta_predicate declaration: | | ref-mod-met |
| :, use in Module:Goal: | | ref-mod-vis |
| :- /1, directive: | | Directives |
|
| ; | | |
|---|
| ;/2 (built-in, ref page): | | mpg-ref-or |
| ;/2 (when/2 condition): | | mpg-ref-when |
| ;/2, disjunction: | | ref-sem-ctr-dis |
|
| < | | |
|---|
| < /2, boolean less: | | CLPB Introduction |
| <, arithmetic less than: | | ref-ari-acm |
| <-/2 (objects): | | obj-exp-send |
| </2 (built-in, ref page): | | mpg-ref-less_than |
| << /2, left shift (evaluable): | | ref-ari-aex |
| <</2 (objects): | | obj-exp-put |
|
| = | | |
|---|
| =../2 (built-in): | | ref-lte-act |
| =../2 (built-in, ref page): | | mpg-ref-univ |
| =/0 (map method): | | Default Map Methods |
| =/2 (built-in): | | ref-lte-met-usu |
| =/2 (built-in, ref page): | | mpg-ref-unify |
| =/2 (clpfd:dispatch_global/4 request): | | The Global Constraint Programming Interface |
| =:= /2, boolean equal: | | CLPB Introduction |
| =:=, arithmetic equal: | | ref-ari-acm |
| =:=/2 (built-in, ref page): | | mpg-ref-equal_to |
| =< /2, boolean less or equal: | | CLPB Introduction |
| =<, arithmetic less or equal: | | ref-ari-acm |
| =</2 (built-in, ref page): | | mpg-ref-not_greater_than |
| ==/2 (built-in): | | ref-lte-cte-sot |
| ==/2 (built-in, ref page): | | mpg-ref-term_equal_to |
| =\= /2, boolean not equal: | | CLPB Introduction |
| =\=, arithmetic not equal: | | ref-ari-acm |
| =\=/2 (built-in, ref page): | | mpg-ref-not_equal_to |
|
| > | | |
|---|
| > /2, boolean greater: | | CLPB Introduction |
| >, arithmetic greater than: | | ref-ari-acm |
| >/2 (built-in, ref page): | | mpg-ref-greater_than |
| >= /2, boolean greater or equal: | | CLPB Introduction |
| >=, arithmetic greater or equal: | | ref-ari-acm |
| >=/2 (built-in, ref page): | | mpg-ref-not_less_than |
| >> /2, right shift (evaluable): | | ref-ari-aex |
| >>/2 (objects): | | obj-exp-get |
|
| ? | | |
|---|
| ? (CHR mode): | | CHR Constraint Declaration |
| ?, mode annotation: | | mpg-ref-mod |
| ?- /1, query: | | Queries |
| ?=/2 (built-in): | | ref-lte-met-usu |
| ?=/2 (built-in, ref page): | | mpg-ref-term_unify_decided |
| ?=/2 (when/2 condition): | | mpg-ref-when |
|
| @ | | |
|---|
| @</2 (built-in): | | ref-lte-cte-sot |
| @</2 (built-in, ref page): | | mpg-ref-term_less_than |
| @=</2 (built-in): | | ref-lte-cte-sot |
| @=</2 (built-in, ref page): | | mpg-ref-term_not_greater_than |
| @>/2 (built-in): | | ref-lte-cte-sot |
| @>/2 (built-in, ref page): | | mpg-ref-term_greater_than |
| @>=/2 (built-in): | | ref-lte-cte-sot |
| @>=/2 (built-in, ref page): | | mpg-ref-term_not_less_than |
|
| [ | | |
|---|
| [], empty grammar body: | | ref-gru-dcg |
| [], empty list: | | ref-syn-cpt-lis |
| []/0 (debugger condition): | | Other Tests |
|
| \ | | |
|---|
| \ /1, bitwise negation (evaluable): | | ref-ari-aex |
| \ /2, bitwise exclusive or (evaluable): | | ref-ari-aex |
| \" (escape sequence): | | ref-syn-syn-esc |
| \' (escape sequence): | | ref-syn-syn-esc |
| \+ /1, not provable: | | ref-sem-ctr-naf |
| \+/1 (built-in, ref page): | | mpg-ref-not_provable |
| \/ /2, bitwise disjunction (evaluable): | | ref-ari-aex |
| \= /2 (built-in): | | ref-lte-met-usu |
| \=/2 (built-in, ref page): | | mpg-ref-not_unifiable |
| \==/2 (built-in): | | ref-lte-cte-sot |
| \==/2 (built-in, ref page): | | mpg-ref-term_not_equal_to |
| \a (escape sequence): | | ref-syn-syn-esc |
| \b (escape sequence): | | ref-syn-syn-esc |
| \d (escape sequence): | | ref-syn-syn-esc |
| \e (escape sequence): | | ref-syn-syn-esc |
| \f (escape sequence): | | ref-syn-syn-esc |
| \LFD (escape sequence): | | ref-syn-syn-esc |
| \n (escape sequence): | | ref-syn-syn-esc |
| \octal-digit…\ (escape sequence): | | ref-syn-syn-esc |
| \r (escape sequence): | | ref-syn-syn-esc |
| \t (escape sequence): | | ref-syn-syn-esc |
| \v (escape sequence): | | ref-syn-syn-esc |
| \xhex-digit…\ (escape sequence): | | ref-syn-syn-esc |
| \\ (escape sequence): | | ref-syn-syn-esc |
| \` (escape sequence): | | ref-syn-syn-esc |
|
| ^ | | |
|---|
| ^ /2, boolean existential quantifier: | | CLPB Introduction |
| ^ /2, existential quantifier: | | ref-sem-ctr-oth |
| ^ /2, generic power (evaluable): | | ref-ari-aex |
| ^/2 (built-in): | | ref-all-cse-equ |
| ^/2 (built-in, ref page): | | mpg-ref-exists |
| ^/2 (input method): | | Default Input Methods |
|
| _ | | |
|---|
| _, anonymous variable: | | ref-syn-trm-var |
|
| { | | |
|---|
| {}/1 (clpqr): | | CLPQR Solver Predicates |
|
| | | | |
|---|
| |, list separator: | | ref-syn-cpt-lis |
|
| ~ | | |
|---|
| ~ /1, boolean not: | | CLPB Introduction |
|
| A | | |
|---|
| abolish (definition): | | Glossary |
| abolish/[1,2] (built-in): | | ref-mdb-rcd |
| abolish/[1,2] (built-in, ref page): | | mpg-ref-abolish |
| abort (CHR debug command): | | CHR Tracing |
| abort (debugger command): | | Debug Commands |
| abort/0 (built-in): | | ref-ere-int |
| abort/0 (built-in, ref page): | | mpg-ref-abort |
| abort/0 (debugger command control): | | Action Variables |
| abs /1, absolute value (evaluable): | | ref-ari-aex |
| absolute path: | | ref-fdi-syn |
| absolute path: | | ref-fdi-syn |
| absolute_file_name/[2,3] (built-in, ref page): | | mpg-ref-absolute_file_name |
| accept (top-level command): | | Queries |
| accepted_hosts/1 (start/1 option): | | PB Prolog Server Interface |
| access to streams, random: | | ref-iou-raf |
| access/1 (absolute_file_name/3 option): | | mpg-ref-absolute_file_name |
| accumulating parameter: | | Accumulating Parameters |
| acos /1, (evaluable): | | ref-ari-aex |
| acosh /1, (evaluable): | | ref-ari-aex |
| acot /1, (evaluable): | | ref-ari-aex |
| acot2 /2, (evaluable): | | ref-ari-aex |
| acoth /1, (evaluable): | | ref-ari-aex |
| action condition, breakpoint: | | Action Conditions |
| action execution, breakpoint: | | Breakpoint Actions |
| action variables, debugger: | | Breakpoint Actions |
| action variables, debugger: | | Action Variables |
| action, breakpoint: | | Creating Breakpoints |
| action, breakpoint: | | Breakpoint Actions |
| acyclic_term/1 (built-in, ref page): | | mpg-ref-acyclic_term |
| acyclic_term/2 (built-in): | | ref-lte-act |
| address, socket: | | lib-sockets |
| add_breakpoint/2 (built-in): | | Breakpoint Predicates |
| add_breakpoint/2 (built-in, ref page): | | mpg-ref-add_breakpoint |
| add_edges/3 (ugraphs): | | lib-ugraphs |
| add_edges/3 (wgraphs): | | lib-wgraphs |
| add_element/3 (sets): | | lib-sets |
| add_vertices/3 (ugraphs): | | lib-ugraphs |
| add_vertices/3 (wgraphs): | | lib-wgraphs |
| advice breakpoint: | | Advanced Debugging |
| advice breakpoint: | | Advice points |
| advice point (definition): | | Glossary |
| advice/0 (debugger condition): | | Advice points |
| advice/0 (debugger condition): | | Other Tests |
| agc_count (statistics key): | | ref-mgc-ove-sta |
| agc_freed (statistics key): | | ref-mgc-ove-sta |
| agc_margin (prolog flag): | | ref-lps-flg |
| agc_margin (prolog flag): | | ref-mgc-ago-agc |
| agc_margin (prolog flag): | | Atoms in C |
| agc_nbfreed (statistics key): | | ref-mgc-ove-sta |
| agc_time (statistics key): | | ref-mgc-ove-sta |
| aggregate/3 (aggregate): | | lib-aggregate |
| aggregate/4 (aggregate): | | lib-aggregate |
| aggregate_all/3 (aggregate): | | lib-aggregate |
| aggregate_all/4 (aggregate): | | lib-aggregate |
| aggregation: | | lib-aggregate |
| alias, of a stream: | | ref-iou-sfh-sob |
| alias, stream (definition): | | Glossary |
| alias, stream (definition): | | Glossary |
| alias/1 (open/4 option): | | ref-iou-sfh-sob |
| alias/1 (open/4 option): | | mpg-ref-open |
| alias/1 (stream property): | | mpg-ref-stream_property |
| all (absolute_file_name/3 solutions): | | mpg-ref-absolute_file_name |
| all (labeling/2 option): | | Enumeration Predicates |
| all (maximize/3 option): | | Enumeration Predicates |
| all (minimize/3 option): | | Enumeration Predicates |
| all solutions, predicates for: | | ref-all-sum |
| all solutions, predicates for: | | mpg-top-all |
| all/1 (plunit option): | | PlUnit A Unit Test Box |
| all_different/[1,2] (clpfd): | | Arithmetic-Logical Constraints |
| all_different_except_0/1 (clpfd): | | Arithmetic-Logical Constraints |
| all_distinct/[1,2] (clpfd): | | Arithmetic-Logical Constraints |
| all_distinct_except_0/1 (clpfd): | | Arithmetic-Logical Constraints |
| all_equal/1 (clpfd): | | Arithmetic-Logical Constraints |
| all_equal_reif/2 (clpfd): | | Arithmetic-Logical Constraints |
| alphanumeric (definition): | | Glossary |
| among/3 (lex_chain/2 option): | | Arithmetic-Logical Constraints |
| among/3 (scalar_product/5 option): | | Arithmetic Constraints |
| analysis, coverage: | | Coverage Analysis |
| ancestor goal: | | Debug Format |
| ancestor/2 (debugger condition): | | Accessing Past Debugger States |
| ancestor/2 (debugger condition): | | Goal Tests |
| ancestors (CHR debug command): | | CHR Tracing |
| ancestors (debugger command): | | Debug Commands |
| ancestors (definition): | | Glossary |
| and: | | ref-sem-ctr |
| annotate goal (debugger command): | | FDBG Debugger Commands |
| annotation: | | FDBG Names of Terms |
| anonymous variable: | | ref-syn-trm-var |
| anonymous variable (definition): | | Glossary |
| ANSI conformance: | | Function Prototypes |
| anti_first_fail (labeling/2 option): | | Enumeration Predicates |
| any (absolute_file_name/3 file type): | | mpg-ref-absolute_file_name |
| anystretchocc/1 (automaton/9 option): | | Sequence Constraints |
| API: | | Mixing C and Prolog |
| append (absolute_file_name/3 access): | | mpg-ref-absolute_file_name |
| append (open/[3,4] mode): | | mpg-ref-open |
| append, avoiding: | | Accumulating Lists |
| append/3 (built-in): | | ref-lte-acl |
| append/3 (built-in, ref page): | | mpg-ref-append |
| append/[2,5] (lists): | | lib-lists |
| appending, to existing files: | | ref-iou-sfh-opn |
| append_length/[3,4] (lists): | | lib-lists |
| append_queue/3 (queues): | | lib-queues |
| application builder: | | The Application Builder |
| apply (CHR port): | | CHR Ports |
| arg/3 (built-in): | | ref-lte-act |
| arg/3 (built-in, ref page): | | mpg-ref-arg |
| argument (definition): | | Glossary |
| argument (definition): | | ref-syn-cpt |
| arguments of terms: | | ref-lte-act |
| arguments, command-line: | | Start |
| arguments, reference page field: | | mpg-ref-ove |
| arguments, types of: | | mpg-ref |
| arguments, types of: | | mpg-ref-aty |
| argv (prolog flag): | | ref-lps-flg |
| argv (prolog flag): | | Initializing the Prolog Engine |
| argv (prolog flag): | | too-sicstus |
| arithmetic and character codes: | | ref-ari-aex |
| arithmetic equality: | | ref-ari-acm |
| arithmetic errors: | | ref-ari-exc |
| arithmetic exceptions: | | ref-ari-exc |
| arithmetic expression: | | ref-ari-aex |
| arithmetic expressions, evaluating: | | ref-ari-eae |
| arithmetic functors: | | ref-ari-aex |
| arithmetic limits: | | ref-ari-ove |
| arithmetic, predicates for: | | ref-ari-sum |
| arithmetic, predicates for: | | mpg-top-ari |
| arithmetic_mean/2 (statistics): | | lib-statistics |
| arity (argument type): | | mpg-ref-aty-ety |
| arity (definition): | | Glossary |
| arity, of a functor: | | ref-syn-cpt |
| asin /1, (evaluable): | | ref-ari-aex |
| asinh /1, (evaluable): | | ref-ari-aex |
| ask/0 (debugger command control): | | Action Variables |
| ask_query/4 (built-in): | | Query Handling Predicates |
| ask_query/4 (built-in, ref page): | | mpg-ref-ask_query |
| ASPX: | | PB Features |
| assert/[1,2] (built-in): | | ref-mdb-acd |
| assert/[1,2] (built-in, ref page): | | mpg-ref-assert |
| asserta/[1,2] (built-in): | | ref-mdb-acd |
| asserta/[1,2] (built-in, ref page): | | mpg-ref-asserta |
| assertion and retraction predicates: | | ref-mdb-bas |
| assertz/[1,2] (built-in): | | ref-mdb-acd |
| assertz/[1,2] (built-in, ref page): | | mpg-ref-assertz |
| assignment, destructive: | | ref-lte-mut |
| assignment/[2,3] (clpfd): | | Arithmetic-Logical Constraints |
| association list: | | lib-assoc |
| association list: | | lib-avl |
| associativity of operators: | | ref-syn-ops-ove |
| assoc_to_list/2 (assoc): | | lib-assoc |
| assumptions/1 (labeling/2 option): | | Enumeration Predicates |
| asynchronously, calling Prolog: | | Calling Prolog Asynchronously |
| atan /1, (evaluable): | | ref-ari-aex |
| atan2 /2, (evaluable): | | ref-ari-aex |
| atanh /1, (evaluable): | | ref-ari-aex |
| atom (definition): | | Glossary |
| atom (double_quotes flag value): | | ref-lps-flg |
| atom garbage collection: | | ref-mgc-ago |
| atom, one-char (definition): | | Glossary |
| atom/1 (built-in, ref page): | | mpg-ref-atom |
| atomic term (definition): | | Glossary |
| atomic/1 (built-in, ref page): | | mpg-ref-atomic |
| atomic_type/[1,2,3] (structs): | | str-etr |
| atoms: | | ref-syn-trm-ato |
| atoms (statistics key): | | ref-mgc-ove-sta |
| atoms, canonical representation of: | | Atoms in C |
| atoms_nbfree (statistics key): | | ref-mgc-ove-sta |
| atoms_nbused (statistics key): | | ref-mgc-ove-sta |
| atoms_used (statistics key): | | ref-mgc-ove-sta |
| atom_chars/2 (built-in): | | ref-lte-c2t |
| atom_chars/2 (built-in): | | ref-lte-c2t |
| atom_chars/2 (built-in, ref page): | | mpg-ref-atom_chars |
| atom_codes/2 (built-in): | | ref-lte-c2t |
| atom_codes/2 (built-in): | | ref-lte-c2t |
| atom_codes/2 (built-in, ref page): | | mpg-ref-atom_codes |
| atom_concat/3 (built-in): | | ref-lte-atm |
| atom_concat/3 (built-in, ref page): | | mpg-ref-atom_concat |
| atom_garbage_collection (statistics key): | | ref-mgc-ove-sta |
| atom_length/2 (built-in): | | ref-lte-atm |
| atom_length/2 (built-in, ref page): | | mpg-ref-atom_length |
| attribute declaration: | | lib-atts |
| attribute/1 (declaration): | | lib-atts |
| attributed variables: | | lib-atts |
| attribute_goal/2 (Module): | | lib-atts |
| at_end_of_line/[0,1] (built-in): | | ref-iou-cin-elf |
| at_end_of_line/[0,1] (built-in, ref page): | | mpg-ref-at_end_of_line |
| at_end_of_stream/[0,1] (built-in): | | ref-iou-cin-elf |
| at_end_of_stream/[0,1] (built-in, ref page): | | mpg-ref-at_end_of_stream |
| auto-generation of names: | | FDBG Name Auto-Generation |
| automaton/[3,8,9] (clpfd): | | Sequence Constraints |
| aux (table/3 method/1 value): | | Extensional Constraints |
| avl_change/5 (avl): | | lib-avl |
| avl_delete/4 (avl): | | lib-avl |
| avl_del_max/4 (avl): | | lib-avl |
| avl_del_min/4 (avl): | | lib-avl |
| avl_domain/2 (avl): | | lib-avl |
| avl_fetch/2 (avl): | | lib-avl |
| avl_fetch/3 (avl): | | lib-avl |
| avl_height/2 (avl): | | lib-avl |
| avl_incr/4 (avl): | | lib-avl |
| avl_map/2 (avl): | | lib-avl |
| avl_map/3 (avl): | | lib-avl |
| avl_max/2 (avl): | | lib-avl |
| avl_max/3 (avl): | | lib-avl |
| avl_member/2 (avl): | | lib-avl |
| avl_member/3 (avl): | | lib-avl |
| avl_min/2 (avl): | | lib-avl |
| avl_min/3 (avl): | | lib-avl |
| avl_next/3 (avl): | | lib-avl |
| avl_next/4 (avl): | | lib-avl |
| avl_prev/3 (avl): | | lib-avl |
| avl_prev/4 (avl): | | lib-avl |
| avl_range/2 (avl): | | lib-avl |
| avl_size/2 (avl): | | lib-avl |
| avl_store/4 (avl): | | lib-avl |
| avl_to_list/2 (avl): | | lib-avl |
| avoiding append: | | Accumulating Lists |
|
| B | | |
|---|
| bab (labeling/2 option): | | Enumeration Predicates |
| backtrace: | | Debug Commands |
| backtrace: | | Accessing Past Debugger States |
| backtrace (debugger command): | | Debug Commands |
| backtrace (definition): | | Glossary |
| backtracking: | | ref-sem-sec |
| backtracking: | | ref-sem-sec |
| backtracking (definition): | | Glossary |
| backtracking, terminating a loop: | | Terminating a Backtracking Loop |
| backtracks (fd_statistics/2 option): | | Statistics Predicates |
| backtracks (zinc option value): | | MiniZinc Exported Predicates |
| backward-paragraph (emacs command): | | Usage |
| bag: | | lib-bags |
| bagof/3 (built-in): | | ref-all-cba |
| bagof/3 (built-in, ref page): | | mpg-ref-bagof |
| bagof_rd_noblock/3 (linda_client): | | lib-linda-client |
| bag_add_element/4 (bags): | | lib-bags |
| bag_del_element/4 (bags): | | lib-bags |
| bag_intersect/2 (bags): | | lib-bags |
| bag_intersection/2 (bags): | | lib-bags |
| bag_intersection/2 (bags): | | lib-bags |
| bag_length/3 (bags): | | lib-bags |
| bag_max/2 (bags): | | lib-bags |
| bag_max/3 (bags): | | lib-bags |
| bag_member/3 (bags): | | lib-bags |
| bag_memberchk/3 (bags): | | lib-bags |
| bag_min/2 (bags): | | lib-bags |
| bag_min/2 (bags): | | lib-bags |
| bag_subtract/3 (bags): | | lib-bags |
| bag_to_list/2 (bags): | | lib-bags |
| bag_to_ord_set/2 (bags): | | lib-bags |
| bag_to_ord_set/3 (bags): | | lib-bags |
| bag_to_set/2 (bags): | | lib-bags |
| bag_to_set/3 (bags): | | lib-bags |
| bag_union/2 (bags): | | lib-bags |
| bag_union/3 (bags): | | lib-bags |
| bbkey (argument type): | | mpg-ref-aty-ety |
| bb_delete/2 (built-in): | | ref-mdb-bbd |
| bb_delete/2 (built-in, ref page): | | mpg-ref-bb_delete |
| bb_get/2 (built-in): | | ref-mdb-bbd |
| bb_get/2 (built-in, ref page): | | mpg-ref-bb_get |
| bb_inf/[3,5] (clpqr): | | CLPQR Solver Predicates |
| bb_inf/[3,5] (clpqr): | | CLPQR Solver Predicates |
| bb_put/2 (built-in): | | ref-mdb-bbd |
| bb_put/2 (built-in, ref page): | | mpg-ref-bb_put |
| bb_update/3 (built-in): | | ref-mdb-bbd |
| bb_update/3 (built-in, ref page): | | mpg-ref-bb_update |
| begin_tests/[1,2] (plunit declaration): | | PlUnit A Unit Test Box |
| best (labeling/2 option): | | Enumeration Predicates |
| best (maximize/3 option): | | Enumeration Predicates |
| best (minimize/3 option): | | Enumeration Predicates |
| between/3 (between): | | lib-between |
| bid/1 (debugger condition): | | Built-in Predicates for Breakpoint Handling |
| bid/1 (debugger condition): | | Port Tests |
| binary tree: | | lib-assoc |
| binary tree: | | lib-avl |
| binding (definition): | | Glossary |
| bin_packing/2 (clpfd): | | Placement Constraints |
| bisect (labeling/2 option): | | Enumeration Predicates |
| blackboard: | | ref-mdb-bbd |
| block (predicate property): | | mpg-ref-predicate_property |
| block declaration: | | Block Declarations |
| block/0 (debugger port value): | | Port Tests |
| block/1 (built-in, ref page): | | mpg-ref-block |
| block/1 (declaration): | | Block Declarations |
| block/1 (predicate property): | | ref-lps-app |
| blocked goal: | | Debug Format |
| blocked goal (definition): | | Glossary |
| blocked goals (debugger command): | | Debug Commands |
| blocked goals (debugger command): | | FDBG Debugger Commands |
| blocked/1 (plunit option): | | PlUnit A Unit Test Box |
| body (definition): | | Glossary |
| body of a clause: | | ref-sem-pro |
| bof (seek/4 method): | | mpg-ref-seek |
| bool_and/2 (clpfd): | | Arithmetic-Logical Constraints |
| bool_channel/4 (clpfd): | | Arithmetic-Logical Constraints |
| bool_or/2 (clpfd): | | Arithmetic-Logical Constraints |
| bool_xor/2 (clpfd): | | Arithmetic-Logical Constraints |
| bound/1 (cumulatives/3 option): | | Scheduling Constraints |
| bounded (prolog flag): | | ref-lps-flg |
| bounding_box/2 (geost/[2,3,4] option): | | Placement Constraints |
| bounds (all_different/2 consistency/1 value): | | Arithmetic-Logical Constraints |
| bounds (all_distinct/2 consistency/1 value): | | Arithmetic-Logical Constraints |
| bounds (global_cardinality/3 consistency/1 value): | | Arithmetic-Logical Constraints |
| bounds (scalar_product/5 consistency/1 value): | | Arithmetic Constraints |
| bounds-consistent: | | Definitions |
| bounds-disentailed: | | Definitions |
| bounds-entailed: | | Definitions |
| box, invocation: | | Procedure Box |
| box, invocation (definition): | | Glossary |
| box, procedure: | | Procedure Box |
| box, procedure (definition): | | Glossary |
| break: | | Nested |
| break (CHR debug command): | | CHR Tracing |
| break (debugger command): | | Debug Commands |
| break (top-level command): | | Queries |
| break/0 (built-in): | | Nested |
| break/0 (built-in): | | ref-lod-rpx |
| break/0 (built-in): | | ref-ere-int |
| break/0 (built-in, ref page): | | mpg-ref-break |
| breakpoint (definition): | | Glossary |
| breakpoint action: | | Creating Breakpoints |
| breakpoint action: | | Breakpoint Actions |
| breakpoint action condition: | | Action Conditions |
| breakpoint action execution: | | Breakpoint Actions |
| breakpoint condition: | | Creating Breakpoints |
| breakpoint conditions: | | Breakpoint Conditions |
| breakpoint handling predicates: | | Breakpoint Predicates |
| breakpoint identifier: | | Creating Breakpoints |
| breakpoint processing: | | Breakpoint Processing |
| breakpoint specification: | | Creating Breakpoints |
| breakpoint specification (definition): | | Glossary |
| breakpoint test: | | Creating Breakpoints |
| breakpoint test condition: | | Goal Tests |
| breakpoint, advice: | | Advanced Debugging |
| breakpoint, advice: | | Advice points |
| breakpoint, debugger: | | Advanced Debugging |
| breakpoint, generic: | | Specific and Generic Breakpoints |
| breakpoint, line: | | Usage |
| breakpoint, setting: | | Usage |
| breakpoint, specific: | | Specific and Generic Breakpoints |
| breakpoint_expansion/2 (hook, ref page): | | mpg-ref-breakpoint_expansion |
| breakpoint_expansion/2 (user, hook): | | Hooks Related to Breakpoints |
| breakpoint_expansion/2 (user, hook): | | Condition Macros |
| break_level/1 (debugger condition): | | Break Tests |
| break_level/1 (debugger condition): | | Past States |
| buffer (definition): | | Glossary |
| builder, application: | | The Application Builder |
| built-in operators: | | ref-syn-ops-ove |
| built-in operators, list of: | | ref-syn-ops-bop |
| built-in predicate (definition): | | Glossary |
| built-in predicates, annotations: | | mpg-ref-cat |
| built-in predicates, list of: | | mpg-top |
| built_in (predicate property): | | mpg-ref-predicate_property |
| built_in/0 (predicate property): | | ref-lps-app |
| Button (Tk event type): | | Event Handling |
| button (Tk widget): | | Types of Widget |
| ButtonPress (Tk event type): | | Event Handling |
| ButtonRelease (Tk event type): | | Event Handling |
| byte (argument type): | | mpg-ref-aty-ety |
| byte list (definition): | | Glossary |
| byte_count/2 (built-in): | | ref-iou-sfh-opn |
| byte_count/2 (built-in): | | ref-iou-sos |
| byte_count/2 (built-in, ref page): | | mpg-ref-byte_count |
|
| C | | |
|---|
| C errors, functions for: | | cpg-top-err |
| C functions for Exceptions: | | cpg-top-exc |
| C functions for File and Stream Handling: | | cpg-top-fst |
| C functions for Foreign Interface: | | cpg-top-fin |
| C functions for I/O: | | cpg-top-cio |
| C functions for initialization: | | cpg-top-main |
| C functions for memory management: | | cpg-top-mem |
| C functions for signal handling: | | cpg-top-sig |
| C functions for terms: | | cpg-top-tic |
| C functions for type tests: | | cpg-top-typ |
| C functions, return values, errors: | | cpg-rve |
| call (CHR port): | | CHR Ports |
| call (leashing mode): | | Basic Debug |
| call errors: | | ref-sem-exc |
| call exceptions: | | ref-sem-exc |
| call, procedure: | | ref-sem-pro |
| call, procedure: | | ref-sem-sec |
| call/0 (debugger port value): | | Port Tests |
| call/1 (clpfd:dispatch_global/4 request): | | The Global Constraint Programming Interface |
| call/[1,2,...,255] (built-in, ref page): | | mpg-ref-call |
| callable term (definition): | | Glossary |
| callable/1 (built-in, ref page): | | mpg-ref-callable |
| calling Prolog asynchronously: | | Calling Prolog Asynchronously |
| calling Prolog from C: | | Calling Prolog from C |
| CallSpec: | | Terminology |
| call_cleanup/2 (built-in, ref page): | | mpg-ref-call_cleanup |
| call_residue_vars/2 (built-in, ref page): | | mpg-ref-call_residue_vars |
| canonical representation of atoms: | | Atoms in C |
| canvas (Tk widget): | | Types of Widget |
| card/2, boolean cardinality: | | CLPB Introduction |
| case-normalized path: | | ref-fdi-syn |
| case/[3,4] (clpfd): | | Extensional Constraints |
| cast/1 (structs): | | str-cas |
| Casting: | | str-cas |
| catch/3 (built-in): | | ref-ere-hex-pgo |
| catch/3 (built-in, ref page): | | mpg-ref-catch |
| catching unknown procedures: | | ref-mdb-dsp |
| ceiling /1, (evaluable): | | ref-ari-aex |
| central_moment/3 (statistics): | | lib-statistics |
| changing prompt: | | ref-iou-tin-cpr |
| changing type-in module: | | ref-mod-tyi |
| char (argument type): | | mpg-ref-aty-ety |
| char list (definition): | | Glossary |
| char/1 (map method): | | Default Map Methods |
| character code (definition): | | Glossary |
| character code set (definition): | | Glossary |
| character codes, arithmetic and: | | ref-ari-aex |
| character codes, lists of: | | ref-syn-cpt-sli |
| character encoding: | | ref-iou-sfh-enc |
| character escaping: | | ref-syn-ces |
| character I/O, predicates for: | | ref-iou-sum |
| character I/O, predicates for: | | mpg-top-cio |
| character set: | | ref-syn-syn-tok |
| character set: | | ref-iou-sfh-enc |
| character, EOF: | | Keyboard Characters |
| character, interrupt: | | Keyboard Characters |
| character-conversion: | | mpg-ref-char_conversion |
| character-conversion: | | mpg-ref-current_char_conversion |
| character-conversion mapping (definition): | | Glossary |
| character-type mapping (definition): | | Glossary |
| characters, conversion to character code: | | ref-syn-trm-int |
| characters, conversion to integers: | | ref-ari-aex |
| characters, input and output of: | | ref-iou-cin |
| characters, strings of: | | ref-syn-cpt-sli |
| character_count/2 (built-in): | | ref-iou-sfh-opn |
| character_count/2 (built-in): | | ref-iou-sos |
| character_count/2 (built-in, ref page): | | mpg-ref-character_count |
| chars (argument type): | | mpg-ref-aty-ety |
| chars (double_quotes flag value): | | ref-lps-flg |
| char_code/2 (built-in): | | ref-lte-c2t |
| char_code/2 (built-in): | | ref-lte-c2t |
| char_code/2 (built-in, ref page): | | mpg-ref-char_code |
| char_conversion (prolog flag): | | Glossary |
| char_conversion (prolog flag): | | ref-lps-flg |
| char_conversion/2 (built-in, ref page): | | mpg-ref-char_conversion |
| check, occurs (definition): | | Glossary |
| checkbag/2 (bags): | | lib-bags |
| checkbutton (Tk widget): | | Types of Widget |
| checker, constraint: | | Sequence Constraints |
| checking indexicals: | | Indexicals |
| check_guard_bindings (CHR option): | | CHR Semantics |
| choice (statistics key): | | ref-mgc-ove-sta |
| choice stack: | | ref-mgc-ove |
| choicepoints (definition): | | Glossary |
| CHOICESTKSIZE (system property): | | System Properties and Environment Variables |
| choice_free (statistics key): | | ref-mgc-ove-sta |
| choice_used (statistics key): | | ref-mgc-ove-sta |
| chr_constraint/1 (CHR declaration): | | CHR Constraint Declaration |
| chr_flag/3 (chr): | | CHR Debugging Predicates |
| chr_leash/1 (chr): | | CHR Debugging Predicates |
| chr_notrace/0 (chr): | | CHR Debugging Predicates |
| chr_option/2 (CHR declaration): | | CHR Semantics |
| chr_show_store/1 (chr): | | CHR Debugging Predicates |
| chr_trace/0 (chr): | | CHR Debugging Predicates |
| chr_type/1 (CHR declaration): | | CHR Constraint Declaration |
| circuit/1 (all_different/2 option): | | Arithmetic-Logical Constraints |
| circuit/1 (all_distinct/2 option): | | Arithmetic-Logical Constraints |
| circuit/1 (assignment/3 option): | | Arithmetic-Logical Constraints |
| circuit/[1,2] (clpfd): | | Graph Constraints |
| clash, name: | | ref-mod-ncl |
| clash, name (definition): | | Glossary |
| class/1 (objects): | | obj-exp-class |
| classes, error: | | ref-ere-err |
| Classname, Fully Qualified: | | Jasper Library Predicates |
| class_ancestor/2 (objects): | | obj-exp-class_ancestor |
| class_method/1 (objects): | | obj-exp-class_method |
| class_of/2 (objects): | | obj-exp-class_of |
| class_superclass/2 (objects): | | obj-exp-class_superclass |
| clause: | | ref-sem-pro |
| clause (definition): | | Glossary |
| clause, guarded: | | Conditionals and Disjunction |
| clause, guarded (definition): | | Glossary |
| clause, instance of: | | ref-sem-sec |
| clause, unit: | | ref-sem-pro |
| clause, unit (definition): | | Glossary |
| clause/[2,3] (built-in): | | ref-mdb-acl |
| clause/[2,3] (built-in, ref page): | | mpg-ref-clause |
| clauseref/5 (source information descriptor): | | mpg-ref-goal_source_info |
| clauses, database references to: | | ref-mdb-dre |
| clauses, declarative interpretation of: | | ref-sem-sec |
| clauses, printing: | | ref-iou-tou-pcl |
| clauses, procedural interpretation of: | | ref-sem-sec |
| cleanup/1 (plunit option): | | PlUnit A Unit Test Box |
| close (Tcl command): | | Commands |
| close on SPQuery: | | Jasper Package Class Reference |
| close/1 (built-in): | | ref-iou-sfh-cst |
| close/[1,2] (built-in, ref page): | | mpg-ref-close |
| close_all_streams/0 (file_systems): | | lib-file_systems |
| close_client/0 (linda_client): | | lib-linda-client |
| closing a file: | | ref-iou-sfh-cst |
| closing a stream: | | ref-iou-sfh-cst |
| clpfd:dispatch_global/4: | | The Global Constraint Programming Interface |
| clpfd:full_answer/0: | | Answer Constraints |
| CLSID: | | Terminology |
| clumped/2 (lists): | | lib-lists |
| clumps/2 (lists): | | lib-lists |
| code (argument type): | | mpg-ref-aty-ety |
| code list (definition): | | Glossary |
| code, character (definition): | | Glossary |
| code, glue (definition): | | Glossary |
| code, source (definition): | | Glossary |
| code, unreachable: | | Xref Introduction |
| codes (argument type): | | mpg-ref-aty-ety |
| codes (double_quotes flag value): | | ref-lps-flg |
| collection, garbage: | | ref-lps-flg |
| collection, garbage (definition): | | Glossary |
| colored resource: | | Scheduling Constraints |
| colored/1 (multi_cumulative/[2,3] resource): | | Scheduling Constraints |
| comclient_clsid_from_progid/2 (comclient): | | COM Client Predicates |
| comclient_create_instance/2 (comclient): | | COM Client Predicates |
| comclient_equal/2 (comclient): | | COM Client Predicates |
| comclient_exception_code/2 (comclient): | | COM Client Predicates |
| comclient_exception_culprit/2 (comclient): | | COM Client Predicates |
| comclient_exception_description/2 (comclient): | | COM Client Predicates |
| comclient_garbage_collect/0 (comclient): | | COM Client Predicates |
| comclient_get_active_object/2 (comclient): | | COM Client Predicates |
| comclient_iid_from_name/2 (comclient): | | COM Client Predicates |
| comclient_invoke_method_fun/3 (comclient): | | COM Client Predicates |
| comclient_invoke_method_proc/2 (comclient): | | COM Client Predicates |
| comclient_invoke_put/3 (comclient): | | COM Client Predicates |
| comclient_is_exception/1 (comclient): | | COM Client Predicates |
| comclient_is_object/1 (comclient): | | COM Client Predicates |
| comclient_name_from_iid/2 (comclient): | | COM Client Predicates |
| comclient_progid_from_clsid/2 (comclient): | | COM Client Predicates |
| comclient_release/1 (comclient): | | COM Client Predicates |
| comclient_valid_object/1 (comclient): | | COM Client Predicates |
| ComInArg: | | Terminology |
| ComInArg: | | Terminology |
| comint-interrupt-subjob (emacs command): | | Usage |
| comint-quit-subjob (emacs command): | | Usage |
| command (debugger command): | | Debug Commands |
| command-line arguments: | | Start |
| command/1 (debugger condition): | | Breakpoint Actions |
| command/1 (debugger condition): | | Port Tests |
| command/1 (debugger condition): | | Action Conditions |
| commands, debug: | | Debug Commands |
| comment-dwim (emacs command): | | Usage |
| communication, process: | | lib-linda |
| communication, process: | | lib-sockets |
| compactcode (compiling flag value): | | ref-lod-ove |
| compactcode (compiling flag value): | | ref-lps-flg |
| compactcode (definition): | | Glossary |
| compare/3 (built-in, ref page): | | mpg-ref-compare |
| comparison of terms: | | ref-lte-cte |
| comparison, of numbers: | | ref-ari-acm |
| compilation, JIT: | | ref-lod-ove |
| compilation, JIT: | | System Properties and Environment Variables |
| compilation_mode/1 (load_files/2 option): | | mpg-ref-load_files |
| compile (definition): | | Glossary |
| compile-buffer (emacs command): | | Usage |
| compile-file (emacs command): | | Usage |
| compile-predicate (emacs command): | | Usage |
| compile-region (emacs command): | | Usage |
| compile/1 (built-in): | | ref-mod-lod |
| compile/1 (built-in, ref page): | | mpg-ref-compile |
| compiled (predicate property): | | mpg-ref-predicate_property |
| compiled/0 (predicate property): | | ref-lps-app |
| compiling: | | Run Intro |
| compiling (prolog flag): | | Glossary |
| compiling (prolog flag): | | ref-lod-ove |
| compiling (prolog flag): | | ref-lps-flg |
| complement/2 (ugraphs): | | lib-ugraphs |
| compose/3 (ugraphs): | | lib-ugraphs |
| compound term (definition): | | Glossary |
| compound, terms: | | ref-syn-cpt |
| compound/1 (built-in, ref page): | | mpg-ref-compound |
| computation rule: | | ref-sem-sec |
| ComValue: | | Terminology |
| concat (Tcl command): | | Commands |
| concepts, FDBG: | | FDBG Concepts |
| condition, breakpoint: | | Creating Breakpoints |
| condition/1 (plunit option): | | PlUnit A Unit Test Box |
| conditional compilation: | | ref-lod-cnd |
| conditional compilation (definition): | | Glossary |
| conditional spypoint: | | Creating Breakpoints |
| conditionals: | | Conditionals and Disjunction |
| conditions, breakpoint: | | Breakpoint Conditions |
| conformance, ANSI: | | Function Prototypes |
| conjunction: | | ref-sem-ctr |
| conjunction (definition): | | Glossary |
| connection_timeout/1 (odbc_db_open/4 option): | | ODBC Predicates |
| cons/3 (lists): | | lib-lists |
| consistency errors: | | ref-ere-err-cns |
| consistency/1 (all_different/2 option): | | Arithmetic-Logical Constraints |
| consistency/1 (all_distinct/2 option): | | Arithmetic-Logical Constraints |
| consistency/1 (assignment/3 option): | | Arithmetic-Logical Constraints |
| consistency/1 (global_cardinality/3 option): | | Arithmetic-Logical Constraints |
| consistency/1 (scalar_product/5 option): | | Arithmetic Constraints |
| consistency_error/[3,4] (error class): | | ref-ere-err |
| consistent store: | | CLPFD Interface |
| console-based executable (definition): | | Glossary |
| constant: | | ref-syn-trm-ove |
| constant (definition): | | Glossary |
| constraint: | | CLPFD Interface |
| constraint checker: | | Sequence Constraints |
| constraint event: | | FDBG Events |
| constraint, global: | | The Global Constraint Programming Interface |
| constraints (fd_statistics/2 option): | | Statistics Predicates |
| constraints (zinc option value): | | MiniZinc Exported Predicates |
| constraints, forgetting: | | Forgetting Constraints |
| constraints, posting: | | Posting Constraints |
| consult (definition): | | Glossary |
| consult-buffer (emacs command): | | Usage |
| consult-file (emacs command): | | Usage |
| consult-predicate (emacs command): | | Usage |
| consult-region (emacs command): | | Usage |
| consult/1 (built-in, ref page): | | mpg-ref-consult |
| consulting: | | Run Intro |
| consulting: | | Reading In |
| consume_layout/1 (read_term/[2,3] option): | | mpg-ref-read_term |
| contains_term/2 (terms): | | lib-terms |
| contains_var/2 (terms): | | lib-terms |
| context errors: | | ref-ere-err-con |
| context, load: | | ref-lps-lco |
| context-free grammars: | | ref-gru-dcg |
| context_error/[2,3] (error class): | | ref-ere-err |
| contradictory store: | | CLPFD Interface |
| control constructs in grammar rules: | | ref-gru-dcg |
| control structure: | | ref-sem-ctr |
| control structure (definition): | | Glossary |
| control, predicates for: | | ref-sem-con |
| control, predicates for: | | mpg-top-con |
| conversions, term: | | Support Functions |
| converting into module files: | | ref-mod-n2m |
| convlist/3 (lists): | | lib-lists |
| copy_term/[2,3] (built-in): | | ref-lte-cpt |
| copy_term/[2,3] (built-in, ref page): | | mpg-ref-copy_term |
| core (statistics key): | | ref-mgc-ove-sta |
| corners/1 (geost/[2,3,4] option): | | Placement Constraints |
| correlation/3 (statistics): | | lib-statistics |
| correspond/4 (lists): | | lib-lists |
| cos /1, (evaluable): | | ref-ari-aex |
| cosh /1, (evaluable): | | ref-ari-aex |
| cost/2 (all_different/2 option): | | Arithmetic-Logical Constraints |
| cost/2 (all_distinct/2 option): | | Arithmetic-Logical Constraints |
| cost/2 (assignment/3 option): | | Arithmetic-Logical Constraints |
| cost/2 (global_cardinality/3 option): | | Arithmetic-Logical Constraints |
| cot /1, (evaluable): | | ref-ari-aex |
| coth /1, (evaluable): | | ref-ari-aex |
| count /3, (iterator): | | ref-sem-ctr-dol |
| count/3 (iterator): | | mpg-ref-do |
| count/4 (clpfd): | | Arithmetic-Logical Constraints |
| counter: | | Execution Profiling |
| counterseq/1 (automaton/9 option): | | Sequence Constraints |
| covariance/3 (statistics): | | lib-statistics |
| coverage analysis: | | Coverage Analysis |
| coverage site: | | Coverage Analysis |
| coverage_data/1 (built-in): | | Coverage Analysis |
| coverage_data/1 (built-in, ref page): | | mpg-ref-coverage_data |
| create/2 (objects): | | obj-exp-create |
| create_mutable/2 (built-in): | | ref-lte-mut |
| create_mutable/2 (built-in, ref page): | | mpg-ref-create_mutable |
| creating new files: | | ref-iou-sfh-opn |
| creep (CHR debug command): | | CHR Tracing |
| creep (debugger command): | | Debug Commands |
| creep (definition): | | Glossary |
| cross-referencer: | | Xref Introduction |
| cumlist/[4,5,6] (lists): | | lib-lists |
| cumulative resource: | | Scheduling Constraints |
| cumulative/1 (geost/[2,3,4] option): | | Placement Constraints |
| cumulative/1 (multi_cumulative/[2,3] resource): | | Scheduling Constraints |
| cumulative/[1,2] (clpfd): | | Scheduling Constraints |
| cumulatives/[2,3] (clpfd): | | Scheduling Constraints |
| current (seek/4 method): | | mpg-ref-seek |
| current frame: | | Debug Format |
| current frame: | | Debug Commands |
| current input: | | ref-iou-str |
| current input stream: | | ref-iou-sfh-sob |
| current input streams: | | ref-iou-sfh-opn |
| current input streams: | | ref-iou-sfh-cis |
| current input streams: | | ref-iou-sfh-cos |
| current operators: | | ref-syn-ops-ops |
| current output: | | ref-iou-str |
| current output stream: | | ref-iou-sfh-sob |
| current output streams: | | ref-iou-sfh-opn |
| current output streams: | | ref-iou-sfh-cis |
| current output streams: | | ref-iou-sfh-cos |
| current stream: | | ref-iou-sfh-bos |
| currently loaded modules: | | ref-mod-mpc-cmo |
| currently loaded modules: | | ref-mod-ilm |
| current_atom/1 (built-in, ref page): | | mpg-ref-current_atom |
| current_breakpoint/5 (built-in): | | Built-in Predicates for Breakpoint Handling |
| current_breakpoint/5 (built-in): | | Breakpoint Predicates |
| current_breakpoint/5 (built-in, ref page): | | mpg-ref-current_breakpoint |
| current_char_conversion/2 (built-in, ref page): | | mpg-ref-current_char_conversion |
| current_class/1 (objects): | | obj-exp-current_class |
| current_directory/[1,2] (file_systems): | | lib-file_systems |
| current_host/1 (sockets): | | lib-sockets |
| current_input/1 (built-in): | | ref-iou-sfh-cis |
| current_input/1 (built-in, ref page): | | mpg-ref-current_input |
| current_key/2 (built-in): | | ref-mdb-idb |
| current_key/2 (built-in, ref page): | | mpg-ref-current_key |
| current_module/[1,2] (built-in): | | ref-mod-ilm |
| current_module/[1,2] (built-in, ref page): | | mpg-ref-current_module |
| current_op/3 (built-in): | | ref-syn-ops-ops |
| current_op/3 (built-in, ref page): | | mpg-ref-current_op |
| current_output/1 (built-in): | | ref-iou-sfh-cos |
| current_output/1 (built-in, ref page): | | mpg-ref-current_output |
| current_predicate/2 (built-in): | | ref-mod-ilm-def |
| current_predicate/[1,2] (built-in, ref page): | | mpg-ref-current_predicate |
| current_prolog_flag/2 (built-in, ref page): | | mpg-ref-current_prolog_flag |
| current_stream/3 (built-in): | | ref-iou-sfh-bos |
| current_stream/3 (built-in, ref page): | | mpg-ref-current_stream |
| cursor (definition): | | Glossary |
| customize-group (emacs command): | | Customizing Emacs |
| customize-variable (emacs command): | | Customizing Emacs |
| cut: | | Cut Overview |
| cut (definition): | | Glossary |
| cut and generate-and-test: | | Terminating a Backtracking Loop |
| cut on SPQuery: | | Jasper Package Class Reference |
| cut, green: | | ref-sem-ctr-cut |
| cut, local: | | ref-sem-ctr-ite |
| cut, placement of: | | Placement of Cuts |
| cut, red: | | ref-sem-ctr-cut |
| cut, soft: | | ref-sem-ctr-ite |
| cycles/1 (read_term/[2,3] option): | | mpg-ref-read_term |
| cycles/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| cyclic list: | | Glossary |
| cyclic term: | | mpg-ref-read_term |
| cyclic term: | | mpg-ref-write_term |
| cyclic terms: | | ref-sem-occ |
| cyclic_term/1 (terms): | | lib-terms |
|
| D | | |
|---|
| data areas, used by Prolog: | | ref-mgc |
| data resource: | | too-spld |
| data tables: | | Data Tables |
| data type: | | ref-syn-trm-ove |
| data types, foreign: | | lib-structs |
| database: | | ref-sls |
| database: | | LMDB Basics |
| database (definition): | | Glossary |
| database modification: | | ref-mdb |
| database reference: | | ref-mdb-dre |
| database references to clauses: | | ref-mdb-dre |
| database, internal: | | ref-mdb-idb |
| database, loading: | | ref-sls-ove |
| database, predicates for: | | ref-mdb-sum |
| database, predicates for: | | mpg-top-dat |
| database, saving: | | ref-sls-ove |
| data_file/1 (zinc option): | | MiniZinc Exported Predicates |
| datime/[1,2] (system): | | lib-system |
| db-spec: | | LMDB DB-Spec Intro |
| db_reference (definition): | | Glossary |
| db_reference/1 (built-in, ref page): | | mpg-ref-db_reference |
| DCG: | | ref-gru-dcg |
| dcg, grammar rule expansion: | | mpg-ref-term_expansion |
| dcgc_count (statistics key): | | ref-mgc-ove-sta |
| dcgc_time (statistics key): | | ref-mgc-ove-sta |
| debug (CHR option): | | CHR Semantics |
| debug (debugging flag value): | | ref-lps-flg |
| debug (debugging flag value): | | mpg-ref-debugging |
| debug (definition): | | Glossary |
| debug (FD flag): | | The Global Constraint Programming Interface |
| debug (prolog flag): | | ref-lps-flg |
| debug (prolog flag): | | Runtime Systems |
| debug commands: | | Debug Commands |
| debug/0 (built-in): | | Basic Debug |
| debug/0 (built-in, ref page): | | mpg-ref-debug |
| debug/0 (debugger mode control): | | Action Variables |
| debugcode (compiling flag value): | | ref-lod-ove |
| debugcode (compiling flag value): | | ref-lps-flg |
| debugcode (definition): | | Glossary |
| debugger action variables: | | Breakpoint Actions |
| debugger action variables: | | Action Variables |
| debugger breakpoint: | | Advanced Debugging |
| debugger port: | | Port Tests |
| debugger, port: | | Procedure Box |
| debugger-ancestor: | | Goal Tests |
| debugger-parent: | | Goal Tests |
| debugger/0 (debugger condition): | | Advice points |
| debugger/0 (debugger condition): | | Other Tests |
| debugger/0 (map method): | | Default Map Methods |
| debugger_command_hook/2 (hook, ref page): | | mpg-ref-debugger_command_hook |
| debugger_command_hook/2 (user, hook): | | Hooks Related to Breakpoints |
| debugger_command_hook/2 (user, hook): | | Breakpoint Predicates |
| debugger_print_options (prolog flag): | | ref-lps-flg |
| debugger_print_options (prolog flag): | | Debug Intro |
| debugger_print_options (prolog flag): | | Debug Commands |
| debugger_print_options (prolog flag): | | Breakpoint Actions |
| debugger_print_options (prolog flag): | | Action Variables |
| debugger_print_options (prolog flag): | | Runtime Systems |
| debugger_print_options (prolog flag): | | mpg-ref-portray |
| debugger_print_options (prolog flag): | | mpg-ref-write_term |
| debugging: | | Debug Intro |
| debugging (debugger command): | | Debug Commands |
| debugging (prolog flag): | | ref-lps-flg |
| debugging (prolog flag): | | Runtime Systems |
| debugging messages: | | Debug Format |
| debugging modules: | | ref-mod-cim |
| debugging predicates: | | Basic Debug |
| debugging, predicates for: | | Debug Summary |
| debugging, predicates for: | | mpg-top-deb |
| debugging/0 (built-in): | | Undefined Predicates |
| debugging/0 (built-in): | | Basic Debug |
| debugging/0 (built-in, ref page): | | mpg-ref-debugging |
| debug_message/0 (objects): | | obj-exp-debug_message |
| dec10 (syntax_errors flag value): | | ref-lps-flg |
| dec10 (syntax_errors flag value): | | ref-ere-err-syn |
| declaration (definition): | | Glossary |
| declaration (predicate annotation): | | mpg-ref-cat |
| declaration, attribute: | | lib-atts |
| declaration, block: | | Block Declarations |
| declaration, discontiguous: | | Discontiguous Declarations |
| declaration, dynamic: | | Dynamic Declarations |
| declaration, include: | | Include Declarations |
| declaration, is/2: | | Is2 Declarations |
| declaration, meta-predicate: | | Meta-Predicate Declarations |
| declaration, meta_predicate: | | ref-mod-met |
| declaration, mode: | | Mode Declarations |
| declaration, module: | | Module Declarations |
| declaration, module: | | ref-mod-lod |
| declaration, multifile: | | Multifile Declarations |
| declaration, operator: | | ref-lod-dcl |
| declaration, predicate: | | ref-lod-dcl |
| declaration, public: | | Public Declarations |
| declaration, volatile: | | Volatile Declarations |
| declarations, mode: | | ref-mod-met |
| declarative semantics: | | ref-sem-sec |
| declaring nondeterminacy: | | Declaring Nondeterminacy |
| declaring operators: | | ref-syn-ops-ops |
| decreasing_prefix/[3,4] (lists): | | lib-lists |
| default (open/4 if_exists value): | | mpg-ref-open |
| default (table/3 method/1 value): | | Extensional Constraints |
| define_method/3 (objects): | | obj-exp-define_method |
| definite clause grammars: | | ref-gru-dcg |
| definition, procedure: | | ref-sem-sec |
| defragmentation (statistics key): | | ref-mgc-ove-sta |
| defrag_count (statistics key): | | ref-mgc-ove-sta |
| defrag_time (statistics key): | | ref-mgc-ove-sta |
| deinit function: | | Conversion Declarations |
| deinit function (definition): | | Glossary |
| delete (delete_directory/2 if_nonempty option value): | | lib-file_systems |
| delete/[3,4] (lists): | | lib-lists |
| delete_directory/[1,2] (file_systems): | | lib-file_systems |
| delete_file/1 (file_systems): | | lib-file_systems |
| del_edges/3 (ugraphs): | | lib-ugraphs |
| del_edges/3 (wgraphs): | | lib-wgraphs |
| del_element/3 (sets): | | lib-sets |
| del_vertices/3 (ugraphs): | | lib-ugraphs |
| del_vertices/3 (wgraphs): | | lib-wgraphs |
| deprecated (predicate annotation): | | mpg-ref-cat |
| depth/1 (debugger condition): | | Breakpoint Tests |
| depth/1 (debugger condition): | | Goal Tests |
| depth_bound/2 (terms): | | lib-terms |
| descendant_of/2 (objects): | | obj-exp-descendant_of |
| destroy/1 (objects): | | obj-exp-destroy |
| destructive assignment: | | ref-lte-mut |
| determinacy checker: | | The Determinacy Checker |
| determinacy detection, last clause: | | Last Clause Determinacy Detection |
| determinacy detection, via indexing: | | Determinacy Detection |
| determinate (definition): | | Glossary |
| development (predicate annotation): | | mpg-ref-cat |
| development system: | | Development and Runtime Systems |
| development system (definition): | | Glossary |
| dialect (prolog flag): | | ref-lod-cnd |
| dialect (prolog flag): | | ref-lps-flg |
| dif/2 (built-in): | | ref-lte-met-usu |
| dif/2 (built-in, ref page): | | mpg-ref-dif |
| diffn/[1,2] (clpfd): | | Placement Constraints |
| direction/1 (close/2 option): | | mpg-ref-close |
| directive: | | Start |
| directive: | | Queries and Directives |
| directive: | | ref-sem-pro |
| directive: | | ref-sem-pro |
| directive (definition): | | Glossary |
| directives, in files being compiled: | | ref-lod-lod |
| directories: | | lib-file_systems |
| directory (absolute_file_name/3 file type): | | mpg-ref-absolute_file_name |
| directory (load context key): | | ref-lps-lco |
| directory specification: | | ref-fdi-fsp |
| directory_exists/1 (file_systems): | | lib-file_systems |
| directory_exists/2 (file_systems): | | lib-file_systems |
| directory_members_of_directory/[1,2,3] (file_systems): | | lib-file_systems |
| directory_member_of_directory/2 (file_systems): | | lib-file_systems |
| directory_member_of_directory/3 (file_systems): | | lib-file_systems |
| directory_member_of_directory/4 (file_systems): | | lib-file_systems |
| directory_must_exist/1 (file_systems): | | lib-file_systems |
| directory_must_exist/2 (file_systems): | | lib-file_systems |
| directory_property/[2,3] (file_systems): | | lib-file_systems |
| direct_message/4 (objects): | | obj-exp-direct_message |
| disable this (debugger command): | | Debug Commands |
| disable_breakpoints/1 (built-in): | | Breakpoint Predicates |
| disable_breakpoints/1 (built-in, ref page): | | mpg-ref-disable_breakpoints |
| discontiguous declaration: | | Discontiguous Declarations |
| discontiguous/1 (built-in, ref page): | | mpg-ref-discontiguous |
| discontiguous/1 (declaration): | | Discontiguous Declarations |
| discontiguous_warnings (prolog flag): | | ref-lod-lod |
| discontiguous_warnings (prolog flag): | | Discontiguous Declarations |
| discontiguous_warnings (prolog flag): | | ref-lps-flg |
| discontiguous_warnings (prolog flag): | | Runtime Systems |
| discrepancy/1 (labeling/2 option): | | Enumeration Predicates |
| disjoint/2 (sets): | | lib-sets |
| disjoint1/[1,2] (clpfd): | | Placement Constraints |
| disjoint2/[1,2] (clpfd): | | Placement Constraints |
| disjoint_union/3 (sets): | | lib-sets |
| disjunction: | | ref-sem-ctr-dis |
| disjunction: | | Conditionals and Disjunction |
| disjunction (definition): | | Glossary |
| disjunctive/1 (geost/[2,3,4] option): | | Placement Constraints |
| dispatch_global/4 (clpfd): | | The Global Constraint Programming Interface |
| display (debugger command): | | Debug Commands |
| display/0 (debugger show control): | | Action Variables |
| display/1 (built-in): | | ref-iou-tou-dsp |
| display/1 (built-in, ref page): | | mpg-ref-display |
| display/1 (tk_new/2 option): | | Basic Functions |
| displaying statistics: | | ref-mgc-ove-sta |
| dispose/1 (structs): | | str-cdf |
| distinctions among write predicates: | | ref-iou-tou-dis |
| div /2, integer floored division (evaluable): | | ref-ari-aex |
| do loop: | | ref-sem-ctr-dol |
| do loop (definition): | | Glossary |
| do/2 (built-in, ref page): | | mpg-ref-do |
| do/2, do loop: | | ref-sem-ctr-dol |
| dom/1 (fd_global/[3,4] option): | | The Global Constraint Programming Interface |
| domain (all_different/2 consistency/1 value): | | Arithmetic-Logical Constraints |
| domain (all_distinct/2 consistency/1 value): | | Arithmetic-Logical Constraints |
| domain (global_cardinality/3 consistency/1 value): | | Arithmetic-Logical Constraints |
| domain (scalar_product/5 consistency/1 value): | | Arithmetic Constraints |
| domain errors: | | ref-ere-err-dom |
| domain variable: | | CLPFD Interface |
| domain, finite: | | CLPFD Interface |
| domain-consistent: | | Definitions |
| domain-disentailed: | | Definitions |
| domain-entailed: | | Definitions |
| domain/3 (clpfd): | | Membership Constraints |
| domain_error/[2,4] (error class): | | ref-ere-err |
| dom_w_deg (labeling/2 option): | | Enumeration Predicates |
| double_quotes (prolog flag): | | Glossary |
| double_quotes (prolog flag): | | ref-syn-cpt-sli |
| double_quotes (prolog flag): | | ref-lps-flg |
| down (labeling/2 option): | | Enumeration Predicates |
| dpgc_count (statistics key): | | ref-mgc-ove-sta |
| dpgc_time (statistics key): | | ref-mgc-ove-sta |
| dump/3 (clpqr): | | CLPQR Solver Predicates |
| dynamic (predicate property): | | mpg-ref-predicate_property |
| dynamic code, indexing of: | | ref-mdb-dsp |
| dynamic code, semantics of: | | ref-mdb-bas |
| dynamic creation of modules: | | ref-mod-dmo |
| dynamic declaration: | | Dynamic Declarations |
| dynamic predicate (definition): | | Glossary |
| dynamic predicates, importing: | | ref-mod-idp |
| dynamic resource: | | Foreign Resources |
| dynamic, procedures and declarations: | | ref-mdb-dsp |
| dynamic/0 (predicate property): | | ref-lps-app |
| dynamic/1 (built-in, ref page): | | mpg-ref-dynamic |
| dynamic/1 (declaration): | | Dynamic Declarations |
| dynamic_programming/1 (geost/[2,3,4] option): | | Placement Constraints |
|
| E | | |
|---|
| Eclipse: | | SPIDER |
| edges/2 (ugraphs): | | lib-ugraphs |
| edges/2 (wgraphs): | | lib-wgraphs |
| effect, side (definition): | | Glossary |
| efficiency and specifying streams: | | ref-iou-str-not |
| efficiency, increasing: | | Writing Efficient Programs |
| element/2 (clpfd): | | Extensional Constraints |
| element/3 (clpfd): | | Extensional Constraints |
| elif/1 (conditional directive): | | ref-lod-cnd |
| else/0 (conditional directive): | | ref-lod-cnd |
| Emacs initialization file .emacs: | | Quick-Start |
| emacs interface: | | Emacs Interface |
| empty list (definition): | | Glossary |
| empty_assoc/1 (assoc): | | lib-assoc |
| empty_avl/1 (avl): | | lib-avl |
| empty_bag/1 (bags): | | lib-bags |
| empty_fdset/1 (clpfd): | | FD Set Operations |
| empty_interval/2 (clpfd): | | FD Set Operations |
| empty_queue/1 (queues): | | lib-queues |
| enable this (debugger command): | | Debug Commands |
| enable_breakpoints/1 (built-in): | | Breakpoint Predicates |
| enable_breakpoints/1 (built-in, ref page): | | mpg-ref-enable_breakpoints |
| enabling and disabling garbage collection: | | ref-mgc-egc |
| encoded string: | | CPL Notes |
| encoded string (definition): | | Glossary |
| encoding: | | ref-iou-sfh-enc |
| encoding, UTF-8: | | CPL Notes |
| encoding/1 (open/4 option): | | mpg-ref-open |
| encoding/1 (stream property): | | mpg-ref-stream_property |
| encoding_signature/1 (open/4 option): | | mpg-ref-open |
| encoding_signature/1 (stream property): | | mpg-ref-stream_property |
| end of line: | | mpg-ref-at_end_of_line |
| end of stream: | | mpg-ref-at_end_of_stream |
| end-of-file on character input: | | ref-iou-cin |
| end-of-file, characters: | | mpg-ref-break |
| endif/0 (conditional directive): | | ref-lod-cnd |
| end_class/[0,1] (objects): | | obj-exp-end_class |
| end_of_file: | | ref-iou-tin-trm |
| end_of_file atom: | | mpg-ref-read |
| end_of_stream/1 (stream property): | | mpg-ref-stream_property |
| end_tests/1 (plunit declaration): | | PlUnit A Unit Test Box |
| ensure_loaded/1 (built-in): | | ref-mod-lod |
| ensure_loaded/1 (built-in, ref page): | | mpg-ref-ensure_loaded |
| entailed/1 (clpqr): | | CLPQR Solver Predicates |
| entailments (fd_statistics/2 option): | | Statistics Predicates |
| Enter (Tk event type): | | Event Handling |
| entry (Tk widget): | | Types of Widget |
| enum (labeling/2 option): | | Enumeration Predicates |
| enumerating solutions to a goal: | | ref-all-cse |
| enumerating solutions to a goal: | | ref-all-cba |
| enumerating solutions to a goal: | | ref-all-cba-cal |
| environ/[2,3] (system): | | lib-system |
| environment variables: | | System Properties and Environment Variables |
| eof (seek/4 method): | | mpg-ref-seek |
| eof (Tcl command): | | Commands |
| EOF character: | | Keyboard Characters |
| eof_action/1 (open/4 option): | | mpg-ref-open |
| eof_action/1 (stream property): | | mpg-ref-stream_property |
| eof_code (open/4 eof_action value): | | mpg-ref-open |
| eol/1 (open/4 option): | | mpg-ref-open |
| eol/1 (stream property): | | mpg-ref-stream_property |
| Epoch: | | lib-file_systems |
| equality of floats: | | ref-ari-acm |
| equality, arithmetic: | | ref-ari-acm |
| equality, unification: | | ref-lte-met-usu |
| erase/1 (built-in): | | ref-mdb-rcd |
| erase/1 (built-in, ref page): | | mpg-ref-erase |
| error (absolute_file_name/3 fileerrors value): | | ref-ere-err-exi |
| error (absolute_file_name/3 fileerrors): | | mpg-ref-absolute_file_name |
| error (delete_directory/2 if_nonempty option value): | | lib-file_systems |
| error (open/4 eof_action value): | | mpg-ref-open |
| error (open/4 if_exists value): | | mpg-ref-open |
| error (overflow FD flag value): | | The Global Constraint Programming Interface |
| error (syntax_errors flag value): | | ref-lps-flg |
| error (syntax_errors flag value): | | ref-ere-err-syn |
| error (unknown flag value): | | ref-lps-flg |
| error (unknown flag value): | | ref-ere-hex-hup |
| error classes: | | ref-ere-err |
| error handling: | | Exceptions Debug |
| error term: | | ref-ere-rex |
| error, syntax: | | Syntax Errors |
| error/1 (plunit option): | | PlUnit A Unit Test Box |
| error/2 (plunit option): | | PlUnit A Unit Test Box |
| errors: | | ref-ere |
| errors, arithmetics: | | ref-ari-exc |
| errors, calls: | | ref-sem-exc |
| errors, consistency: | | ref-ere-err-cns |
| errors, context: | | ref-ere-err-con |
| errors, domain: | | ref-ere-err-dom |
| errors, evaluation: | | ref-ere-err-eva |
| errors, existence: | | ref-ere-err-exi |
| errors, instantiation: | | ref-ere-err-ins |
| errors, permission: | | ref-ere-err-per |
| errors, representation: | | ref-ere-err-rep |
| errors, resource: | | ref-ere-err-res |
| errors, streams: | | ref-iou-sfh-est |
| errors, syntax: | | ref-ere-err-syn |
| errors, system: | | ref-ere-err-sys |
| errors, type: | | ref-ere-err-typ |
| errors, uninstantiation: | | ref-ere-err-uns |
| error_exception/1 (hook, ref page): | | mpg-ref-error_exception |
| error_exception/1 (user, hook): | | ref-ere-hex |
| error_exception/1 (user, hook): | | Exceptions Debug |
| escape sequence: | | ref-syn-syn-esc |
| escape sequence (definition): | | Glossary |
| escaping, character: | | ref-syn-ces |
| eval (Tcl command): | | Commands |
| evaluating arithmetic expressions: | | ref-ari-eae |
| evaluation errors: | | ref-ere-err-eva |
| evaluation_error/[2,4] (error class): | | ref-ere-err |
| event, constraint: | | FDBG Events |
| event, FDBG: | | FDBG Events |
| event, labeling: | | FDBG Events |
| exception (leashing mode): | | Basic Debug |
| exception handling: | | Exceptions Debug |
| exception handling in C: | | Exception Handling in C |
| exception term: | | ref-ere-rex |
| exception term: | | Exception Handling in C |
| exception/1 (debugger port value): | | Port Tests |
| exception/1 (plunit option): | | PlUnit A Unit Test Box |
| exceptions: | | ref-ere |
| exceptions, arithmetic: | | ref-ari-exc |
| Exceptions, C functions for: | | cpg-top-exc |
| exceptions, calls: | | ref-sem-exc |
| exceptions, global handler: | | ref-ere-hex-hup |
| exceptions, module name expansion: | | mpg-ref-cat |
| exceptions, streams: | | ref-iou-sfh-est |
| exclude/[3,4,5] (lists): | | lib-lists |
| executable (absolute_file_name/3 access): | | mpg-ref-absolute_file_name |
| executable (absolute_file_name/3 file type): | | mpg-ref-absolute_file_name |
| executable, console-based (definition): | | Glossary |
| executable, stand-alone: | | Stand-Alone Executables |
| executable, stand-alone (definition): | | Glossary |
| executable, windowed (definition): | | Glossary |
| execute (absolute_file_name/3 access): | | mpg-ref-absolute_file_name |
| execution: | | Execution |
| execution profiling: | | Execution Profiling |
| execution state, predicates for: | | ref-ere-sum |
| execution state, predicates for: | | mpg-top-est |
| execution, nested: | | Nested |
| execution_state/[1,2] (built-in): | | Built-in Predicates for Breakpoint Handling |
| execution_state/[1,2] (built-in): | | Accessing Past Debugger States |
| execution_state/[1,2] (built-in): | | Breakpoint Predicates |
| execution_state/[1,2] (built-in, ref page): | | mpg-ref-execution_state |
| exist (absolute_file_name/3 access): | | mpg-ref-absolute_file_name |
| existence errors: | | ref-ere-err-exi |
| existence_error/[2,5] (error class): | | ref-ere-err |
| existential quantifier: | | ref-all-cse-equ |
| existential quantifier: | | mpg-ref-exists |
| exit (CHR port): | | CHR Ports |
| exit (leashing mode): | | Basic Debug |
| exit/0 (clpfd:dispatch_global/4 request): | | The Global Constraint Programming Interface |
| exit/1 (debugger port value): | | Port Tests |
| exited/1 (debugger condition): | | Accessing Past Debugger States |
| exited/1 (debugger condition): | | Goal Tests |
| exiting: | | Exiting |
| exp /1, exponent (evaluable): | | ref-ari-aex |
| exp /2, float power (evaluable): | | ref-ari-aex |
| expand_term/2 (built-in): | | ref-lod-exp |
| expand_term/2 (built-in, ref page): | | mpg-ref-expand_term |
| expansion, macro: | | mpg-ref-goal_expansion |
| expansion, module name: | | Mode Spec |
| expansion, module name: | | Meta-Predicate Declarations |
| expansion, module name (definition): | | Glossary |
| explicit unification: | | ref-lte-met-usu |
| export (definition): | | Glossary |
| exported (predicate property): | | mpg-ref-predicate_property |
| exported/0 (predicate property): | | ref-lps-app |
| exporting predicates from a module: | | ref-mod-def |
| expr (argument type): | | mpg-ref-aty-ety |
| expr (Tcl command): | | Commands |
| expression, arithmetic: | | ref-ari-aex |
| extended runtime system (definition): | | Glossary |
| extended_characters/1 (xml_parse/3 option): | | lib-xml |
| extensions/1 (absolute_file_name/3 option): | | mpg-ref-absolute_file_name |
|
| F | | |
|---|
| fact (definition): | | Glossary |
| fail (absolute_file_name/3 fileerrors value): | | ref-ere-err-exi |
| fail (absolute_file_name/3 fileerrors): | | mpg-ref-absolute_file_name |
| fail (CHR debug command): | | CHR Tracing |
| fail (CHR port): | | CHR Ports |
| fail (debugger command): | | Debug Commands |
| fail (delete_directory/2 if_nonempty option value): | | lib-file_systems |
| fail (leashing mode): | | Basic Debug |
| fail (overflow FD flag value): | | The Global Constraint Programming Interface |
| fail (syntax_errors flag value): | | ref-lps-flg |
| fail (syntax_errors flag value): | | ref-ere-err-syn |
| fail (unknown flag value): | | ref-lps-flg |
| fail (unknown flag value): | | ref-ere-hex-hup |
| fail/0 (built-in, ref page): | | mpg-ref-fail |
| fail/0 (clpfd:dispatch_global/4 request): | | The Global Constraint Programming Interface |
| fail/0 (debugger port value): | | Port Tests |
| fail/0 (plunit option): | | PlUnit A Unit Test Box |
| fail/1 (debugger command control): | | Action Variables |
| false/0 (built-in, ref page): | | mpg-ref-false |
| false/0 (debugger condition): | | Other Tests |
| FD predicate: | | User-Defined Constraints |
| FD predicate: | | FD Predicates |
| FD set: | | FD Set Operations |
| FDBG concepts: | | FDBG Concepts |
| FDBG event: | | FDBG Events |
| FDBG output stream: | | FDBG The fdbg_output Stream |
| fdbg_annotate/[3,4] (fdbg): | | FDBG Writing Visualizers |
| fdbg_assign_name/2 (fdbg): | | FDBG Naming Terms |
| fdbg_current_name/2 (fdbg): | | FDBG Naming Terms |
| fdbg_get_name/2 (fdbg): | | FDBG Naming Terms |
| fdbg_guard/3 (fdbg): | | FDBG Debugging Global Constraints |
| fdbg_labeling_step/2 (fdbg): | | FDBG Annotation |
| fdbg_label_show/3 (fdbg): | | FDBG Built-In Visualizers |
| fdbg_legend/[1,2] (fdbg): | | FDBG Writing Visualizers |
| fdbg_off/0 (fdbg): | | FDBG Options |
| fdbg_on/[0,1] (fdbg): | | FDBG Options |
| fdbg_output: | | FDBG The fdbg_output Stream |
| fdbg_show/2 (fdbg): | | FDBG Built-In Visualizers |
| fdbg_start_labeling/1 (fdbg): | | FDBG Annotation |
| fdbg_transform_actions/3 (fdbg): | | FDBG Writing Legend Printers |
| fdset_add_element/3 (clpfd): | | FD Set Operations |
| fdset_complement/2 (clpfd): | | FD Set Operations |
| fdset_del_element/3 (clpfd): | | FD Set Operations |
| fdset_disjoint/2 (clpfd): | | FD Set Operations |
| fdset_eq/2 (clpfd): | | FD Set Operations |
| fdset_intersect/2 (clpfd): | | FD Set Operations |
| fdset_intersection/[2,3] (clpfd): | | FD Set Operations |
| fdset_interval/3 (clpfd): | | FD Set Operations |
| fdset_max/2 (clpfd): | | FD Set Operations |
| fdset_member/2 (clpfd): | | FD Set Operations |
| fdset_min/2 (clpfd): | | FD Set Operations |
| fdset_parts/4 (clpfd): | | FD Set Operations |
| fdset_singleton/2 (clpfd): | | FD Set Operations |
| fdset_size/2 (clpfd): | | FD Set Operations |
| fdset_subset/2 (clpfd): | | FD Set Operations |
| fdset_subtract/3 (clpfd): | | FD Set Operations |
| fdset_to_list/2 (clpfd): | | FD Set Operations |
| fdset_to_range/2 (clpfd): | | FD Set Operations |
| fdset_union/[2,3] (clpfd): | | FD Set Operations |
| fdvar_portray/3 (fdbg, hook): | | FDBG Customizing Output |
| fd_batch/1 (clpfd): | | Posting Constraints |
| fd_closure/2 (clpfd): | | Reflection Predicates |
| fd_constraint (predicate property): | | mpg-ref-predicate_property |
| fd_constraint/0 (predicate property): | | ref-lps-app |
| fd_degree/2 (clpfd): | | Reflection Predicates |
| fd_dom/2 (clpfd): | | Reflection Predicates |
| fd_failures/2 (clpfd): | | Reflection Predicates |
| fd_flag/3 (clpfd): | | The Global Constraint Programming Interface |
| fd_global/[3,4] (clpfd): | | The Global Constraint Programming Interface |
| fd_max/2 (clpfd): | | Reflection Predicates |
| fd_min/2 (clpfd): | | Reflection Predicates |
| fd_neighbors/2 (clpfd): | | Reflection Predicates |
| fd_purge/1 (clpfd): | | Forgetting Constraints |
| fd_set/2 (clpfd): | | Reflection Predicates |
| fd_set_failures/2 (clpfd): | | Reflection Predicates |
| fd_size/2 (clpfd): | | Reflection Predicates |
| fd_statistics/[0,2] (clpfd): | | Statistics Predicates |
| fd_var/1 (clpfd): | | Reflection Predicates |
| fetch_slot/2 (objects): | | obj-exp-fetch_slot |
| ff (labeling/2 option): | | Enumeration Predicates |
| ffc (labeling/2 option): | | Enumeration Predicates |
| file (load context key): | | ref-lps-lco |
| File and Stream Handling, C functions for: | | cpg-top-fst |
| file and stream handling, predicates for: | | ref-iou-sum |
| file and stream handling, predicates for: | | mpg-top-fsh |
| file specification: | | ref-fdi-fsp |
| file specification: | | ref-fdi-syn |
| file specification (definition): | | Glossary |
| file, closing: | | ref-iou-sfh-cst |
| file, initialization: | | ref-fdi-fsp-ffs |
| file, module (definition): | | Glossary |
| file, PO (definition): | | Glossary |
| file/1 (debugger condition): | | Breakpoint Tests |
| file/1 (debugger condition): | | Source Tests |
| fileerrors (prolog flag): | | ref-lod-lod |
| fileerrors (prolog flag): | | ref-iou-sfh-sem |
| fileerrors (prolog flag): | | ref-lps-flg |
| fileerrors (prolog flag): | | ref-ere-err-exi |
| fileerrors (prolog flag): | | ref-ere-err-per |
| fileerrors (prolog flag): | | mpg-ref-absolute_file_name |
| fileerrors (prolog flag): | | mpg-ref-absolute_file_name |
| fileerrors (prolog flag): | | mpg-ref-restore |
| fileerrors (prolog flag): | | mpg-ref-see |
| fileerrors (prolog flag): | | mpg-ref-tell |
| fileerrors/1 (absolute_file_name/3 option): | | mpg-ref-absolute_file_name |
| fileerrors/1 (read_term/[2,3] option): | | ref-ere-err-exi |
| fileerrors/1 (read_term/[2,3] option): | | ref-ere-err-per |
| filename manipulation, predicates for: | | ref-fdi-pre |
| filename manipulation, predicates for: | | mpg-top-fnm |
| fileref/2 (source information descriptor): | | mpg-ref-goal_source_info |
| files: | | lib-file_systems |
| files, appending to existing: | | ref-iou-sfh-opn |
| files, creating new: | | ref-iou-sfh-opn |
| files, opening: | | ref-iou-sfh-opn |
| files, searching for in a library: | | ref-fdi-fsp |
| file_errors/1 (absolute_file_name/3 option): | | mpg-ref-absolute_file_name |
| file_errors/1 (read_term/[2,3] option): | | ref-ere-err-exi |
| file_exists/1 (file_systems): | | lib-file_systems |
| file_exists/2 (file_systems): | | lib-file_systems |
| file_members_of_directory/[1,2,3] (file_systems): | | lib-file_systems |
| file_member_of_directory/[2,3,4] (file_systems): | | lib-file_systems |
| file_must_exist/1 (file_systems): | | lib-file_systems |
| file_must_exist/2 (file_systems): | | lib-file_systems |
| file_name/1 (stream property): | | mpg-ref-stream_property |
| file_property/[2,3] (file_systems): | | lib-file_systems |
| file_search_path/2 (hook, ref page): | | mpg-ref-file_search_path |
| file_search_path/2 (user, hook): | | ref-fdi-fsp-def |
| file_spec (argument type): | | mpg-ref-aty-ety |
| file_type/1 (absolute_file_name/3 option): | | mpg-ref-absolute_file_name |
| find this (debugger command): | | Debug Commands |
| findall/[3,4] (built-in): | | ref-all-cba-cal |
| findall/[3,4] (built-in, ref page): | | mpg-ref-findall |
| finding nondeterminacy: | | The Determinacy Checker |
| find_chr_constraint/1 (chr): | | CHR Debugging Predicates |
| finite domain: | | CLPFD Interface |
| first (absolute_file_name/3 solutions): | | mpg-ref-absolute_file_name |
| first_bound/2 (clpfd): | | Enumeration Predicates |
| first_bound/2 (clpfd): | | Enumeration Predicates |
| first_fail (labeling/2 option): | | Enumeration Predicates |
| fixall/2 (geost/[2,3,4] option): | | Placement Constraints |
| fixme/1 (plunit option): | | PlUnit A Unit Test Box |
| flit/0 (debugger command control): | | Action Variables |
| flit/2 (debugger command control): | | Action Variables |
| float (CHR type): | | CHR Constraint Declaration |
| float /1, coercion (evaluable): | | ref-ari-aex |
| float/1 (built-in, ref page): | | mpg-ref-float |
| floats, equality of: | | ref-ari-acm |
| floats, range of: | | ref-ari-ove |
| floats, syntax of: | | ref-syn-trm-flo |
| float_format/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| float_fractional_part /1, fractional part (evaluable): | | ref-ari-aex |
| float_integer_part /1, coercion (evaluable): | | ref-ari-aex |
| floor /1, (evaluable): | | ref-ari-aex |
| floundered query (definition): | | Glossary |
| floundering: | | ref-sem-sec |
| flushing output: | | ref-iou-sfh-flu |
| flush_output/1 (built-in): | | ref-iou-sfh-flu |
| flush_output/[0,1] (built-in, ref page): | | mpg-ref-flush_output |
| for (Tcl command): | | Commands |
| for /3, (iterator): | | ref-sem-ctr-dol |
| for/3 (iterator): | | mpg-ref-do |
| forall/1 (plunit option): | | PlUnit A Unit Test Box |
| forall/2 (aggregate): | | lib-aggregate |
| force/1 (abolish/2 option): | | mpg-ref-abolish |
| force/1 (close/2 option): | | mpg-ref-close |
| foreach (Tcl command): | | Commands |
| foreach /2, (iterator): | | ref-sem-ctr-dol |
| foreach/2 (aggregate): | | lib-aggregate |
| foreach/2 (iterator): | | mpg-ref-do |
| foreacharg /2, (iterator): | | ref-sem-ctr-dol |
| foreacharg /3, (iterator): | | ref-sem-ctr-dol |
| foreacharg/2 (iterator): | | mpg-ref-do |
| foreacharg/3 (iterator): | | mpg-ref-do |
| foreign data types: | | lib-structs |
| Foreign Interface, C functions for: | | cpg-top-fin |
| foreign interface, predicates for: | | mpg-top-fin |
| foreign language interface: | | Mixing C and Prolog |
| foreign language interface: | | Calling C from Prolog |
| foreign predicate (definition): | | Glossary |
| foreign resource: | | Foreign Resources |
| foreign resource (definition): | | Glossary |
| foreign resource linker: | | The Foreign Resource Linker |
| foreign resource, linked: | | Foreign Resources |
| foreign resource, linked: | | Creating the Linked Foreign Resource |
| foreign resource, prelinked (definition): | | Glossary |
| foreign terms (definition): | | lib-structs |
| foreign/[2,3] (hook, ref page): | | mpg-ref-foreign |
| foreign/[2,3] (Module, hook): | | Conversion Declarations |
| foreign_arg (argument type): | | mpg-ref-aty-ety |
| foreign_resource (absolute_file_name/3 file type): | | mpg-ref-absolute_file_name |
| foreign_resource/2 (hook, ref page): | | mpg-ref-foreign_resource |
| foreign_resource/2 (Module, hook): | | Conversion Declarations |
| foreign_spec (argument type): | | mpg-ref-aty-ety |
| foreign_type/2 (structs): | | str-fty-dty |
| forgetting constraints: | | Forgetting Constraints |
| formal syntax: | | ref-syn-syn |
| format (Tcl command): | | Commands |
| format-command: | | Message Phases |
| format/1 (xml_parse/3 option): | | lib-xml |
| format/[2,3] (built-in): | | ref-iou-cou-fou |
| format/[2,3] (built-in, ref page): | | mpg-ref-format |
| formatted printing: | | ref-iou-cou-fou |
| format_to_codes/[3,4] (codesio): | | lib-codesio |
| forward-paragraph (emacs command): | | Usage |
| fractile/3 (statistics): | | lib-statistics |
| frame (Tk widget): | | Types of Widget |
| frame, current: | | Debug Format |
| frame, current: | | Debug Commands |
| freeze/2 (built-in, ref page): | | mpg-ref-freeze |
| free_of_term/2 (terms): | | lib-terms |
| free_of_var/2 (terms): | | lib-terms |
| free_search/1 (zinc option): | | FlatZinc Exported Predicates |
| free_search/1 (zinc option): | | MiniZinc Exported Predicates |
| free_variables/4 (aggregate): | | lib-aggregate |
| fromto /4, (iterator): | | ref-sem-ctr-dol |
| fromto/4 (iterator): | | mpg-ref-do |
| frozen/2 (built-in, ref page): | | mpg-ref-frozen |
| full stop: | | ref-sem-sec |
| full stop, use of: | | ref-iou-tin-trm |
| full stop, use of: | | ref-iou-tou-cha |
| full stop, use of: | | mpg-ref-read |
| Fully Qualified Classname: | | Jasper Library Predicates |
| full_answer/0 (clpfd): | | Answer Constraints |
| function prototype: | | Function Prototypes |
| function, deinit: | | Conversion Declarations |
| function, deinit (definition): | | Glossary |
| function, init: | | Conversion Declarations |
| function, init (definition): | | Glossary |
| functions for C errors: | | cpg-top-err |
| functor (definition): | | Glossary |
| functor, principal: | | ref-lte-act |
| functor, principal (definition): | | ref-syn-cpt |
| functor/3 (built-in): | | ref-lte-act |
| functor/3 (built-in, ref page): | | mpg-ref-functor |
| functors: | | ref-syn-cpt |
| functors, arithmetic: | | ref-ari-aex |
| fzn_dump/[2,3] (zinc): | | FlatZinc Exported Predicates |
| fzn_file/1 (zinc option): | | MiniZinc Exported Predicates |
| fzn_identifier/3 (zinc): | | FlatZinc Exported Predicates |
| fzn_load_file/2 (zinc): | | FlatZinc Exported Predicates |
| fzn_load_stream/2 (zinc): | | FlatZinc Exported Predicates |
| fzn_objective/2 (zinc): | | FlatZinc Exported Predicates |
| fzn_output/1 (zinc): | | FlatZinc Exported Predicates |
| fzn_post/1 (zinc): | | FlatZinc Exported Predicates |
| fzn_run_file/[1,2] (zinc): | | FlatZinc Exported Predicates |
| fzn_run_stream/[1,2] (zinc): | | FlatZinc Exported Predicates |
| fzn_solve/1 (zinc): | | FlatZinc Exported Predicates |
|
| G | | |
|---|
| garbage collection: | | ref-lps-flg |
| garbage collection: | | ref-mgc-ove |
| garbage collection: | | ref-mgc-gcp |
| garbage collection: | | mpg-ref-abolish |
| garbage collection (definition): | | Glossary |
| garbage collection, atoms: | | ref-mgc-ago |
| garbage collection, enabling and disabling: | | ref-mgc-egc |
| garbage collection, invoking directly: | | ref-mgc-gcd |
| garbage collection, monitoring: | | ref-mgc-mgc |
| garbage_collect/0 (built-in): | | ref-mgc-gcd |
| garbage_collect/0 (built-in, ref page): | | mpg-ref-garbage_collect |
| garbage_collection (statistics key): | | ref-mgc-ove-sta |
| garbage_collect_atoms/0 (built-in): | | ref-mgc-ago-agc |
| garbage_collect_atoms/0 (built-in, ref page): | | mpg-ref-garbage_collect_atoms |
| gauge: | | lib-gauge |
| gc (prolog flag): | | ref-lps-flg |
| gc (prolog flag): | | ref-mgc-egc |
| gcd /2, greatest common divisor (evaluable): | | ref-ari-aex |
| gc_count (statistics key): | | ref-mgc-ove-sta |
| gc_freed (statistics key): | | ref-mgc-ove-sta |
| gc_margin (prolog flag): | | ref-lps-flg |
| gc_margin (prolog flag): | | ref-mgc-gch |
| gc_time (statistics key): | | ref-mgc-ove-sta |
| gc_trace (prolog flag): | | ref-lps-flg |
| gc_trace (prolog flag): | | ref-mgc-egc |
| gc_trace (prolog flag): | | ref-mgc-mgc |
| generalization/1 (cumulatives/3 option): | | Scheduling Constraints |
| generalized predicate specification (definition): | | Glossary |
| generate-and-test, use with cut: | | Terminating a Backtracking Loop |
| generate_debug_info (CHR flag): | | CHR Debugging Predicates |
| generate_message/3 (hook, ref page): | | mpg-ref-generate_message |
| generate_message/3 (SU_messages): | | Message Handling Predicates |
| generate_message_hook/3 (hook, ref page): | | mpg-ref-generate_message_hook |
| generate_message_hook/3 (user, hook): | | Message Handling Predicates |
| generate_unique_name (open/4 if_exists value): | | mpg-ref-open |
| generic breakpoint: | | Specific and Generic Breakpoints |
| gen_assoc/3 (assoc): | | lib-assoc |
| gen_int/1 (between): | | lib-between |
| gen_label/3 (trees): | | lib-trees |
| gen_nat/1 (between): | | lib-between |
| geometric_mean/2 (statistics): | | lib-statistics |
| geost/[2,3,4] (clpfd): | | Placement Constraints |
| get/1 (debugger condition): | | Port Tests |
| getrand/1 (random): | | lib-random |
| gets (Tcl command): | | Commands |
| get_address/3 (structs): | | str-afd |
| get_assoc/3 (assoc): | | lib-assoc |
| get_atts/2 (Module): | | lib-atts |
| get_byte/[1,2] (built-in): | | ref-iou-cin-cha |
| get_byte/[1,2] (built-in, ref page): | | mpg-ref-get_byte |
| get_char/[1,2] (built-in): | | ref-iou-cin-cha |
| get_char/[1,2] (built-in, ref page): | | mpg-ref-get_char |
| get_code/[1,2] (built-in): | | ref-iou-cin-cha |
| get_code/[1,2] (built-in, ref page): | | mpg-ref-get_code |
| get_contents/3 (structs): | | str-afd |
| get_label/3 (trees): | | lib-trees |
| get_mutable/2 (built-in): | | ref-lte-mut |
| get_mutable/2 (built-in, ref page): | | mpg-ref-get_mutable |
| get_next_assoc/4 (assoc): | | lib-assoc |
| get_prev_assoc/4: | | lib-assoc |
| glob/1 (absolute_file_name/3 option): | | mpg-ref-absolute_file_name |
| global (Tcl command): | | Commands |
| global constraint: | | The Global Constraint Programming Interface |
| global exception handler: | | ref-ere-hex-hup |
| global stack: | | ref-mgc-ove |
| global stack, expansion: | | ref-mgc-ove |
| global/1 (cumulative/2 option): | | Scheduling Constraints |
| global/1 (disjoint1/2 option): | | Placement Constraints |
| global/1 (disjoint2/2 option): | | Placement Constraints |
| global/1 (lex_chain/2 option): | | Arithmetic-Logical Constraints |
| global/1 (value_precede_chain/3 option): | | Sequence Constraints |
| GLOBALSTKSIZE (system property): | | System Properties and Environment Variables |
| global_cardinality/[2,3] (clpfd): | | Arithmetic-Logical Constraints |
| global_stack (statistics key): | | ref-mgc-ove-sta |
| global_stack_free (statistics key): | | ref-mgc-ove-sta |
| global_stack_used (statistics key): | | ref-mgc-ove-sta |
| glue code (definition): | | Glossary |
| GNU Emacsss: | | Emacs Interface |
| goal: | | ref-sem-pro |
| goal (definition): | | Glossary |
| goal, ancestor: | | Debug Format |
| goal, blocked: | | Debug Format |
| goal, blocked (definition): | | Glossary |
| goal, skeletal (definition): | | Glossary |
| goal, unblocked (definition): | | Glossary |
| goal/1 (debugger condition): | | Breakpoint Tests |
| goal/1 (debugger condition): | | Goal Tests |
| goals, enumerating solutions: | | ref-all-cse |
| goals, enumerating solutions: | | ref-all-cba |
| goals, enumerating solutions: | | ref-all-cba-cal |
| goal_expansion/5 (hook, ref page): | | mpg-ref-goal_expansion |
| goal_expansion/5 (Module, hook): | | ref-lod-exp |
| goal_private/1 (debugger condition): | | Storing User Information in the Backtrace |
| goal_private/1 (debugger condition): | | Goal Tests |
| goal_source_info/3 (built-in): | | ref-ere-err |
| goal_source_info/3 (built-in): | | Message Handling Predicates |
| goal_source_info/3 (built-in, ref page): | | mpg-ref-goal_source_info |
| grammar rules, control constructs in: | | ref-gru-dcg |
| grammar rules, predicates for: | | ref-gru-sum |
| grammar rules, predicates for: | | mpg-top-gru |
| grammar rules, semantics of: | | ref-gru-tra |
| grammars, context-free: | | ref-gru-dcg |
| grammars, definite clause: | | ref-gru-dcg |
| greedy/1 (multi_cumulatives/3 option): | | Scheduling Constraints |
| green cut: | | ref-sem-ctr-cut |
| ground (definition): | | Glossary |
| ground/1 (built-in, ref page): | | mpg-ref-ground |
| ground/1 (when/2 condition): | | mpg-ref-when |
| group/[3,4,5] (lists): | | lib-lists |
| GROWTHFACTOR (system property): | | System Properties and Environment Variables |
| guarded clause: | | Conditionals and Disjunction |
| guarded clause (definition): | | Glossary |
|
| H | | |
|---|
| halt/[0,1] (built-in): | | ref-ere-int |
| halt/[0,1] (built-in, ref page): | | mpg-ref-halt |
| handling, error: | | Exceptions Debug |
| handling, exception: | | Exceptions Debug |
| handling, interrupt: | | Calling Prolog Asynchronously |
| handling, signal: | | Calling Prolog Asynchronously |
| harmonic_mean/2 (statistics): | | lib-statistics |
| head (definition): | | Glossary |
| head of a clause: | | ref-sem-pro |
| head/2 (lists): | | lib-lists |
| heap (statistics key): | | ref-mgc-ove-sta |
| help (CHR debug command): | | CHR Tracing |
| help (debugger command): | | Debug Commands |
| help (top-level command): | | Queries |
| hidden module: | | ref-mod-def |
| hidden/1 (module/3 option): | | ref-mod-def |
| hidden/1 (module/3 option): | | mpg-ref-module |
| hide/0 (debugger condition): | | Condition Macros |
| hook (function annotation): | | cpg-rve |
| hook (predicate annotation): | | mpg-ref-cat |
| hook predicate: | | Multifile Declarations |
| hook predicate (definition): | | Glossary |
| hook predicate (definition): | | ref-sem-typ-hok |
| hook predicates: | | mpg-top-hok |
| hookable (predicate annotation): | | mpg-ref-cat |
| hookable predicate (definition): | | Glossary |
| host_type (prolog flag): | | ref-fdi-fsp-pre |
| host_type (prolog flag): | | ref-lps-flg |
| host_type (prolog flag, volatile): | | mpg-ref-file_search_path |
|
| I | | |
|---|
| I/O, C functions for: | | cpg-top-cio |
| id/1 (stream property): | | mpg-ref-stream_property |
| id3 (table/3 order/1 value): | | Extensional Constraints |
| idempotent/1 (fd_global/[3,4] option): | | The Global Constraint Programming Interface |
| identifier, breakpoint: | | Creating Breakpoints |
| if (Tcl command): | | Commands |
| if/1 (conditional directive): | | ref-lod-cnd |
| if/1 (load_files/2 option): | | mpg-ref-load_files |
| if/3 (built-in, ref page): | | mpg-ref-if |
| if/3, soft cut: | | ref-sem-ctr-ite |
| if_exists/1 (open/4 option): | | mpg-ref-open |
| if_nonempty/1 (delete_directory/2 option): | | lib-file_systems |
| if_then_else/4 (clpfd): | | Arithmetic Constraints |
| if_user/1 (absolute_file_name/3 option): | | mpg-ref-absolute_file_name |
| ignore (delete_directory/2 if_nonempty option value): | | lib-file_systems |
| ignore_ops/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| IID: | | Terminology |
| illarg/[3,4] (types): | | lib-types |
| impact (labeling/2 option): | | Enumeration Predicates |
| import (definition): | | Glossary |
| importation: | | ref-mod-bas |
| importation: | | ref-mod-lod |
| importation, predicates from another module: | | ref-mod-lod |
| imported_from (predicate property): | | mpg-ref-predicate_property |
| imported_from/1 (predicate property): | | ref-lps-app |
| importing dynamic predicates: | | ref-mod-idp |
| importing predicates into modules: | | ref-mod-lod |
| imports/1 (load_files/2 option): | | mpg-ref-load_files |
| in/1 (linda_client): | | lib-linda-client |
| in/2 (clpfd): | | Membership Constraints |
| in/2 (clpfd:dispatch_global/4 request): | | The Global Constraint Programming Interface |
| in/2 (linda_client): | | lib-linda-client |
| IName: | | Terminology |
| include declaration: | | Include Declarations |
| include/1 (built-in, ref page): | | mpg-ref-include |
| include/1 (declaration): | | Include Declarations |
| include/[3,4,5] (lists): | | lib-lists |
| incr (Tcl command): | | Commands |
| increasing efficiency: | | Writing Efficient Programs |
| increasing/0 (lex_chain/2 option): | | Arithmetic-Logical Constraints |
| increasing_prefix/[3,4] (lists): | | lib-lists |
| indented/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| indexed term: | | LMDB DB-Spec Intro |
| indexical: | | Indexicals |
| indexicals, checking: | | Indexicals |
| indexicals, propagating: | | Indexicals |
| indexing: | | Indexing |
| indexing (definition): | | Glossary |
| indexing of dynamic code: | | ref-mdb-dsp |
| indexing, determinacy detection via: | | Determinacy Detection |
| indomain/1 (clpfd): | | Enumeration Predicates |
| inf, minus infinity: | | CLPFD Interface |
| inf/[2,4] (clpqr): | | CLPQR Solver Predicates |
| infix operators: | | ref-syn-cpt |
| infix operators: | | ref-syn-ops-ove |
| information, source: | | Usage |
| information, source: | | ref-lps-flg |
| informational (prolog flag): | | ref-lps-flg |
| informational (prolog flag): | | Runtime Systems |
| informational (prolog flag): | | too-sicstus |
| inherit/1 (objects): | | obj-exp-inherit |
| init function: | | Conversion Declarations |
| init function (definition): | | Glossary |
| initialization: | | Initializations |
| initialization (definition): | | Glossary |
| initialization file: | | ref-fdi-fsp-ffs |
| initialization of saved states: | | ref-sls-sst |
| initialization, C functions for: | | cpg-top-main |
| initialization/1 (built-in, ref page): | | mpg-ref-initialization |
| initialization/1 (declaration): | | Initializations |
| input: | | ref-iou |
| input and output of characters: | | ref-iou-cin |
| input and output of terms: | | ref-iou-bas |
| input and output, streams: | | ref-iou-bas |
| input stream, current: | | ref-iou-sfh-sob |
| input, current: | | ref-iou-str |
| input, term: | | ref-iou-tin |
| input/0 (stream property): | | mpg-ref-stream_property |
| input_encoding/1 (stream property): | | mpg-ref-stream_property |
| input_order (labeling/2 option): | | Enumeration Predicates |
| insert (CHR port): | | CHR Ports |
| instance of clause: | | ref-sem-sec |
| instance/2 (built-in): | | ref-mdb-acl |
| instance/2 (built-in, ref page): | | mpg-ref-instance |
| instance_method/1 (objects): | | obj-exp-instance_method |
| instantiation (definition): | | Glossary |
| instantiation errors: | | ref-ere-err-ins |
| instantiation_error/[0,2] (error class): | | ref-ere-err |
| int (CHR type): | | CHR Constraint Declaration |
| integer /1, coercion (evaluable): | | ref-ari-aex |
| integer, large (definition): | | Glossary |
| integer, small (definition): | | Glossary |
| integer/1 (built-in, ref page): | | mpg-ref-integer |
| integers, range of: | | ref-ari-ove |
| integers, syntax of: | | ref-syn-trm-int |
| integer_rounding_function (prolog flag): | | ref-lps-flg |
| interactive stream (definition): | | Glossary |
| interactive/0 (stream property): | | mpg-ref-stream_property |
| interface, Eclipse: | | SPIDER |
| interface, emacs: | | Emacs Interface |
| interface, foreign language: | | Mixing C and Prolog |
| interface, foreign language: | | Calling C from Prolog |
| interf_arg_type (argument type): | | mpg-ref-aty-ety |
| internal database: | | ref-mdb-idb |
| interoperability: | | Mixing C and Prolog |
| interpret (definition): | | Glossary |
| interpretation of clauses, declarative: | | ref-sem-sec |
| interpretation of clauses, procedural: | | ref-sem-sec |
| interpreted (predicate property): | | mpg-ref-predicate_property |
| interpreted/0 (predicate property): | | ref-lps-app |
| interrupt character: | | Keyboard Characters |
| interrupt handling: | | Calling Prolog Asynchronously |
| intersect/2 (sets): | | lib-sets |
| intersection/[2,3] (sets): | | lib-sets |
| inv/1 (debugger condition): | | Breakpoint Tests |
| inv/1 (debugger condition): | | Goal Tests |
| inv/1 (debugger condition): | | Past States |
| invocation box: | | Procedure Box |
| invocation box (definition): | | Glossary |
| invoking garbage collection directly: | | ref-mgc-gcd |
| in_noblock/1 (linda_client): | | lib-linda-client |
| in_set/2 (clpfd): | | Membership Constraints |
| in_set/2 (clpfd:dispatch_global/4 request): | | The Global Constraint Programming Interface |
| is/2 (built-in): | | ref-ari-eae |
| is/2 (built-in, ref page): | | mpg-ref-is |
| is/2 (declaration): | | Is2 Declarations |
| is/2 declaration: | | Is2 Declarations |
| ISO (predicate annotation): | | mpg-ref-cat |
| is_assoc/1 (assoc): | | lib-assoc |
| is_avl/1 (avl): | | lib-avl |
| is_bag/1 (bags): | | lib-bags |
| is_fdset/1 (clpfd): | | FD Set Operations |
| is_json_term/[1,2] (json): | | lib-json |
| is_list/1 (lists): | | lib-lists |
| is_mutarray/1 (mutarray): | | lib-mutarray |
| is_mutdict/1 (mutdict): | | lib-mutdict |
| is_ordset/1 (ordsets): | | lib-ordsets |
| is_process/1 (process): | | lib-process |
| is_queue/1 (queues): | | lib-queues |
| is_set/1 (sets): | | lib-sets |
| iterator (definition): | | Glossary |
|
| J | | |
|---|
| jasper_call/4 (jasper): | | Jasper Library Predicates |
| jasper_create_global_ref/3 (jasper): | | Jasper Library Predicates |
| jasper_create_local_ref/3 (jasper): | | Jasper Library Predicates |
| jasper_deinitialize/1 (jasper): | | Jasper Library Predicates |
| jasper_delete_global_ref/2 (jasper): | | Jasper Library Predicates |
| jasper_delete_local_ref/2 (jasper): | | Jasper Library Predicates |
| jasper_initialize/[1,2] (jasper): | | Jasper Library Predicates |
| jasper_is_instance_of/3 (jasper): | | Jasper Library Predicates |
| jasper_is_jvm/1 (jasper): | | Jasper Library Predicates |
| jasper_is_object/[1,2] (jasper): | | Jasper Library Predicates |
| jasper_is_same_object/3 (jasper): | | Jasper Library Predicates |
| jasper_new_object/5 (jasper): | | Jasper Library Predicates |
| jasper_new_object/5 (jasper): | | Deprecated Jasper Predicates |
| jasper_null/2 (jasper): | | Jasper Library Predicates |
| jasper_null/2 (jasper): | | Jasper Library Predicates |
| jasper_object_class_name/3 (jasper): | | Jasper Library Predicates |
| Java Virtual Machine: | | Jasper Overview |
| JIT compilation: | | ref-lod-ove |
| JIT compilation: | | System Properties and Environment Variables |
| jittable (predicate property): | | mpg-ref-predicate_property |
| jitted (predicate property): | | mpg-ref-predicate_property |
| jit_count (statistics key): | | ref-mgc-ove-sta |
| jit_time (statistics key): | | ref-mgc-ove-sta |
| JNDI: | | PB Features |
| join (Tcl command): | | Commands |
| json_from_atom/[2,3] (json): | | lib-json |
| json_from_codes/[2,3] (json): | | lib-json |
| json_read/[2,3] (json): | | lib-json |
| json_to_atom/[2,3] (json): | | lib-json |
| json_to_codes/[2,3] (json): | | lib-json |
| json_write/[2,3] (json): | | lib-json |
| jump to port (debugger command): | | Debug Commands |
| JVM: | | Jasper Overview |
|
| K | | |
|---|
| kernel, runtime (definition): | | Glossary |
| Key (Tk event type): | | Event Handling |
| keyboard: | | Keyboard Characters |
| keyclumped/2 (lists): | | lib-lists |
| keyclumps/2 (lists): | | lib-lists |
| keymerge/3 (samsort): | | lib-samsort |
| KeyPress (Tk event type): | | Event Handling |
| KeyRelease (Tk event type): | | Event Handling |
| keys, recorded: | | ref-mdb-idb |
| keys/1 (keysorting/3 option): | | Arithmetic-Logical Constraints |
| keysort/2 (built-in): | | ref-lte-cte-sor |
| keysort/2 (built-in, ref page): | | mpg-ref-keysort |
| keysorting/[2,3] (clpfd): | | Arithmetic-Logical Constraints |
| keys_and_values/3 (lists): | | lib-lists |
| kurtosis/2 (statistics): | | lib-statistics |
|
| L | | |
|---|
| label (Tk widget): | | Types of Widget |
| labeling: | | FDBG Annotation |
| labeling event: | | FDBG Events |
| labeling levels: | | FDBG Labeling Levels |
| labeling/1 (clpb): | | CLPB Interface |
| labeling/2 (clpfd): | | Enumeration Predicates |
| large integer (definition): | | Glossary |
| largest (labeling/2 option): | | Enumeration Predicates |
| last call optimization: | | Last Call Optimization |
| last clause determinacy detection: | | Last Clause Determinacy Detection |
| last/2 (lists): | | lib-lists |
| last/3 (lists): | | lib-lists |
| later_bound/2 (clpfd): | | Enumeration Predicates |
| later_bound/2 (clpfd): | | Enumeration Predicates |
| layout term: | | mpg-ref-read_term |
| layout term (definition): | | Glossary |
| layout/1 (read_term/[2,3] option): | | mpg-ref-read_term |
| leap (debugger command): | | Debug Commands |
| leap (definition): | | Glossary |
| leash/0 (debugger condition): | | Condition Macros |
| leash/1 (built-in): | | Basic Debug |
| leash/1 (built-in, ref page): | | mpg-ref-leash |
| leashing (definition): | | Glossary |
| Leave (Tk event type): | | Event Handling |
| leftmost (labeling/2 option): | | Enumeration Predicates |
| leftmost (table/3 order/1 value): | | Extensional Constraints |
| legacy_char_classification (prolog flag): | | ref-syn-syn-tok |
| legacy_char_classification (prolog flag): | | ref-lod-lod |
| legacy_char_classification (prolog flag): | | ref-lps-flg |
| legacy_numbervars/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| legend: | | FDBG Legend |
| legend_portray/3 (fdbg, hook): | | FDBG Customizing Output |
| length/2 (built-in): | | ref-lte-acl |
| length/2 (built-in, ref page): | | mpg-ref-length |
| length/3 (bags, deprecated): | | lib-bags |
| length_bound/2 (terms): | | lib-terms |
| level, top: | | Start |
| levels, labeling: | | FDBG Labeling Levels |
| lex/1 (geost/[2,3,4] option): | | Placement Constraints |
| lex_chain/[1,2] (clpfd): | | Arithmetic-Logical Constraints |
| library: | | The Prolog Library |
| library, searching for a file in: | | ref-fdi-fsp |
| library_directory/1 (hook, ref page): | | mpg-ref-library_directory |
| limit/1 (cumulative/2 option): | | Scheduling Constraints |
| limits, arithmetic: | | ref-ari-ove |
| Linda: | | lib-linda |
| linda/[0,1] (linda): | | lib-linda-server |
| linda_client/1 (linda_client): | | lib-linda-client |
| linda_timeout/2 (linda_client): | | lib-linda-client |
| lindex (Tcl command): | | Commands |
| line breakpoint: | | Usage |
| line, end of: | | mpg-ref-at_end_of_line |
| line/0 (input method): | | Default Input Methods |
| line/1 (debugger condition): | | Breakpoint Tests |
| line/1 (debugger condition): | | Source Tests |
| line/2 (debugger condition): | | Breakpoint Tests |
| line/2 (debugger condition): | | Source Tests |
| line_count/2 (built-in): | | ref-iou-sfh-opn |
| line_count/2 (built-in): | | ref-iou-sos |
| line_count/2 (built-in, ref page): | | mpg-ref-line_count |
| line_position/2 (built-in): | | ref-iou-sfh-opn |
| line_position/2 (built-in): | | ref-iou-sos |
| line_position/2 (built-in, ref page): | | mpg-ref-line_position |
| linked foreign resource: | | Foreign Resources |
| linked foreign resource: | | Creating the Linked Foreign Resource |
| linked foreign resource (definition): | | Glossary |
| linker, foreign resource: | | The Foreign Resource Linker |
| linsert (Tcl command): | | Commands |
| list (definition): | | Glossary |
| list (Tcl command): | | Commands |
| list constructor (definition): | | Glossary |
| list of Type (argument type): | | mpg-ref-aty-ety |
| list of variables: | | FDBG Legend |
| list processing, predicates for: | | ref-lte-sum |
| list processing, predicates for: | | mpg-top-lis |
| list separator, ’|’: | | ref-syn-cpt-lis |
| list syntax: | | Glossary |
| list, association: | | lib-assoc |
| list, association: | | lib-avl |
| list, byte (definition): | | Glossary |
| list, char (definition): | | Glossary |
| list, code (definition): | | Glossary |
| list, cyclic: | | Glossary |
| list, empty (definition): | | Glossary |
| list, partial (definition): | | Glossary |
| list, proper (definition): | | Glossary |
| listbox (Tk widget): | | Types of Widget |
| listing/[0,1] (built-in): | | Syntax Errors |
| listing/[0,1] (built-in): | | ref-mod-idp |
| listing/[0,1] (built-in, ref page): | | mpg-ref-listing |
| lists, predicates for processing: | | ref-lte-acl |
| lists, syntax of: | | ref-syn-cpt-lis |
| list_queue/2 (queues): | | lib-queues |
| list_to_assoc/2 (assoc): | | lib-assoc |
| list_to_avl/2 (avl): | | lib-avl |
| list_to_bag/2 (bags): | | lib-bags |
| list_to_fdset/2 (clpfd): | | FD Set Operations |
| list_to_mutarray/2 (mutarray): | | lib-mutarray |
| list_to_mutdict/2 (mutdict): | | lib-mutdict |
| list_to_ord_set/2 (ordsets): | | lib-ordsets |
| list_to_set/2 (sets): | | lib-sets |
| list_to_tree/2 (trees): | | lib-trees |
| llength (Tcl command): | | Commands |
| lmdb_close/1 (lmdb): | | LMDB The Predicates |
| lmdb_compress/2 (lmdb): | | LMDB The Predicates |
| lmdb_create/[2,3] (lmdb): | | LMDB The Predicates |
| lmdb_enumerate/3 (lmdb): | | LMDB The Predicates |
| lmdb_erase/2 (lmdb): | | LMDB The Predicates |
| lmdb_export/2 (lmdb): | | LMDB The Predicates |
| lmdb_fetch/3 (lmdb): | | LMDB The Predicates |
| lmdb_findall/3 (lmdb): | | LMDB The Predicates |
| lmdb_import/2 (lmdb): | | LMDB The Predicates |
| lmdb_iterator_done/1 (lmdb): | | LMDB The Predicates |
| lmdb_iterator_next/3 (lmdb): | | LMDB The Predicates |
| lmdb_make_iterator/3 (lmdb): | | LMDB The Predicates |
| lmdb_open/[2,3] (lmdb): | | LMDB The Predicates |
| lmdb_property/2 (lmdb): | | LMDB The Predicates |
| lmdb_store/3 (lmdb): | | LMDB The Predicates |
| lmdb_sync/1 (lmdb): | | LMDB The Predicates |
| lmdb_with_db/[2,3] (lmdb): | | LMDB The Predicates |
| lmdb_with_iterator/3 (lmdb): | | LMDB The Predicates |
| load (--main option value): | | too-spld |
| load (definition): | | Glossary |
| load context: | | ref-lps-lco |
| loading database: | | ref-sls-ove |
| loading module files: | | ref-mod-lod |
| loading modules: | | ref-mod-lod |
| loading PO files: | | ref-sls-ssl |
| loading programs: | | ref-sem-con |
| loading programs, predicates for: | | ref-lod-lis |
| loading programs, predicates for: | | mpg-top-lod |
| load_files/[1,2] (built-in): | | ref-sls-ssl |
| load_files/[1,2] (built-in, ref page): | | mpg-ref-load_files |
| load_foreign_resource/1 (built-in): | | Interface Predicates |
| load_foreign_resource/1 (built-in, ref page): | | mpg-ref-load_foreign_resource |
| load_type/1 (load_files/2 option): | | mpg-ref-load_files |
| local cut: | | ref-sem-ctr-ite |
| local cut: | | mpg-ref-or |
| local stack: | | ref-mgc-ove |
| LOCALSTKSIZE (system property): | | System Properties and Environment Variables |
| local_stack (statistics key): | | ref-mgc-ove-sta |
| local_stack_free (statistics key): | | ref-mgc-ove-sta |
| local_stack_used (statistics key): | | ref-mgc-ove-sta |
| locks, mutual exclusion: | | OS Threads |
| log /1, logarithm (evaluable): | | ref-ari-aex |
| log /2, logarithm (evaluable): | | ref-ari-aex |
| logic programming: | | Intro |
| logical loop: | | ref-sem-ctr-dol |
| login_timeout/1 (odbc_db_open/4 option): | | ODBC Predicates |
| longest_hole/2 (geost/[2,3,4] option): | | Placement Constraints |
| loop, do (definition): | | Glossary |
| loop, logical: | | ref-sem-ctr-dol |
| lrange (Tcl command): | | Commands |
| lreplace (Tcl command): | | Commands |
| lsearch (Tcl command): | | Commands |
| lsort (Tcl command): | | Commands |
|
| M | | |
|---|
| macro (function annotation): | | cpg-rve |
| macro expansion: | | mpg-ref-goal_expansion |
| main thread: | | Calling Prolog Asynchronously |
| make_directory/1 (file_systems): | | lib-file_systems |
| make_sub_bag/2 (bags): | | lib-bags |
| mapbag/2 (bags): | | lib-bags |
| mapbag/3 (bags): | | lib-bags |
| maplist/[2,3,4] (lists): | | lib-lists |
| mapsize/1 (lmdb option): | | LMDB Conventions |
| mapsize/1 (lmdb property): | | LMDB The Predicates |
| map_assoc/2 (assoc): | | lib-assoc |
| map_assoc/3 (assoc): | | lib-assoc |
| map_list_queue/3 (queues): | | lib-queues |
| map_product/5 (lists): | | lib-lists |
| map_queue/[2,3] (queues): | | lib-queues |
| map_queue_list/3 (queues): | | lib-queues |
| map_tree/3 (trees): | | lib-trees |
| margin/3 (disjoint1/2 option): | | Placement Constraints |
| margin/4 (disjoint2/2 option): | | Placement Constraints |
| mark-paragraph (emacs command): | | Usage |
| max (labeling/2 option): | | Enumeration Predicates |
| max /2, maximum value (evaluable): | | ref-ari-aex |
| max/1 (fd_global/[3,4] option): | | The Global Constraint Programming Interface |
| max/2 (statistics): | | lib-statistics |
| maximize/1 (clpqr): | | CLPQR Solver Predicates |
| maximize/1 (labeling/2 option): | | Enumeration Predicates |
| maximize/[2,3] (clpfd): | | Enumeration Predicates |
| maximum/2 (clpfd): | | Arithmetic Constraints |
| maximum_arg/2 (clpfd): | | Arithmetic Constraints |
| max_arity (prolog flag): | | ref-lps-flg |
| max_assoc/3 (assoc): | | lib-assoc |
| max_cliques/2 (ugraphs): | | lib-ugraphs |
| max_depth/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| max_integer (prolog flag): | | ref-lps-flg |
| max_inv/1 (debugger condition): | | Accessing Past Debugger States |
| max_inv/1 (debugger condition): | | Break Tests |
| max_member/[2,3] (lists): | | lib-lists |
| max_path/5 (ugraphs): | | lib-ugraphs |
| max_path/5 (wgraphs): | | lib-wgraphs |
| max_regret (labeling/2 option): | | Enumeration Predicates |
| max_tagged_integer (prolog flag): | | Glossary |
| max_tagged_integer (prolog flag): | | ref-lps-flg |
| maybe/[0,1,2] (random): | | lib-random |
| mean/2 (statistics): | | lib-statistics |
| median (labeling/2 option): | | Enumeration Predicates |
| median/2 (statistics): | | lib-statistics |
| member/2 (built-in): | | ref-lte-acl |
| member/2 (built-in, ref page): | | mpg-ref-member |
| member/3 (bags, deprecated): | | lib-bags |
| memberchk/2 (built-in): | | ref-lte-acl |
| memberchk/2 (built-in, ref page): | | mpg-ref-memberchk |
| memberchk/3 (bags, deprecated): | | lib-bags |
| memory (statistics key): | | ref-mgc-ove-sta |
| Memory management, C functions for: | | cpg-top-mem |
| memory statistics: | | ref-mgc-ove-sta |
| memory, general description: | | ref-mgc |
| memory, predicates for: | | ref-mgc-sum |
| memory, predicates for: | | mpg-top-mem |
| memory, reclamation: | | mpg-ref-abolish |
| memory_buckets (statistics key): | | ref-mgc-ove-sta |
| memory_culprit (statistics key): | | ref-mgc-ove-sta |
| memory_free (statistics key): | | ref-mgc-ove-sta |
| memory_used (statistics key): | | ref-mgc-ove-sta |
| menu (Tk widget): | | Types of Widget |
| menubutton (Tk widget): | | Types of Widget |
| merge/[3,4] (samsort): | | lib-samsort |
| message (Tk widget): | | Types of Widget |
| message/4 (objects): | | obj-exp-message |
| messages and queries, predicates for: | | Message Summary |
| messages and queries, predicates for: | | mpg-top-msg |
| messages, debugging: | | Debug Format |
| message_hook/3 (hook, ref page): | | mpg-ref-message_hook |
| message_hook/3 (user, hook): | | Message Handling Predicates |
| meta-call: | | ref-sem-cal |
| meta-call (definition): | | Glossary |
| meta-logical (definition): | | ref-lte-met |
| meta-logical predicate (definition): | | Glossary |
| meta-logical predicates: | | ref-lte-met |
| meta-predicate (definition): | | Glossary |
| meta-predicate declaration: | | Meta-Predicate Declarations |
| meta-predicates (definition): | | mpg-ref-cat |
| meta_predicate (predicate property): | | mpg-ref-predicate_property |
| meta_predicate declaration: | | ref-mod-met |
| meta_predicate/1 (built-in, ref page): | | mpg-ref-meta_predicate |
| meta_predicate/1 (declaration): | | Meta-Predicate Declarations |
| meta_predicate/1 (declaration): | | ref-mod-met |
| meta_predicate/1 (predicate property): | | ref-lps-app |
| method/1 (table/3 option): | | Extensional Constraints |
| method/3 (Java method identifier): | | Jasper Library Predicates |
| middle (labeling/2 option): | | Enumeration Predicates |
| min (labeling/2 option): | | Enumeration Predicates |
| min /2, minimum value (evaluable): | | ref-ari-aex |
| min/1 (fd_global/[3,4] option): | | The Global Constraint Programming Interface |
| min/2 (statistics): | | lib-statistics |
| minimize/1 (clpqr): | | CLPQR Solver Predicates |
| minimize/1 (labeling/2 option): | | Enumeration Predicates |
| minimize/[2,3] (clpfd): | | Enumeration Predicates |
| minimum/2 (clpfd): | | Arithmetic Constraints |
| minimum_arg/2 (clpfd): | | Arithmetic Constraints |
| minmax/1 (fd_global/[3,4] option): | | The Global Constraint Programming Interface |
| minus infinity, inf: | | CLPFD Interface |
| min_assoc/3 (assoc): | | lib-assoc |
| min_integer (prolog flag): | | ref-lps-flg |
| min_max/3 (statistics): | | lib-statistics |
| min_member/[2,3] (lists): | | lib-lists |
| min_path/5 (ugraphs): | | lib-ugraphs |
| min_path/5 (wgraphs): | | lib-wgraphs |
| min_paths/3 (ugraphs): | | lib-ugraphs |
| min_paths/3 (wgraphs): | | lib-wgraphs |
| min_tagged_integer (prolog flag): | | Glossary |
| min_tagged_integer (prolog flag): | | ref-lps-flg |
| min_tree/3 (ugraphs): | | lib-ugraphs |
| min_tree/3 (wgraphs): | | lib-wgraphs |
| mixing C/C++ and Prolog: | | Mixing C and Prolog |
| ml_standard_deviation/2 (statistics): | | lib-statistics |
| ml_variance/2 (statistics): | | lib-statistics |
| mod /2, integer floored remainder (evaluable): | | ref-ari-aex |
| mode annotations: | | mpg-ref-mod |
| mode declaration: | | Mode Declarations |
| mode declarations: | | ref-mod-met |
| mode spec: | | Mode Spec |
| mode/1 (built-in, ref page): | | mpg-ref-mode |
| mode/1 (debugger condition): | | Breakpoint Actions |
| mode/1 (debugger condition): | | Port Tests |
| mode/1 (debugger condition): | | Action Conditions |
| mode/1 (declaration): | | Mode Declarations |
| mode/1 (lmdb option): | | LMDB Conventions |
| mode/1 (lmdb option): | | LMDB The Predicates |
| mode/1 (stream property): | | mpg-ref-stream_property |
| mode/2 (statistics): | | lib-statistics |
| modification, database: | | ref-mdb |
| modularity, procedural: | | ref-mod-ove |
| module (definition): | | Glossary |
| module (definition): | | ref-mod-ove |
| module (load context key): | | ref-lps-lco |
| module declaration: | | Module Declarations |
| module declaration: | | ref-mod-lod |
| module file (definition): | | Glossary |
| module files: | | ref-mod-def |
| module files, converting into: | | ref-mod-n2m |
| module files, loading: | | ref-mod-lod |
| module files, loading: | | ref-mod-lod |
| module name expansion: | | Mode Spec |
| module name expansion: | | Meta-Predicate Declarations |
| module name expansion: | | ref-mod-mne |
| module name expansion (definition): | | Glossary |
| module name expansion, exceptions: | | mpg-ref-cat |
| module prefixes on clauses: | | ref-mod-mpc |
| module, declaration: | | ref-mod-def |
| module, hidden: | | ref-mod-def |
| module, source: | | ref-mod-som |
| module, source (definition): | | Glossary |
| module, type-in: | | ref-lps-flg |
| module, type-in: | | ref-mod-som |
| module, type-in (definition): | | Glossary |
| module/1 (debugger condition): | | Goal Tests |
| module/[2,3] (built-in, ref page): | | mpg-ref-module |
| module/[2,3] (declaration): | | Module Declarations |
| module/[2,3] (declaration): | | ref-mod-lod |
| modules, currently loaded: | | ref-mod-mpc-cmo |
| modules, currently loaded: | | ref-mod-ilm |
| modules, debugging: | | ref-mod-cim |
| modules, defining: | | ref-mod-def |
| modules, dynamic creation of: | | ref-mod-dmo |
| modules, exporting predicates from: | | ref-mod-def |
| modules, importing predicates into: | | ref-mod-lod |
| modules, loading: | | ref-mod-lod |
| modules, name clashes: | | ref-mod-ncl |
| modules, predicates defined in: | | ref-mod-ilm-def |
| modules, predicates exported from: | | ref-mod-ilm-def |
| modules, predicates for: | | ref-mod-sum |
| modules, predicates for: | | mpg-top-mod |
| modules, predicates imported into: | | ref-mod-ilm-vis |
| modules, source: | | ref-mod-mne |
| modules, visibility rules: | | ref-mod-vis |
| monitoring garbage collection: | | ref-mgc-mgc |
| most general unifier: | | ref-sem-sec |
| most_constrained (labeling/2 option): | | Enumeration Predicates |
| Motion (Tk event type): | | Event Handling |
| msb /1, most significant bit (evaluable): | | ref-ari-aex |
| multifile (predicate property): | | mpg-ref-predicate_property |
| multifile declaration: | | Multifile Declarations |
| multifile predicate (definition): | | Glossary |
| multifile/0 (predicate property): | | ref-lps-app |
| multifile/1 (built-in, ref page): | | mpg-ref-multifile |
| multifile/1 (declaration): | | Multifile Declarations |
| multiset: | | lib-bags |
| multi_cumulative/[2,3] (clpfd): | | Scheduling Constraints |
| must_be/4 (types): | | lib-types |
| mutable: | | Terminology |
| mutable term: | | ref-lte-mut |
| mutable term (definition): | | Glossary |
| mutable/1 (built-in): | | ref-lte-mut |
| mutable/1 (built-in, ref page): | | mpg-ref-mutable |
| mutarray_append/2 (mutarray): | | lib-mutarray |
| mutarray_gen/3 (mutarray): | | lib-mutarray |
| mutarray_get/3 (mutarray): | | lib-mutarray |
| mutarray_last/2 (mutarray): | | lib-mutarray |
| mutarray_length/2 (mutarray): | | lib-mutarray |
| mutarray_put/3 (mutarray): | | lib-mutarray |
| mutarray_set_length/2 (mutarray): | | lib-mutarray |
| mutarray_to_list/2 (mutarray): | | lib-mutarray |
| mutarray_update/4 (mutarray): | | lib-mutarray |
| mutdict_append/2 (mutdict): | | lib-mutdict |
| mutdict_clear/1 (mutdict): | | lib-mutdict |
| mutdict_delete/2 (mutdict): | | lib-mutdict |
| mutdict_empty/1 (mutdict): | | lib-mutdict |
| mutdict_gen/3 (mutdict): | | lib-mutdict |
| mutdict_get/3 (mutdict): | | lib-mutdict |
| mutdict_items/2 (mutdict): | | lib-mutdict |
| mutdict_keys/2 (mutdict): | | lib-mutdict |
| mutdict_put/3 (mutdict): | | lib-mutdict |
| mutdict_size/1 (mutdict): | | lib-mutdict |
| mutdict_update/4 (mutdict): | | lib-mutdict |
| mutdict_values/2 (mutdict): | | lib-mutdict |
| mutex: | | OS Threads |
| mutual exclusion locks: | | OS Threads |
| mzn-sicstus(1) (command line tool): | | too-mzn-sicstus |
| mzn_load_file/[2,3] (zinc): | | MiniZinc Exported Predicates |
| mzn_load_file/[2,3] (zinc): | | MiniZinc Exported Predicates |
| mzn_run_file/[1,2] (zinc): | | MiniZinc Exported Predicates |
| mzn_run_model/[1,2] (zinc): | | MiniZinc Exported Predicates |
| mzn_to_fzn/[2,3] (zinc): | | MiniZinc Exported Predicates |
|
| N | | |
|---|
| name auto-generation: | | FDBG Name Auto-Generation |
| name clash: | | ref-mod-ncl |
| name clash (definition): | | Glossary |
| name expansion, module: | | ref-mod-mne |
| name variable (debugger command): | | FDBG Debugger Commands |
| name, of a functor: | | ref-syn-cpt |
| name/1 (tk_new/2 option): | | Basic Functions |
| name/2 (built-in): | | ref-lte-c2t |
| name/2 (built-in): | | ref-lte-c2t |
| name/2 (built-in, ref page): | | mpg-ref-name |
| names of terms: | | FDBG Names of Terms |
| names of terms: | | FDBG Naming Terms |
| natural (CHR type): | | CHR Constraint Declaration |
| neighbors/3 (ugraphs): | | lib-ugraphs |
| neighbors/3 (wgraphs): | | lib-wgraphs |
| neighbours/3 (ugraphs): | | lib-ugraphs |
| neighbours/3 (wgraphs): | | lib-wgraphs |
| nested execution: | | Nested |
| network path: | | ref-fdi-syn |
| new/[2,3] (structs): | | str-cdf |
| newProlog on Jasper: | | Java Threads |
| newProlog on SICStus: | | Java Threads |
| new_mutarray/1 (mutarray): | | lib-mutarray |
| new_mutarray/2 (mutarray): | | lib-mutarray |
| new_mutdict/1 (mutdict): | | lib-mutdict |
| nextSolution on SPQuery: | | Jasper Package Class Reference |
| nextto/3 (lists): | | lib-lists |
| nl/[0,1] (built-in): | | ref-iou-cou-nln |
| nl/[0,1] (built-in, ref page): | | mpg-ref-nl |
| noaux (table/3 method/1 value): | | Extensional Constraints |
| nodebug (CHR debug command): | | CHR Tracing |
| nodebug (debugger command): | | Debug Commands |
| nodebug/0 (built-in): | | Basic Debug |
| nodebug/0 (built-in, ref page): | | mpg-ref-nodebug |
| nodebug_message/0 (objects): | | obj-exp-nodebug_message |
| non-backtraced tests: | | Breakpoint Conditions |
| nondet/0 (plunit option): | | PlUnit A Unit Test Box |
| nondeterminacy, declaring: | | Declaring Nondeterminacy |
| nondeterminacy, finding: | | The Determinacy Checker |
| nondeterminate (definition): | | Glossary |
| none (--main option value): | | too-spld |
| none (absolute_file_name/3 access): | | mpg-ref-absolute_file_name |
| nonmember/2 (built-in): | | ref-lte-acl |
| nonmember/2 (built-in, ref page): | | mpg-ref-nonmember |
| nonvar/1 (built-in, ref page): | | mpg-ref-nonvar |
| nonvar/1 (when/2 condition): | | mpg-ref-when |
| normalize/2 (statistics): | | lib-statistics |
| nospy this (debugger command): | | Debug Commands |
| nospy/1 (built-in): | | Plain Spypoint |
| nospy/1 (built-in, ref page): | | mpg-ref-nospy |
| nospyall/0 (built-in): | | Plain Spypoint |
| nospyall/0 (built-in, ref page): | | mpg-ref-nospyall |
| notation: | | Notation |
| notation: | | ref-syn-syn-not |
| notrace/0 (built-in): | | Basic Debug |
| notrace/0 (built-in, ref page): | | mpg-ref-notrace |
| now/1 (system): | | lib-system |
| nozip/0 (built-in): | | Basic Debug |
| nozip/0 (built-in, ref page): | | mpg-ref-nozip |
| nth0/[3,4] (lists): | | lib-lists |
| nth1/[3,4] (lists): | | lib-lists |
| null streams: | | ref-iou-sfh-opn |
| null_foreign_term/2 (structs): | | str-nul |
| number (CHR type): | | CHR Constraint Declaration |
| number/1 (built-in, ref page): | | mpg-ref-number |
| numbers, comparison of: | | ref-ari-acm |
| numbervars: | | lib-varnumbers |
| numbervars/1 (varnumbers): | | lib-varnumbers |
| numbervars/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| numbervars/3 (built-in): | | ref-lte-anv |
| numbervars/3 (built-in, ref page): | | mpg-ref-numbervars |
| number_chars/2 (built-in): | | ref-lte-c2t |
| number_chars/2 (built-in): | | ref-lte-c2t |
| number_chars/2 (built-in, ref page): | | mpg-ref-number_chars |
| number_codes/2 (built-in): | | ref-lte-c2t |
| number_codes/2 (built-in): | | ref-lte-c2t |
| number_codes/2 (built-in, ref page): | | mpg-ref-number_codes |
| numlist/[2,3,5] (between): | | lib-between |
| nvalue/2 (clpfd): | | Arithmetic-Logical Constraints |
|
| O | | |
|---|
| Object: | | Terminology |
| object (absolute_file_name/3 file type): | | mpg-ref-absolute_file_name |
| object, stream: | | ref-iou-sfh-sob |
| object, stream position: | | ref-iou-raf |
| objects (library package): | | lib-objects |
| occurrence (labeling/2 option): | | Enumeration Predicates |
| occurrences_of_term/3 (terms): | | lib-terms |
| occurrences_of_var/3 (terms): | | lib-terms |
| occurs check: | | ref-sem-occ |
| occurs check (definition): | | Glossary |
| odbc_db_open/3 (odbc): | | ODBC Predicates |
| odbc_db_open/4 (odbc): | | ODBC Predicates |
| odbc_db_open/5 (odbc): | | ODBC Predicates |
| odbc_env_open/1 (odbc): | | ODBC Predicates |
| odbc_list_DSN/2 (odbc): | | ODBC Predicates |
| off (debug flag value): | | ref-lps-flg |
| off (debugging flag value): | | ref-lps-flg |
| off (debugging flag value): | | mpg-ref-debugging |
| off (fileerrors flag value): | | ref-ere-err-exi |
| off (gc_trace flag value): | | ref-lps-flg |
| off (profiling flag value): | | ref-lps-flg |
| off (redefine_warnings flag value): | | ref-lps-flg |
| off/0 (debugger mode control): | | Action Variables |
| on (debug flag value): | | ref-lps-flg |
| on (fileerrors flag value): | | ref-ere-err-exi |
| on (profiling flag value): | | ref-lps-flg |
| on (redefine_warnings flag value): | | ref-lps-flg |
| once/1: | | ref-sem-ctr-ite |
| once/1 (built-in, ref page): | | mpg-ref-once |
| one of List (argument type): | | mpg-ref-aty-ety |
| one-char atom (definition): | | Glossary |
| one_longer/2 (lists): | | lib-lists |
| on_exception/3 (built-in): | | ref-ere-leg |
| on_exception/3 (built-in, ref page): | | mpg-ref-on_exception |
| op/1 (lex_chain/2 option): | | Arithmetic-Logical Constraints |
| op/3 (built-in): | | ref-syn-ops-ops |
| op/3 (built-in, ref page): | | mpg-ref-op |
| open (Tcl command): | | Commands |
| open/[3,4] (built-in): | | ref-iou-sfh-sob |
| open/[3,4] (built-in): | | ref-iou-sfh-opn |
| open/[3,4] (built-in, ref page): | | mpg-ref-open |
| opening a file: | | ref-iou-sfh-opn |
| openQuery on SICStus: | | Jasper Package Class Reference |
| openQuery on SICStus: | | Jasper Package Class Reference |
| openQuery on SICStus: | | Jasper Package Class Reference |
| open_codes_stream/2 (codesio): | | lib-codesio |
| open_null_stream/1 (built-in): | | ref-iou-sfh-opn |
| open_null_stream/1 (built-in, ref page): | | mpg-ref-open_null_stream |
| operator (definition): | | Glossary |
| operator declaration: | | ref-lod-dcl |
| operators: | | mpg-ref-op |
| operators, associativity of: | | ref-syn-ops-ove |
| operators, built-in: | | ref-syn-ops-ove |
| operators, built-in: | | ref-syn-ops-bop |
| operators, built-in predicates for handling: | | ref-syn-ops-ops |
| operators, current: | | ref-syn-ops-ops |
| operators, declaring: | | ref-syn-ops-ops |
| operators, infix: | | ref-syn-cpt |
| operators, infix: | | ref-syn-ops-ove |
| operators, list of: | | ref-syn-ops-bop |
| operators, postfix: | | ref-syn-cpt |
| operators, postfix: | | ref-syn-ops-ove |
| operators, precedence of: | | ref-syn-ops-ove |
| operators, prefix: | | ref-syn-cpt |
| operators, prefix: | | ref-syn-ops-ove |
| operators, reference page convention: | | mpg-ref-cat |
| operators, syntax restrictions on: | | ref-syn-ops-res |
| operators, type of: | | ref-syn-ops-ove |
| optimality (labeling/2 time_out/2 option value): | | Enumeration Predicates |
| optimise/1 (zinc option): | | MiniZinc Exported Predicates |
| optimization, last call: | | Last Call Optimization |
| optimize (CHR flag): | | CHR Debugging Predicates |
| optimize (CHR option): | | CHR Semantics |
| optimize/1 (zinc option): | | MiniZinc Exported Predicates |
| or: | | ref-sem-ctr-dis |
| order (argument type): | | mpg-ref-aty-ety |
| order on terms, standard: | | ref-lte-cte-sot |
| order/1 (table/3 option): | | Extensional Constraints |
| ordered/[1,2] (lists): | | lib-lists |
| ordering/1 (clpqr): | | CLPQR Solver Predicates |
| ordering/1 (clpqr): | | CLPQR Variable Ordering |
| ordset_order/3 (ordsets): | | lib-ordsets |
| ord_add_element/3 (ordsets): | | lib-ordsets |
| ord_del_element/3 (ordsets): | | lib-ordsets |
| ord_disjoint/2 (ordsets): | | lib-ordsets |
| ord_disjoint_union/3 (ordsets): | | lib-ordsets |
| ord_intersect/2 (ordsets): | | lib-ordsets |
| ord_intersection/[2,3,4] (ordsets): | | lib-ordsets |
| ord_list_to_assoc/2 (assoc): | | lib-assoc |
| ord_list_to_avl/2 (avl): | | lib-avl |
| ord_member/2 (ordsets): | | lib-ordsets |
| ord_nonmember/2 (ordsets): | | lib-ordsets |
| ord_seteq/2 (ordsets): | | lib-ordsets |
| ord_setproduct/3 (ordsets): | | lib-ordsets |
| ord_subset/2 (ordsets): | | lib-ordsets |
| ord_subtract/3 (ordsets): | | lib-ordsets |
| ord_symdiff/3 (ordsets): | | lib-ordsets |
| ord_union/[2,3,4] (ordsets): | | lib-ordsets |
| os_data (prolog flag): | | ref-lps-flg |
| otherwise/0 (built-in, ref page): | | mpg-ref-otherwise |
| out (debugger command): | | Debug Commands |
| out/1 (linda_client): | | lib-linda-client |
| output: | | ref-iou |
| output stream, current: | | ref-iou-sfh-sob |
| output, current: | | ref-iou-str |
| output, flushing: | | ref-iou-sfh-flu |
| output, term: | | ref-iou-tou |
| output/0 (stream property): | | mpg-ref-stream_property |
| output/1 (zinc option): | | FlatZinc Exported Predicates |
| output/1 (zinc option): | | MiniZinc Exported Predicates |
| output/1 (zinc option): | | MiniZinc Exported Predicates |
| output_encoding/1 (stream property): | | mpg-ref-stream_property |
| overflow (FD flag): | | The Global Constraint Programming Interface |
| overlap/1 (geost/[2,3,4] option): | | Placement Constraints |
| overlap/1 (geost/[2,3,4] option): | | Placement Constraints |
| ozn_file/1 (zinc option): | | FlatZinc Exported Predicates |
| ozn_file/1 (zinc option): | | MiniZinc Exported Predicates |
|
| P | | |
|---|
| pair (argument type): | | mpg-ref-aty-ety |
| pair (definition): | | Glossary |
| pairfrom/4 (sets): | | lib-sets |
| pallet_loading/1 (geost/[2,3,4] option): | | Placement Constraints |
| param /1, (iterator): | | ref-sem-ctr-dol |
| param/1 (iterator): | | mpg-ref-do |
| parameter, accumulating: | | Accumulating Parameters |
| parameters/1 (zinc option): | | MiniZinc Exported Predicates |
| parconflict/1 (geost/[2,3,4] option): | | Placement Constraints |
| parent (definition): | | Glossary |
| parent_clause/1 (debugger condition): | | Breakpoint Tests |
| parent_clause/1 (debugger condition): | | Source Tests |
| parent_clause/2 (debugger condition): | | Breakpoint Tests |
| parent_clause/2 (debugger condition): | | Source Tests |
| parent_clause/3 (debugger condition): | | Breakpoint Tests |
| parent_clause/3 (debugger condition): | | Source Tests |
| parent_inv/1 (debugger condition): | | Accessing Past Debugger States |
| parent_inv/1 (debugger condition): | | Goal Tests |
| parent_pred/1 (debugger condition): | | Breakpoint Tests |
| parent_pred/1 (debugger condition): | | Source Tests |
| parent_pred/2 (debugger condition): | | Breakpoint Tests |
| parent_pred/2 (debugger condition): | | Source Tests |
| parsing phrases: | | mpg-ref-phrase |
| partial list (definition): | | Glossary |
| partition/5 (lists): | | lib-lists |
| passive/1 (CHR pragma): | | CHR Semantics |
| password/1 (odbc_db_open/4 option): | | ODBC Predicates |
| path root: | | ref-fdi-syn |
| path, absolute: | | ref-fdi-syn |
| path, absolute: | | ref-fdi-syn |
| path, case-normalized: | | ref-fdi-syn |
| path, network: | | ref-fdi-syn |
| path, UNC: | | ref-fdi-syn |
| path/1 (lmdb property): | | LMDB The Predicates |
| path/3 (ugraphs): | | lib-ugraphs |
| path/3 (wgraphs): | | lib-wgraphs |
| peek_byte/[1,2] (built-in): | | ref-iou-cin-pee |
| peek_byte/[1,2] (built-in, ref page): | | mpg-ref-peek_byte |
| peek_char/[1,2] (built-in): | | ref-iou-cin-pee |
| peek_char/[1,2] (built-in, ref page): | | mpg-ref-peek_char |
| peek_code/[1,2] (built-in): | | ref-iou-cin-pee |
| peek_code/[1,2] (built-in, ref page): | | mpg-ref-peek_code |
| perm/2 (lists): | | lib-lists |
| perm2/4 (lists): | | lib-lists |
| permission errors: | | ref-ere-err-per |
| permission/1 (lmdb option): | | LMDB Conventions |
| permission_error/[3,5] (error class): | | ref-ere-err |
| permutation/1 (keysorting/3 option): | | Arithmetic-Logical Constraints |
| permutation/2 (lists): | | lib-lists |
| phrase/[2,3] (built-in): | | ref-gru-exa |
| phrase/[2,3] (built-in, ref page): | | mpg-ref-phrase |
| pi /0, pi (evaluable): | | ref-ari-aex |
| placement of cut: | | Placement of Cuts |
| plain spypoint: | | Plain Spypoint |
| plain spypoint: | | Creating Breakpoints |
| platform_data (prolog flag): | | ref-lps-flg |
| pltrace-break (emacs command): | | Usage |
| plus infinity, sup: | | CLPFD Interface |
| PO file (definition): | | Glossary |
| PO files: | | ref-sls-ove |
| PO files, loading: | | ref-sls-ssl |
| PO files, saving: | | ref-sls-ssl |
| point, advice (definition): | | Glossary |
| pointer_object/2 (objects): | | obj-exp-pointer_object |
| polymorphism/1 (geost/[2,3,4] option): | | Placement Constraints |
| population_standard_deviation/2 (statistics): | | lib-statistics |
| population_variance/2 (statistics): | | lib-statistics |
| port (definition): | | Glossary |
| port debugger: | | Procedure Box |
| port, debugger: | | Port Tests |
| port/1 (debugger condition): | | Breakpoint Tests |
| port/1 (debugger condition): | | Port Tests |
| port/1 (start/1 option): | | PB Prolog Server Interface |
| portable (quoted_charset flag value): | | ref-lps-flg |
| portray/1 (hook, ref page): | | mpg-ref-portray |
| portray/1 (user, hook): | | ref-iou-tou-por |
| portray/1 (user, hook): | | CLPQR Fragments and Bits |
| portrayed/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| portray_assoc/1 (assoc): | | lib-assoc |
| portray_avl/1 (avl): | | lib-avl |
| portray_bag/1 (bags): | | lib-bags |
| portray_clause/[1,2] (built-in): | | ref-iou-tou-pcl |
| portray_clause/[1,2] (built-in, ref page): | | mpg-ref-portray_clause |
| portray_message/2 (hook, ref page): | | mpg-ref-portray_message |
| portray_message/2 (user, hook): | | Message Handling Predicates |
| portray_queue/1 (queues): | | lib-queues |
| position in a stream: | | ref-iou-raf |
| position, stream: | | ref-iou-sos |
| position, stream (definition): | | Glossary |
| position/1 (stream property): | | mpg-ref-stream_property |
| post/1 (zinc option): | | MiniZinc Exported Predicates |
| postfix operators: | | ref-syn-cpt |
| postfix operators: | | ref-syn-ops-ove |
| posting constraints: | | Posting Constraints |
| power_set/2 (sets): | | lib-sets |
| precedence (definition): | | Glossary |
| precedence, of operators: | | ref-syn-ops-ove |
| precedences/1 (cumulative/2 option): | | Scheduling Constraints |
| precedences/1 (multi_cumulatives/3 option): | | Scheduling Constraints |
| pred/1 (debugger condition): | | Creating Breakpoints |
| pred/1 (debugger condition): | | Goal Tests |
| predicate: | | ref-sem-pro |
| predicate (definition): | | Glossary |
| predicate declaration: | | ref-lod-dcl |
| predicate specification (definition): | | Glossary |
| predicate specification, generalized (definition): | | Glossary |
| predicate, built-in (definition): | | Glossary |
| predicate, dynamic (definition): | | Glossary |
| predicate, FD: | | User-Defined Constraints |
| predicate, FD: | | FD Predicates |
| predicate, foreign (definition): | | Glossary |
| predicate, hook: | | Multifile Declarations |
| predicate, hook (definition): | | Glossary |
| predicate, hookable (definition): | | Glossary |
| predicate, meta-logical (definition): | | Glossary |
| predicate, multifile (definition): | | Glossary |
| predicate, public: | | ref-mod-def |
| predicate, static (definition): | | Glossary |
| predicate, steadfast (definition): | | Glossary |
| predicate, undefined: | | Undefined Predicates |
| predicate, undefined: | | ref-lps-flg |
| predicate, undefined: | | mpg-ref-unknown_predicate_handler |
| predicates defined in modules: | | ref-mod-ilm-def |
| predicates exported from modules: | | ref-mod-ilm-def |
| predicates for all solutions: | | ref-all-sum |
| predicates for all solutions: | | mpg-top-all |
| predicates for arithmetic: | | ref-ari-sum |
| predicates for arithmetic: | | mpg-top-ari |
| predicates for character I/O: | | ref-iou-sum |
| predicates for character I/O: | | mpg-top-cio |
| predicates for control: | | ref-sem-con |
| predicates for control: | | mpg-top-con |
| predicates for database: | | ref-mdb-sum |
| predicates for database: | | mpg-top-dat |
| predicates for debugging: | | Debug Summary |
| predicates for debugging: | | mpg-top-deb |
| predicates for execution state: | | ref-ere-sum |
| predicates for execution state: | | mpg-top-est |
| predicates for file and stream handling: | | ref-iou-sum |
| predicates for file and stream handling: | | mpg-top-fsh |
| predicates for filename manipulation: | | ref-fdi-pre |
| predicates for filename manipulation: | | mpg-top-fnm |
| predicates for foreign interface: | | mpg-top-fin |
| predicates for grammar rules: | | ref-gru-sum |
| predicates for grammar rules: | | mpg-top-gru |
| predicates for list processing: | | ref-lte-sum |
| predicates for list processing: | | mpg-top-lis |
| predicates for loading programs: | | ref-lod-lis |
| predicates for loading programs: | | mpg-top-lod |
| predicates for looking at terms: | | ref-lte |
| predicates for memory: | | ref-mgc-sum |
| predicates for memory: | | mpg-top-mem |
| predicates for messages and queries: | | Message Summary |
| predicates for messages and queries: | | mpg-top-msg |
| predicates for modules: | | ref-mod-sum |
| predicates for modules: | | mpg-top-mod |
| predicates for processing lists: | | ref-lte-acl |
| predicates for program state: | | ref-lps-sum |
| predicates for program state: | | mpg-top-sta |
| predicates for saving programs: | | ref-sls-lis |
| predicates for saving programs: | | mpg-top-eqs |
| predicates for term comparison: | | ref-lte-sum |
| predicates for term comparison: | | mpg-top-tcm |
| predicates for term handling: | | ref-lte-sum |
| predicates for term handling: | | mpg-top-tha |
| predicates for term I/O: | | ref-iou-sum |
| predicates for term I/O: | | mpg-top-tio |
| predicates for type tests: | | ref-lte-met-typ |
| predicates for type tests: | | ref-lte-met-typ |
| predicates for type tests: | | ref-lte-sum |
| predicates for type tests: | | mpg-top-typ |
| predicates imported into modules: | | ref-mod-ilm-vis |
| predicates, annotations: | | mpg-ref-cat |
| predicates, assertion and retraction: | | ref-mdb-bas |
| predicates, breakpoint handling: | | Breakpoint Predicates |
| predicates, debugging: | | Basic Debug |
| predicates, hook: | | mpg-top-hok |
| predicates, importing dynamic: | | ref-mod-idp |
| predicates, meta-logical: | | ref-lte-met |
| predicates, private: | | ref-mod-bas |
| predicates, public: | | ref-mod-bas |
| predicates, read: | | ref-iou-tin-trm |
| predicates, write: | | ref-iou-tou-wrt |
| predicate_property/2 (built-in): | | ref-lps-app |
| predicate_property/2 (built-in): | | ref-mod-ilm-vis |
| predicate_property/2 (built-in): | | ref-mod-ilm-vis |
| predicate_property/2 (built-in): | | ref-mod-ilm-vis |
| predicate_property/2 (built-in, ref page): | | mpg-ref-predicate_property |
| pred_spec (argument type): | | mpg-ref-aty-ety |
| pred_spec_forest (argument type): | | mpg-ref-aty-ety |
| pred_spec_tree (argument type): | | mpg-ref-aty-ety |
| prefix operators: | | ref-syn-cpt |
| prefix operators: | | ref-syn-ops-ove |
| prefix/2 (lists): | | lib-lists |
| prefix_length/3 (lists): | | lib-lists |
| preinit (function annotation): | | cpg-rve |
| prelinked foreign resource (definition): | | Glossary |
| prelinked resource: | | Foreign Resources |
| principal functor: | | ref-lte-act |
| principal functor (definition): | | ref-syn-cpt |
| print (debugger command): | | Debug Commands |
| print/0 (debugger show control): | | Action Variables |
| print/[1,2] (built-in): | | ref-iou-tou-dsp |
| print/[1,2] (built-in, ref page): | | mpg-ref-print |
| printing clauses: | | ref-iou-tou-pcl |
| printing, formatted: | | ref-iou-cou-fou |
| print_coverage/[0,1] (built-in): | | Coverage Analysis |
| print_coverage/[0,1] (built-in, ref page): | | mpg-ref-print_coverage |
| print_message/2 (built-in): | | Message Handling Predicates |
| print_message/2 (built-in, ref page): | | mpg-ref-print_message |
| print_message_lines/3 (built-in): | | Message Handling Predicates |
| print_message_lines/3 (built-in, ref page): | | mpg-ref-print_message_lines |
| print_profile/[0,1] (built-in): | | Execution Profiling |
| print_profile/[0,1] (built-in, ref page): | | mpg-ref-print_profile |
| priority/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| private predicates: | | ref-mod-bas |
| private/1 (debugger condition): | | Storing User Information in the Backtrace |
| private/1 (debugger condition): | | Break Tests |
| proc (Tcl command): | | Commands |
| procedural modularity: | | ref-mod-ove |
| procedural semantics: | | ref-sem-sec |
| procedural semantics: | | ref-sem-sec |
| procedure: | | ref-sem-pro |
| procedure (definition): | | Glossary |
| procedure box: | | Procedure Box |
| procedure box (definition): | | Glossary |
| procedure call: | | ref-sem-pro |
| procedure call: | | ref-sem-sec |
| procedure definition: | | ref-sem-sec |
| procedures, dynamic and static: | | ref-mdb-dsp |
| procedures, redefining during execution: | | ref-lod-rpx |
| procedures, removing properties: | | mpg-ref-abolish |
| procedures, self-modifying: | | ref-mdb-bas |
| procedures, self-modifying: | | ref-mdb-exa |
| proceed (redefine_warnings flag value): | | ref-lps-flg |
| proceed/0 (debugger command control): | | Action Variables |
| proceed/2 (debugger command control): | | Action Variables |
| process communication: | | lib-linda |
| process communication: | | lib-sockets |
| processing, breakpoint: | | Breakpoint Processing |
| process_create/[2,3] (process): | | lib-process |
| process_id/1 (process): | | lib-process |
| process_id/2 (process): | | lib-process |
| process_kill/[1,2] (process): | | lib-process |
| process_release/1 (process): | | lib-process |
| process_wait/[2,3] (process): | | lib-process |
| profile_data/1 (built-in): | | Execution Profiling |
| profile_data/1 (built-in, ref page): | | mpg-ref-profile_data |
| profile_reset/0 (built-in): | | Execution Profiling |
| profile_reset/0 (built-in): | | Coverage Analysis |
| profile_reset/0 (built-in, ref page): | | mpg-ref-profile_reset |
| profiling: | | lib-gauge |
| profiling (definition): | | Glossary |
| profiling (prolog flag): | | ref-lps-flg |
| profiling (prolog flag): | | Runtime Systems |
| profiling, execution: | | Execution Profiling |
| ProgID: | | Terminology |
| program (definition): | | Glossary |
| program (statistics key): | | ref-mgc-ove-sta |
| program space: | | ref-mgc-ove |
| program state: | | Saving |
| program state, predicates for: | | ref-lps-sum |
| program state, predicates for: | | mpg-top-sta |
| program, loading: | | ref-sem-con |
| programming in logic: | | Intro |
| projecting_assert/1 (clpqr): | | CLPQR Solver Predicates |
| project_attributes/2 (Module): | | lib-atts |
| prolog (--main option value): | | too-spld |
| prolog (quoted_charset flag value): | | ref-lps-flg |
| prolog-backward-list (emacs command): | | Usage |
| prolog-beginning-of-clause (emacs command): | | Usage |
| prolog-beginning-of-predicate (emacs command): | | Usage |
| prolog-debug-on (emacs command): | | Usage |
| prolog-end-of-clause (emacs command): | | Usage |
| prolog-end-of-predicate (emacs command): | | Usage |
| prolog-forward-list (emacs command): | | Usage |
| prolog-help-on-predicate (emacs command): | | Usage |
| prolog-insert-next-clause (emacs command): | | Usage |
| prolog-insert-predicate-template (emacs command): | | Usage |
| prolog-insert-predspec (emacs command): | | Usage |
| prolog-mark-clause (emacs command): | | Usage |
| prolog-mark-predicate (emacs command): | | Usage |
| prolog-trace-on (emacs command): | | Usage |
| prolog-variables-to-anonymous (emacs command): | | Usage |
| prolog-zip-on (emacs command): | | Usage |
| PROLOGINCSIZE (system property): | | System Properties and Environment Variables |
| PROLOGINITSIZE (system property): | | ref-mgc-ove-rsp |
| PROLOGINITSIZE (system property): | | System Properties and Environment Variables |
| PROLOGKEEPSIZE (system property): | | ref-mgc-ove-rsp |
| PROLOGKEEPSIZE (system property): | | System Properties and Environment Variables |
| PROLOGMAXSIZE (system property): | | System Properties and Environment Variables |
| prolog_flag/[2,3] (built-in): | | ref-iou-tin-trm |
| prolog_flag/[2,3] (built-in, ref page): | | mpg-ref-prolog_flag |
| prolog_load_context/2 (built-in, ref page): | | mpg-ref-prolog_load_context |
| prompt, changing: | | ref-iou-tin-cpr |
| prompt/2 (built-in): | | ref-iou-tin-cpr |
| prompt/2 (built-in, ref page): | | mpg-ref-prompt |
| propagating indexicals: | | Indexicals |
| proper list (definition): | | Glossary |
| property, stream: | | mpg-ref-stream_property |
| property, stream (definition): | | Glossary |
| proper_length/2 (lists): | | lib-lists |
| proper_prefix/2 (lists): | | lib-lists |
| proper_prefix_length/3 (lists): | | lib-lists |
| proper_segment/2 (lists): | | lib-lists |
| proper_suffix/2 (lists): | | lib-lists |
| proper_suffix_length/3 (lists): | | lib-lists |
| prototype, function: | | Function Prototypes |
| prunings (fd_statistics/2 option): | | Statistics Predicates |
| prunings (zinc option value): | | MiniZinc Exported Predicates |
| public declaration: | | Public Declarations |
| public predicate: | | ref-mod-def |
| public predicates: | | ref-mod-bas |
| public/1 (built-in, ref page): | | mpg-ref-public |
| public/1 (declaration): | | Public Declarations |
| puts (Tcl command): | | Commands |
| put_assoc/4 (assoc): | | lib-assoc |
| put_atts/2 (Module): | | lib-atts |
| put_byte/[1,2] (built-in): | | ref-iou-cou-cha |
| put_byte/[1,2] (built-in, ref page): | | mpg-ref-put_byte |
| put_char/[1,2] (built-in): | | ref-iou-cou-cha |
| put_char/[1,2] (built-in, ref page): | | mpg-ref-put_char |
| put_code/[1,2] (built-in): | | ref-iou-cou-cha |
| put_code/[1,2] (built-in, ref page): | | mpg-ref-put_code |
| put_contents/3 (structs): | | str-afd |
| put_label/[4,5] (trees): | | lib-trees |
|
| Q | | |
|---|
| qskip/1 (debugger mode control): | | Action Variables |
| quantifier, existential: | | ref-all-cse-equ |
| quasi-skip (debugger command): | | Debug Commands |
| query: | | Start |
| query: | | Queries and Directives |
| query: | | ref-sem-pro |
| query (definition): | | Glossary |
| query on SICStus: | | Jasper Package Class Reference |
| query on SICStus: | | Jasper Package Class Reference |
| query on SICStus: | | Jasper Package Class Reference |
| query, floundered (definition): | | Glossary |
| queryCutFail on SICStus: | | Jasper Package Class Reference |
| queryCutFail on SICStus: | | Jasper Package Class Reference |
| queryCutFail on SICStus: | | Jasper Package Class Reference |
| query_abbreviation/3 (hook, ref page): | | mpg-ref-query_abbreviation |
| query_abbreviation/3 (SU_messages): | | Query Handling Predicates |
| query_class/5 (hook, ref page): | | mpg-ref-query_class |
| query_class/5 (SU_messages): | | Query Handling Predicates |
| query_class_hook/5 (hook, ref page): | | mpg-ref-query_class_hook |
| query_class_hook/5 (user, hook): | | Query Handling Predicates |
| query_hook/6 (hook, ref page): | | mpg-ref-query_hook |
| query_hook/6 (user, hook): | | Query Handling Predicates |
| query_input/3 (hook, ref page): | | mpg-ref-query_input |
| query_input/3 (SU_messages): | | Query Handling Predicates |
| query_input_hook/3 (hook, ref page): | | mpg-ref-query_input_hook |
| query_input_hook/3 (user, hook): | | Query Handling Predicates |
| query_map/4 (hook, ref page): | | mpg-ref-query_map |
| query_map/4 (SU_messages): | | Query Handling Predicates |
| query_map_hook/4 (hook, ref page): | | mpg-ref-query_map_hook |
| query_map_hook/4 (user, hook): | | Query Handling Predicates |
| queue_append/3 (queues): | | lib-queues |
| queue_cons/3 (queues): | | lib-queues |
| queue_head/2 (queues): | | lib-queues |
| queue_last/[2,3] (queues): | | lib-queues |
| queue_length/2 (queues): | | lib-queues |
| queue_list/2 (queues): | | lib-queues |
| queue_member/2 (queues): | | lib-queues |
| queue_memberchk/2 (queues): | | lib-queues |
| queue_tail/2 (queues): | | lib-queues |
| quiet (syntax_errors flag value): | | ref-lps-flg |
| quiet (syntax_errors flag value): | | ref-ere-err-syn |
| quote characters, in atoms: | | ref-syn-trm-ato |
| quoted/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| quoted/1, write_term/[2,3] option: | | ref-iou-tou-dis |
| quoted_charset (prolog flag): | | ref-lps-flg |
| quoted_charset (prolog flag): | | mpg-ref-write_term |
| quoted_charset/1 (write_term/[2,3] option): | | mpg-ref-write_term |
|
| R | | |
|---|
| radiobutton (Tk widget): | | Types of Widget |
| raise exception (debugger command): | | Debug Commands |
| raise/1 (debugger command control): | | Action Variables |
| raise_exception/1 (built-in): | | ref-ere-leg |
| raise_exception/1 (built-in, ref page): | | mpg-ref-raise_exception |
| random access to streams: | | ref-iou-raf |
| random/[1,3] (random): | | lib-random |
| random_member/2 (random): | | lib-random |
| random_numlist/4 (random): | | lib-random |
| random_perm2/4 (random): | | lib-random |
| random_permutation/2 (random): | | lib-random |
| random_select/3 (random): | | lib-random |
| random_subseq/3 (random): | | lib-random |
| random_ugraph/3 (ugraphs): | | lib-ugraphs |
| random_wgraph/4 (wgraphs): | | lib-wgraphs |
| range of floats: | | ref-ari-ove |
| range of integers: | | ref-ari-ove |
| range/2 (statistics): | | lib-statistics |
| range_to_fdset/2 (clpfd): | | FD Set Operations |
| raw/1 (odbc_db_open/4 option): | | ODBC Predicates |
| rd/[1,2] (linda_client): | | lib-linda-client |
| rd_noblock/1 (linda_client): | | lib-linda-client |
| reachable/3 (ugraphs): | | lib-ugraphs |
| reachable/3 (wgraphs): | | lib-wgraphs |
| read (absolute_file_name/3 access): | | mpg-ref-absolute_file_name |
| read (open/[3,4] mode): | | mpg-ref-open |
| read (Tcl command): | | Commands |
| read predicates: | | ref-iou-tin-trm |
| read/[1,2] (built-in): | | ref-iou-tin-trm |
| read/[1,2] (built-in, ref page): | | mpg-ref-read |
| reading a goal from a string: | | Reading a goal from a string |
| reading in: | | Reading In |
| read_from_codes/2 (codesio): | | lib-codesio |
| read_line/[1,2] (built-in, ref page): | | mpg-ref-read_line |
| read_record/[1,2] (csv): | | lib-csv |
| read_records/[1,2] (csv): | | lib-csv |
| read_record_from_codes/[2,3] (csv): | | lib-csv |
| read_term/[2,3] (built-in): | | ref-iou-tin-trm |
| read_term/[2,3] (built-in, ref page): | | mpg-ref-read_term |
| read_term_from_codes/3 (codesio): | | lib-codesio |
| reclamation, space: | | ref-mgc-ove-rsp |
| reconsult: | | Consult |
| reconsult/1 (built-in, ref page): | | mpg-ref-reconsult |
| recorda/3 (built-in): | | ref-mdb-idb |
| recorda/3 (built-in, ref page): | | mpg-ref-recorda |
| recorded keys: | | ref-mdb-idb |
| recorded/3 (built-in, ref page): | | mpg-ref-recorded |
| recordz/3 (built-in): | | ref-mdb-idb |
| recordz/3 (built-in, ref page): | | mpg-ref-recordz |
| recursion (definition): | | Glossary |
| red cut: | | ref-sem-ctr-cut |
| redefine_warnings (prolog flag): | | ref-lod-lod |
| redefine_warnings (prolog flag): | | ref-lps-flg |
| redefine_warnings (prolog flag): | | Runtime Systems |
| redefining procedures, during execution: | | ref-lod-rpx |
| redo (CHR port): | | CHR Ports |
| redo (leashing mode): | | Basic Debug |
| redo/0 (debugger port value): | | Port Tests |
| redo/1 (debugger command control): | | Action Variables |
| reduce/2 (ugraphs): | | lib-ugraphs |
| reduce/2 (wgraphs): | | lib-wgraphs |
| reexit/1 (debugger command control): | | Action Variables |
| reference page conventions: | | mpg-ref-ove |
| reference, term: | | Mixing C and Prolog |
| regexp (Tcl command): | | Commands |
| region (definition): | | Glossary |
| register_event_listener/[2,3] (prologbeans): | | PB Prolog Server Interface |
| register_query/[2,3] (prologbeans): | | PB Prolog Server Interface |
| regsub (Tcl command): | | Commands |
| regular/2 (clpfd): | | Sequence Constraints |
| reification: | | Reified Constraints |
| reject (redefine_warnings flag value): | | ref-lps-flg |
| reject (top-level command): | | Queries |
| relation/3 (clpfd): | | Extensional Constraints |
| relative_to/1 (absolute_file_name/3 option): | | mpg-ref-absolute_file_name |
| rem /2, integer truncated remainder (evaluable): | | ref-ari-aex |
| remove (CHR port): | | CHR Ports |
| remove this (debugger command): | | Debug Commands |
| remove_attribute_prefixes/1 (xml_parse/3 option): | | lib-xml |
| remove_breakpoints/1 (built-in): | | Built-in Predicates for Breakpoint Handling |
| remove_breakpoints/1 (built-in): | | Breakpoint Predicates |
| remove_breakpoints/1 (built-in, ref page): | | mpg-ref-remove_breakpoints |
| remove_dups/2 (lists): | | lib-lists |
| rem_add_link/4 (rem): | | lib-rem |
| rem_create/2 (rem): | | lib-rem |
| rem_equivalent/3 (rem): | | lib-rem |
| rem_head/3 (random): | | lib-rem |
| rename_directory/2 (file_systems): | | lib-file_systems |
| rename_file/2 (file_systems): | | lib-file_systems |
| repeat/0 (built-in, ref page): | | mpg-ref-repeat |
| repeat/1 (between): | | lib-between |
| reposition/1 (open/4 option): | | mpg-ref-open |
| reposition/1 (stream property): | | mpg-ref-stream_property |
| representation errors: | | ref-ere-err-rep |
| representation_error/[1,3] (error class): | | ref-ere-err |
| reset (open/4 eof_action value): | | mpg-ref-open |
| reset printdepth (debugger command): | | Debug Commands |
| reset printdepth (top-level command): | | Queries |
| reset subterm (debugger command): | | Debug Commands |
| reset subterm (top-level command): | | Queries |
| resource errors: | | ref-ere-err-res |
| resource, colored: | | Scheduling Constraints |
| resource, cumulative: | | Scheduling Constraints |
| resource, data: | | too-spld |
| resource, dynamic: | | Foreign Resources |
| resource, foreign: | | Foreign Resources |
| resource, foreign (definition): | | Glossary |
| resource, linked foreign (definition): | | Glossary |
| resource, prelinked: | | Foreign Resources |
| resource, static: | | Foreign Resources |
| resource_error/[1,2] (error class): | | ref-ere-err |
| rest of list, ’|’: | | ref-syn-cpt-lis |
| restart (labeling/2 option): | | Enumeration Predicates |
| restore (--main option value): | | too-spld |
| restore/1 (built-in): | | Saving |
| restore/1 (built-in): | | ref-sls-sst |
| restore/1 (built-in, ref page): | | mpg-ref-restore |
| restoring: | | Saving |
| restrictions, operator syntax: | | ref-syn-ops-res |
| resumptions (fd_statistics/2 option): | | Statistics Predicates |
| retract/1 (built-in): | | ref-mdb-rcd |
| retract/1 (built-in, ref page): | | mpg-ref-retract |
| retractall/1 (built-in): | | ref-mdb-rcd |
| retractall/1 (built-in, ref page): | | mpg-ref-retractall |
| retry (debugger command): | | Debug Commands |
| retry/1 (debugger command control): | | Action Variables |
| return (Tcl command): | | Commands |
| rev/2 (lists): | | lib-lists |
| reverse/2 (lists): | | lib-lists |
| rewriting, syntactic: | | ref-fdi-syn |
| rotate_list/[2,3] (lists): | | lib-lists |
| round /1, (evaluable): | | ref-ari-aex |
| rule (definition): | | Glossary |
| rule, computation: | | ref-sem-sec |
| rule, search: | | ref-sem-sec |
| run-prolog (emacs command): | | Usage |
| running: | | Start |
| runtime (statistics key): | | ref-mgc-ove-sta |
| runtime (zinc option value): | | MiniZinc Exported Predicates |
| runtime kernel (definition): | | Glossary |
| runtime system: | | Development and Runtime Systems |
| runtime system: | | Stand-Alone Executables |
| runtime system (definition): | | Glossary |
| runtime system, extended (definition): | | Glossary |
| runtime_entry/1 (hook, ref page): | | mpg-ref-runtime_entry |
| runtime_entry/1 (user, hook): | | too-spld |
| run_tests/[0,1,2] (plunit): | | PlUnit Running the Test-Suite |
|
| S | | |
|---|
| same_functor/[2,3,4] (terms): | | lib-terms |
| same_length/[2,3] (lists): | | lib-lists |
| samkeysort/2 (samsort): | | lib-samsort |
| sample_standard_deviation/2 (statistics): | | lib-statistics |
| sample_variance/2 (statistics): | | lib-statistics |
| samsort/[2,3] (samsort): | | lib-samsort |
| sat/1 (clpb): | | CLPB Interface |
| satisfy (labeling/2 option): | | Enumeration Predicates |
| saved state: | | Saving |
| saved state: | | ref-sls-sst |
| saved state (definition): | | Glossary |
| saved states, initialization of: | | ref-sls-sst |
| saved_state (absolute_file_name/3 file type): | | mpg-ref-absolute_file_name |
| save_files/2 (built-in): | | Saving |
| save_files/2 (built-in): | | ref-sls-ssl |
| save_files/2 (built-in, ref page): | | mpg-ref-save_files |
| save_modules/2 (built-in): | | Saving |
| save_modules/2 (built-in): | | ref-sls-ssl |
| save_modules/2 (built-in, ref page): | | mpg-ref-save_modules |
| save_predicates/2 (built-in): | | Saving |
| save_predicates/2 (built-in): | | ref-sls-ssl |
| save_predicates/2 (built-in, ref page): | | mpg-ref-save_predicates |
| save_program/[1,2] (built-in): | | Saving |
| save_program/[1,2] (built-in): | | ref-sls-sst |
| save_program/[1,2] (built-in, ref page): | | mpg-ref-save_program |
| saving: | | Saving |
| saving database: | | ref-sls-ove |
| saving PO files: | | ref-sls-ssl |
| saving programs, predicates for: | | ref-sls-lis |
| saving programs, predicates for: | | mpg-top-eqs |
| scalar_product/4 (case/4 option): | | Extensional Constraints |
| scalar_product/[4,5] (clpfd): | | Arithmetic Constraints |
| scalar_product_reif/[5,6] (clpfd): | | Arithmetic Constraints |
| scale (Tk widget): | | Types of Widget |
| scan (Tcl command): | | Commands |
| scanlist/[4,5,6] (lists): | | lib-lists |
| scollbar (Tk widget): | | Types of Widget |
| scope of variables: | | ref-sem-pro |
| search (absolute_file_name/3 access): | | mpg-ref-absolute_file_name |
| search rule: | | ref-sem-sec |
| search/1 (zinc option): | | FlatZinc Exported Predicates |
| search/1 (zinc option): | | MiniZinc Exported Predicates |
| searchable (absolute_file_name/3 access): | | mpg-ref-absolute_file_name |
| searching, for a file in a library: | | ref-fdi-fsp |
| seconds since the Epoch: | | lib-file_systems |
| see/1 (built-in): | | ref-iou-sfh-opn |
| see/1 (built-in, ref page): | | mpg-ref-see |
| seeing/1 (built-in): | | ref-iou-sfh-cis |
| seeing/1 (built-in, ref page): | | mpg-ref-seeing |
| seek/4 (built-in): | | ref-iou-raf |
| seek/4 (built-in, ref page): | | mpg-ref-seek |
| seen/0 (built-in): | | ref-iou-sfh-cst |
| seen/0 (built-in, ref page): | | mpg-ref-seen |
| segment/2 (lists): | | lib-lists |
| select/3 (lists): | | lib-lists |
| select/4 (lists): | | lib-lists |
| selectchk/3 (lists): | | lib-lists |
| selectchk/4 (lists): | | lib-lists |
| selector: | | FDBG Selectors |
| selector, subterm: | | Queries |
| selector, subterm: | | Breakpoint Tests |
| selector, subterm (definition): | | Glossary |
| select_max/[3,4] (lists): | | lib-lists |
| select_min/[3,4] (lists): | | lib-lists |
| self-modifying procedures: | | ref-mdb-bas |
| self-modifying procedures: | | ref-mdb-exa |
| semantics: | | ref-sem |
| semantics (definition): | | Glossary |
| semantics of dynamic code: | | ref-mdb-bas |
| semantics of grammar rules: | | ref-gru-tra |
| semantics, declarative: | | ref-sem-sec |
| semantics, procedural: | | ref-sem-sec |
| semantics, procedural: | | ref-sem-sec |
| sentence: | | ref-sem-pro |
| sentence (definition): | | Glossary |
| sentences: | | ref-syn-syn |
| sequence, escape: | | ref-syn-syn-esc |
| sequence, escape (definition): | | Glossary |
| seq_precede_chain/[1,2] (clpfd): | | Sequence Constraints |
| servlet: | | PB Features |
| session_gc_timeout/1 (start/1 option): | | PB Prolog Server Interface |
| session_get/4 (prologbeans): | | PB Prolog Server Interface |
| session_put/3 (prologbeans): | | PB Prolog Server Interface |
| session_timeout/1 (start/1 option): | | PB Prolog Server Interface |
| set (Tcl command): | | Commands |
| set printdepth (debugger command): | | Debug Commands |
| set printdepth (top-level command): | | Queries |
| set subterm (debugger command): | | Debug Commands |
| set subterm (top-level command): | | Queries |
| set, character: | | ref-syn-syn-tok |
| set, FD: | | FD Set Operations |
| set/1 (plunit option): | | PlUnit A Unit Test Box |
| seteq/2 (sets): | | lib-sets |
| setof/3 (built-in): | | ref-all-cse |
| setof/3 (built-in, ref page): | | mpg-ref-setof |
| setproduct/3 (sets): | | lib-sets |
| setrand/1 (random): | | lib-random |
| sets, collecting solutions to a goal: | | ref-all |
| setting a breakpoint: | | Usage |
| setup/1 (plunit option): | | PlUnit A Unit Test Box |
| set_input/1 (built-in): | | ref-iou-sfh-opn |
| set_input/1 (built-in): | | ref-iou-sfh-opn |
| set_input/1 (built-in, ref page): | | mpg-ref-set_input |
| set_module/1 (built-in): | | ref-mod-tyi |
| set_module/1 (built-in, ref page): | | mpg-ref-set_module |
| set_order/3 (sets): | | lib-sets |
| set_output/1 (built-in): | | ref-iou-sfh-opn |
| set_output/1 (built-in): | | ref-iou-sfh-opn |
| set_output/1 (built-in, ref page): | | mpg-ref-set_output |
| set_prolog_flag/2 (built-in, ref page): | | mpg-ref-set_prolog_flag |
| set_stream_position/2 (built-in): | | ref-iou-raf |
| set_stream_position/2 (built-in, ref page): | | mpg-ref-set_stream_position |
| shorter_list/2 (lists): | | lib-lists |
| show/1 (debugger condition): | | Breakpoint Actions |
| show/1 (debugger condition): | | Port Tests |
| show/1 (debugger condition): | | Action Conditions |
| shutdown/[0,1] (prologbeans): | | PB Prolog Server Interface |
| shutdown_server/0 (linda_client): | | lib-linda-client |
| SICStus Prolog IDE (SPIDER): | | SPIDER |
| sicstus(1) (command line tool): | | too-sicstus |
| sicstus-bindings-on (emacs command): | | Usage |
| sicstus-bindings-print-depth (emacs command): | | Usage |
| sicstus-coverage-on (emacs command): | | Usage |
| side effect (definition): | | Glossary |
| side effects, in repeat loops: | | mpg-ref-repeat |
| sigaction: | | Signal Handling |
| SIGBREAK: | | Signal Handling |
| SIGCHLD: | | Signal Handling |
| SIGCLD: | | Signal Handling |
| SIGINT: | | Signal Handling |
| sign /1, (evaluable): | | ref-ari-aex |
| signal: | | Signal Handling |
| signal handling: | | Calling Prolog Asynchronously |
| Signal handling, C functions for: | | cpg-top-sig |
| SIGUSR1: | | Signal Handling |
| SIGUSR2: | | Signal Handling |
| SIGVTALRM: | | Signal Handling |
| SIG_DFL (C macro): | | cpg-ref-SP_signal |
| SIG_ERR (C macro): | | cpg-ref-SP_signal |
| SIG_IGN (C macro): | | cpg-ref-SP_signal |
| silent/0 (debugger show control): | | Action Variables |
| simple term (definition): | | Glossary |
| simple/1 (built-in, ref page): | | mpg-ref-simple |
| SimpleCallSpec: | | Terminology |
| simple_pred_spec (argument type): | | mpg-ref-aty-ety |
| sin /1, (evaluable): | | ref-ari-aex |
| singletons/1 (read_term/[2,3] option): | | mpg-ref-read_term |
| singleton_queue/2 (queues): | | lib-queues |
| single_var_warnings (prolog flag): | | ref-lod-lod |
| single_var_warnings (prolog flag): | | ref-lps-flg |
| single_var_warnings (prolog flag): | | Runtime Systems |
| sinh /1, (evaluable): | | ref-ari-aex |
| site, coverage: | | Coverage Analysis |
| size_bound/2 (terms): | | lib-terms |
| skeletal goal (definition): | | Glossary |
| skewness/2 (statistics): | | lib-statistics |
| skip (CHR debug command): | | CHR Tracing |
| skip (debugger command): | | Debug Commands |
| skip/1 (debugger mode control): | | Action Variables |
| skip_byte/[1,2] (built-in): | | ref-iou-cin-ski |
| skip_byte/[1,2] (built-in, ref page): | | mpg-ref-skip_byte |
| skip_char/[1,2] (built-in): | | ref-iou-cin-ski |
| skip_char/[1,2] (built-in, ref page): | | mpg-ref-skip_char |
| skip_code/[1,2] (built-in): | | ref-iou-cin-ski |
| skip_code/[1,2] (built-in, ref page): | | mpg-ref-skip_code |
| skip_line/[0,1] (built-in): | | ref-iou-cin-ski |
| skip_line/[0,1] (built-in, ref page): | | mpg-ref-skip_line |
| sleep/1 (system): | | lib-system |
| small integer (definition): | | Glossary |
| smallest (labeling/2 option): | | Enumeration Predicates |
| smt/1 (clpfd): | | Arithmetic-Logical Constraints |
| socket address: | | lib-sockets |
| sockets: | | lib-sockets |
| socket_client_open/3 (sockets): | | lib-sockets |
| socket_select/7 (sockets): | | lib-sockets |
| socket_server_accept/4 (sockets): | | lib-sockets |
| socket_server_close/1 (sockets): | | lib-sockets |
| socket_server_open/[2,3] (sockets): | | lib-sockets |
| soft cut: | | ref-sem-ctr-ite |
| solutions (zinc option value): | | MiniZinc Exported Predicates |
| solutions/1 (absolute_file_name/3 option): | | mpg-ref-absolute_file_name |
| solutions/1 (zinc option): | | FlatZinc Exported Predicates |
| solutions/1 (zinc option): | | MiniZinc Exported Predicates |
| solve/2 (clpfd): | | Enumeration Predicates |
| solvetime (zinc option value): | | MiniZinc Exported Predicates |
| some/[2,3,4] (lists): | | lib-lists |
| somebag/2 (bags): | | lib-bags |
| somechk/[2,3,4] (lists): | | lib-lists |
| somechkbag/2 (bags): | | lib-bags |
| somechk_queue/[2,3] (queues): | | lib-queues |
| some_queue/[2,3] (queues): | | lib-queues |
| sort/2 (built-in): | | ref-lte-cte-sor |
| sort/2 (built-in, ref page): | | mpg-ref-sort |
| sorting/3 (clpfd): | | Arithmetic-Logical Constraints |
| source (absolute_file_name/3 file type): | | mpg-ref-absolute_file_name |
| source (load context key): | | ref-lps-lco |
| source (Tcl command): | | Commands |
| source code (definition): | | Glossary |
| source information: | | Usage |
| source information: | | ref-lps-flg |
| source module: | | ref-mod-som |
| source module: | | ref-mod-mne |
| source module (definition): | | Glossary |
| source/1 (fd_global/[3,4] option): | | The Global Constraint Programming Interface |
| source_file/[1,2] (built-in): | | ref-lps-apf |
| source_file/[1,2] (built-in, ref page): | | mpg-ref-source_file |
| source_info (prolog flag): | | Usage |
| source_info (prolog flag): | | ref-lps-flg |
| source_info (prolog flag): | | Breakpoint Tests |
| source_info (prolog flag): | | Debugging Runtime Systems |
| space reclamation: | | ref-mgc-ove-rsp |
| space, program: | | ref-mgc-ove |
| space, reclamation: | | mpg-ref-abolish |
| spdet(1) (command line tool): | | too-spdet |
| spdet, the determinacy checker: | | The Determinacy Checker |
| spec, mode: | | Mode Spec |
| specific breakpoint: | | Specific and Generic Breakpoints |
| specification, breakpoint: | | Creating Breakpoints |
| specification, directory: | | ref-fdi-fsp |
| specification, file: | | ref-fdi-fsp |
| specification, file: | | ref-fdi-syn |
| specification, file (definition): | | Glossary |
| specification, predicate (definition): | | Glossary |
| specifying streams: | | ref-iou-str |
| specifying streams, efficiency and: | | ref-iou-str-not |
| speclist/1 (lmdb property): | | LMDB The Predicates |
| spfz(1) (command line tool): | | too-spfz |
| SPIDER: | | SPIDER |
| spld: | | The Application Builder |
| spld(1) (command line tool): | | too-spld |
| splfr: | | The Foreign Resource Linker |
| splfr(1) (command line tool): | | too-splfr |
| split (Tcl command): | | Commands |
| splm(1) (command line tool): | | too-splm |
| spxref: | | Xref Introduction |
| spxref(1) (command line tool): | | too-spxref |
| spy this (debugger command): | | Debug Commands |
| spy this conditionally (debugger command): | | Debug Commands |
| spy/[1,2] (built-in): | | Plain Spypoint |
| spy/[1,2] (built-in): | | Breakpoint Predicates |
| spy/[1,2] (built-in, ref page): | | mpg-ref-spy |
| spypoint: | | Debug Intro |
| spypoint (definition): | | Glossary |
| spypoint, conditional: | | Creating Breakpoints |
| spypoint, plain: | | Plain Spypoint |
| spypoint, plain: | | Creating Breakpoints |
| SP_ALLOW_CHDIR (system property): | | System Properties and Environment Variables |
| SP_ALLOW_DEVSYS (system property): | | Customizing the Debugged Runtime System |
| SP_APP_DIR (system property): | | System Properties and Environment Variables |
| SP_APP_PATH (system property): | | System Properties and Environment Variables |
| SP_atom (C type): | | Glossary |
| SP_atom (C type): | | Glossary |
| SP_atom (C type): | | Atoms in C |
| SP_atom (C type): | | cpg-ref-SP_atom_from_string |
| SP_atom (C type): | | cpg-ref-SP_atom_length |
| SP_atom (C type): | | cpg-ref-SP_cons_functor |
| SP_atom (C type): | | cpg-ref-SP_cons_functor_array |
| SP_atom (C type): | | cpg-ref-SP_get_atom |
| SP_atom (C type): | | cpg-ref-SP_get_functor |
| SP_atom (C type): | | cpg-ref-SP_pred |
| SP_atom (C type): | | cpg-ref-SP_put_atom |
| SP_atom (C type): | | cpg-ref-SP_put_functor |
| SP_atom (C type): | | cpg-ref-SP_register_atom |
| SP_atom (C type): | | cpg-ref-SP_string_from_atom |
| SP_atom (C type): | | cpg-ref-SP_unregister_atom |
| SP_atom (definition): | | Glossary |
| SP_atom_from_string() (C function): | | Atoms in C |
| SP_atom_from_string() (C function): | | cpg-ref-SP_atom_from_string |
| SP_atom_length() (C function): | | Atoms in C |
| SP_atom_length() (C function): | | cpg-ref-SP_atom_length |
| SP_ATTACH_SPIDER (system property): | | Customizing the Debugged Runtime System |
| SP_calloc() (C function): | | OS Memory Management |
| SP_calloc() (C function): | | cpg-ref-SP_calloc |
| SP_close_query() (C function): | | cpg-ref-SP_close_query |
| SP_compare() (C function): | | Unifying and Comparing Terms |
| SP_compare() (C function): | | cpg-ref-SP_compare |
| SP_cons_functor() (C function): | | Creating Prolog Terms |
| SP_cons_functor() (C function): | | cpg-ref-SP_cons_functor |
| SP_cons_functor_array() (C function): | | cpg-ref-SP_cons_functor_array |
| SP_cons_list() (C function): | | Creating Prolog Terms |
| SP_cons_list() (C function): | | cpg-ref-SP_cons_list |
| SP_create_stream() (C function): | | cpg-ref-SP_create_stream |
| SP_curin (C stream): | | Prolog Streams |
| SP_curout (C stream): | | Prolog Streams |
| SP_cut_query() (C function): | | Finding Multiple Solutions of a Call |
| SP_cut_query() (C function): | | cpg-ref-SP_cut_query |
| SP_define_c_predicate() (C function): | | cpg-ref-SP_define_c_predicate |
| SP_deinitialize() (C function): | | Initializing the Prolog Engine |
| SP_deinitialize() (C function): | | cpg-ref-SP_deinitialize |
| SP_DEVSYS_NO_TRACE (system property): | | Customizing the Debugged Runtime System |
| SP_errno (C macro): | | CPL Notes |
| SP_errno (C macro): | | cpg-rve |
| SP_ERROR (C macro): | | CPL Notes |
| SP_ERROR (C macro): | | cpg-rve |
| SP_error_message() (C function): | | CPL Notes |
| SP_error_message() (C function): | | cpg-rve |
| SP_error_message() (C function): | | cpg-ref-SP_error_message |
| SP_event() (C function): | | Calling Prolog Asynchronously |
| SP_event() (C function): | | cpg-ref-SP_event |
| SP_exception_term() (C function): | | Exception Handling in C |
| SP_exception_term() (C function): | | cpg-ref-SP_exception_term |
| SP_expand_file_name() (C function): | | cpg-ref-SP_expand_file_name |
| SP_fail() (C function): | | Exception Handling in C |
| SP_fail() (C function): | | cpg-ref-SP_fail |
| SP_FAILURE (C macro): | | CPL Notes |
| SP_FAILURE (C macro): | | cpg-rve |
| SP_fclose() (C function): | | Prolog Streams |
| SP_fclose() (C function): | | cpg-ref-SP_fclose |
| SP_flush_output() (C function): | | Prolog Streams |
| SP_flush_output() (C function): | | cpg-ref-SP_flush_output |
| SP_fopen() (C function): | | cpg-ref-SP_fopen |
| SP_foreign_stash() (C macro): | | OS Threads |
| SP_foreign_stash() (C macro): | | cpg-ref-SP_foreign_stash |
| SP_fprintf() (C function): | | Prolog Streams |
| SP_fprintf() (C function): | | cpg-ref-SP_fprintf |
| SP_free() (C function): | | OS Memory Management |
| SP_free() (C function): | | cpg-ref-SP_free |
| SP_getenv() (C function): | | cpg-ref-SP_getenv |
| SP_get_address() (C function): | | Accessing Prolog Terms |
| SP_get_address() (C function): | | cpg-ref-SP_get_address |
| SP_get_arg() (C function): | | Accessing Prolog Terms |
| SP_get_arg() (C function): | | cpg-ref-SP_get_arg |
| SP_get_atom() (C function): | | Accessing Prolog Terms |
| SP_get_atom() (C function): | | cpg-ref-SP_get_atom |
| SP_get_byte() (C function): | | cpg-ref-SP_get_byte |
| SP_get_byte() (C macro): | | Prolog Streams |
| SP_get_code() (C function): | | cpg-ref-SP_get_code |
| SP_get_code() (C macro): | | Prolog Streams |
| SP_get_current_dir() (C function): | | OS File System |
| SP_get_current_dir() (C function): | | cpg-ref-SP_get_current_dir |
| SP_get_dispatch() (C function): | | cpg-ref-SP_get_dispatch |
| SP_get_float() (C function): | | Accessing Prolog Terms |
| SP_get_float() (C function): | | cpg-ref-SP_get_float |
| SP_get_functor() (C function): | | Accessing Prolog Terms |
| SP_get_functor() (C function): | | cpg-ref-SP_get_functor |
| SP_get_integer() (C function): | | Accessing Prolog Terms |
| SP_get_integer() (C function): | | cpg-ref-SP_get_integer |
| SP_get_integer_bytes() (C function): | | Accessing Prolog Terms |
| SP_get_integer_bytes() (C function): | | cpg-ref-SP_get_integer_bytes |
| SP_get_list() (C function): | | Accessing Prolog Terms |
| SP_get_list() (C function): | | cpg-ref-SP_get_list |
| SP_get_list_codes() (C function): | | Accessing Prolog Terms |
| SP_get_list_codes() (C function): | | cpg-ref-SP_get_list_codes |
| SP_get_list_n_bytes() (C function): | | Accessing Prolog Terms |
| SP_get_list_n_bytes() (C function): | | cpg-ref-SP_get_list_n_bytes |
| SP_get_list_n_codes() (C function): | | Accessing Prolog Terms |
| SP_get_list_n_codes() (C function): | | cpg-ref-SP_get_list_n_codes |
| SP_get_number_codes() (C function): | | Accessing Prolog Terms |
| SP_get_number_codes() (C function): | | cpg-ref-SP_get_number_codes |
| SP_get_stream_counts() (C function): | | cpg-ref-SP_get_stream_counts |
| SP_get_stream_user_data() (C function): | | cpg-ref-SP_get_stream_user_data |
| SP_get_string() (C function): | | Accessing Prolog Terms |
| SP_get_string() (C function): | | cpg-ref-SP_get_string |
| SP_initialize() (C function): | | Initializing the Prolog Engine |
| SP_initialize() (C macro): | | cpg-ref-SP_initialize |
| SP_integer (C type): | | Glossary |
| SP_integer (definition): | | Glossary |
| SP_is_atom() (C function): | | Testing Prolog Terms |
| SP_is_atom() (C function): | | cpg-ref-SP_is_atom |
| SP_is_atomic() (C function): | | Testing Prolog Terms |
| SP_is_atomic() (C function): | | cpg-ref-SP_is_atomic |
| SP_is_compound() (C function): | | Testing Prolog Terms |
| SP_is_compound() (C function): | | cpg-ref-SP_is_compound |
| SP_is_float() (C function): | | Testing Prolog Terms |
| SP_is_float() (C function): | | cpg-ref-SP_is_float |
| SP_is_integer() (C function): | | Testing Prolog Terms |
| SP_is_integer() (C function): | | cpg-ref-SP_is_integer |
| SP_is_list() (C function): | | Testing Prolog Terms |
| SP_is_list() (C function): | | cpg-ref-SP_is_list |
| SP_is_number() (C function): | | Testing Prolog Terms |
| SP_is_number() (C function): | | cpg-ref-SP_is_number |
| SP_is_variable() (C function): | | Testing Prolog Terms |
| SP_is_variable() (C function): | | cpg-ref-SP_is_variable |
| SP_JIT (system property): | | System Properties and Environment Variables |
| SP_JIT_CLAUSE_LIMIT (system property): | | System Properties and Environment Variables |
| SP_JIT_COUNTER_LIMIT (system property): | | System Properties and Environment Variables |
| SP_LIBRARY_DIR (system property): | | System Properties and Environment Variables |
| SP_LICENSE_CODE (system property): | | Locating the License Information |
| SP_LICENSE_CODE (system property): | | Locating the License Information |
| SP_LICENSE_CODE (system property): | | Customizing the Debugged Runtime System |
| SP_LICENSE_EXPIRATION (system property): | | Locating the License Information |
| SP_LICENSE_EXPIRATION (system property): | | Locating the License Information |
| SP_LICENSE_EXPIRATION (system property): | | Customizing the Debugged Runtime System |
| SP_LICENSE_FILE (system property): | | Locating the License Information |
| SP_LICENSE_FILE (system property): | | Customizing the Debugged Runtime System |
| SP_LICENSE_SITE (system property): | | Locating the License Information |
| SP_LICENSE_SITE (system property): | | Locating the License Information |
| SP_LICENSE_SITE (system property): | | Customizing the Debugged Runtime System |
| SP_load() (C function): | | Loading Prolog Code |
| SP_load() (C function): | | cpg-ref-SP_load |
| SP_load_sicstus_run_time() (C function): | | cpg-ref-SP_load_sicstus_run_time |
| SP_malloc() (C function): | | OS Memory Management |
| SP_malloc() (C function): | | cpg-ref-SP_malloc |
| SP_MUTEX_INITIALIZER (C macro): | | OS Threads |
| SP_mutex_lock() (C function): | | OS Threads |
| SP_mutex_lock() (C function): | | cpg-ref-SP_mutex_lock |
| SP_mutex_unlock() (C function): | | OS Threads |
| SP_mutex_unlock() (C function): | | OS Threads |
| SP_mutex_unlock() (C function): | | cpg-ref-SP_mutex_unlock |
| SP_new_term_ref() (C function): | | Creating and Manipulating SP_term_refs |
| SP_new_term_ref() (C function): | | cpg-ref-SP_new_term_ref |
| SP_next_solution() (C function): | | Finding Multiple Solutions of a Call |
| SP_next_solution() (C function): | | cpg-ref-SP_next_solution |
| SP_next_stream() (C function): | | cpg-ref-SP_next_stream |
| SP_on_fault() (C macro): | | Exception Handling in C |
| SP_open_query() (C function): | | Finding Multiple Solutions of a Call |
| SP_open_query() (C function): | | cpg-ref-SP_open_query |
| SP_PATH (system property): | | System Properties and Environment Variables |
| SP_PATH (system property): | | CPL Notes |
| SP_pred() (C function): | | Calling Prolog from C |
| SP_pred() (C function): | | cpg-ref-SP_pred |
| SP_predicate() (C function): | | Calling Prolog from C |
| SP_predicate() (C function): | | cpg-ref-SP_predicate |
| SP_printf() (C function): | | Prolog Streams |
| SP_printf() (C function): | | cpg-ref-SP_printf |
| SP_put_address() (C function): | | Creating Prolog Terms |
| SP_put_address() (C function): | | cpg-ref-SP_put_address |
| SP_put_atom() (C function): | | Creating Prolog Terms |
| SP_put_atom() (C function): | | cpg-ref-SP_put_atom |
| SP_put_byte() (C function): | | cpg-ref-SP_put_byte |
| SP_put_byte() (C macro): | | Prolog Streams |
| SP_put_bytes() (C function): | | Prolog Streams |
| SP_put_bytes() (C function): | | cpg-ref-SP_put_bytes |
| SP_put_code() (C function): | | cpg-ref-SP_put_code |
| SP_put_code() (C macro): | | Prolog Streams |
| SP_put_codes() (C function): | | Prolog Streams |
| SP_put_codes() (C function): | | cpg-ref-SP_put_codes |
| SP_put_encoded_string() (C function): | | Prolog Streams |
| SP_put_encoded_string() (C function): | | cpg-ref-SP_put_encoded_string |
| SP_put_float() (C function): | | Creating Prolog Terms |
| SP_put_float() (C function): | | cpg-ref-SP_put_float |
| SP_put_functor() (C function): | | Creating Prolog Terms |
| SP_put_functor() (C function): | | cpg-ref-SP_put_functor |
| SP_put_integer() (C function): | | Creating Prolog Terms |
| SP_put_integer() (C function): | | cpg-ref-SP_put_integer |
| SP_put_integer_bytes() (C function): | | Creating Prolog Terms |
| SP_put_integer_bytes() (C function): | | cpg-ref-SP_put_integer_bytes |
| SP_put_list() (C function): | | Creating Prolog Terms |
| SP_put_list() (C function): | | cpg-ref-SP_put_list |
| SP_put_list_codes() (C function): | | Creating Prolog Terms |
| SP_put_list_codes() (C function): | | cpg-ref-SP_put_list_codes |
| SP_put_list_n_bytes() (C function): | | Creating Prolog Terms |
| SP_put_list_n_bytes() (C function): | | cpg-ref-SP_put_list_n_bytes |
| SP_put_list_n_codes() (C function): | | Creating Prolog Terms |
| SP_put_list_n_codes() (C function): | | cpg-ref-SP_put_list_n_codes |
| SP_put_number_codes() (C function): | | Creating Prolog Terms |
| SP_put_number_codes() (C function): | | cpg-ref-SP_put_number_codes |
| SP_put_string() (C function): | | Creating Prolog Terms |
| SP_put_string() (C function): | | cpg-ref-SP_put_string |
| SP_put_term() (C function): | | Creating and Manipulating SP_term_refs |
| SP_put_term() (C function): | | cpg-ref-SP_put_term |
| SP_put_variable() (C function): | | Creating Prolog Terms |
| SP_put_variable() (C function): | | cpg-ref-SP_put_variable |
| SP_qid (C type): | | Finding Multiple Solutions of a Call |
| SP_qid (C type): | | cpg-ref-SP_close_query |
| SP_qid (C type): | | cpg-ref-SP_cut_query |
| SP_qid (C type): | | cpg-ref-SP_next_solution |
| SP_qid (C type): | | cpg-ref-SP_open_query |
| SP_query() (C function): | | Finding One Solution of a Call |
| SP_query() (C function): | | cpg-ref-SP_query |
| SP_query_cut_fail() (C function): | | Finding One Solution of a Call |
| SP_query_cut_fail() (C function): | | cpg-ref-SP_query_cut_fail |
| SP_raise_exception() (C function): | | Exception Handling in C |
| SP_raise_exception() (C function): | | cpg-ref-SP_raise_exception |
| SP_raise_fault() (C function): | | Exception Handling in C |
| SP_read_from_string() (C function): | | Creating Prolog Terms |
| SP_read_from_string() (C function): | | cpg-ref-SP_read_from_string |
| SP_realloc() (C function): | | OS Memory Management |
| SP_realloc() (C function): | | cpg-ref-SP_realloc |
| SP_register_atom() (C function): | | Atoms in C |
| SP_register_atom() (C function): | | cpg-ref-SP_register_atom |
| SP_restore() (C function): | | Loading Prolog Code |
| SP_restore() (C function): | | cpg-ref-SP_restore |
| SP_RT_DIR (system property): | | System Properties and Environment Variables |
| SP_RT_PATH (system property): | | System Properties and Environment Variables |
| SP_set_argv() (C function): | | cpg-ref-SP_set_argv |
| SP_set_current_dir() (C function): | | OS File System |
| SP_set_current_dir() (C function): | | cpg-ref-SP_set_current_dir |
| SP_set_user_stream_hook() (C function): | | Hookable Standard Streams |
| SP_set_user_stream_hook() (C function): | | cpg-ref-SP_set_user_stream_hook |
| SP_set_user_stream_post_hook() (C function): | | Hookable Standard Streams |
| SP_set_user_stream_post_hook() (C function): | | cpg-ref-SP_set_user_stream_post_hook |
| SP_signal() (C function): | | Signal Handling |
| SP_signal() (C function): | | cpg-ref-SP_signal |
| SP_SIG_DFL (C macro): | | cpg-ref-SP_signal |
| SP_SIG_ERR (C macro): | | cpg-ref-SP_signal |
| SP_SIG_IGN (C macro): | | cpg-ref-SP_signal |
| SP_SPTI_PATH (system property): | | System Properties and Environment Variables |
| SP_STARTUP_DIR (system property): | | System Properties and Environment Variables |
| SP_stderr (C stream): | | Prolog Streams |
| SP_stdin (C stream): | | Prolog Streams |
| SP_stdout (C stream): | | Prolog Streams |
| SP_strdup() (C function): | | OS Memory Management |
| SP_strdup() (C function): | | cpg-ref-SP_strdup |
| SP_stream (C type): | | Prolog Streams |
| SP_STREAMHOOK_STDERR (stream hook): | | Writing User-stream Hooks |
| SP_STREAMHOOK_STDIN (stream hook): | | Writing User-stream Hooks |
| SP_STREAMHOOK_STDOUT (stream hook): | | Writing User-stream Hooks |
| SP_string_from_atom() (C function): | | Atoms in C |
| SP_string_from_atom() (C function): | | cpg-ref-SP_string_from_atom |
| SP_SUCCESS (C macro): | | CPL Notes |
| SP_SUCCESS (C macro): | | cpg-rve |
| SP_TEMP_DIR (system property): | | System Properties and Environment Variables |
| SP_term_ref: | | Mixing C and Prolog |
| SP_term_ref (C type): | | Mixing C and Prolog |
| SP_term_ref (C type): | | Creating and Manipulating SP_term_refs |
| SP_term_ref (definition): | | Glossary |
| SP_term_type() (C function): | | Testing Prolog Terms |
| SP_term_type() (C function): | | cpg-ref-SP_term_type |
| SP_TYPE_ATOM (C macro): | | cpg-ref-SP_term_type |
| SP_TYPE_COMPOUND (C macro): | | cpg-ref-SP_term_type |
| SP_TYPE_ERROR (C macro): | | cpg-ref-SP_term_type |
| SP_TYPE_FLOAT (C macro): | | cpg-ref-SP_term_type |
| SP_TYPE_INTEGER (C macro): | | cpg-ref-SP_term_type |
| SP_TYPE_VARIABLE (C macro): | | cpg-ref-SP_term_type |
| SP_ULIMIT_DATA_SEGMENT_SIZE (system property): | | System Properties and Environment Variables |
| SP_unget_byte() (C function): | | cpg-ref-SP_unget_byte |
| SP_unget_code() (C function): | | cpg-ref-SP_unget_code |
| SP_unify() (C function): | | Unifying and Comparing Terms |
| SP_unify() (C function): | | cpg-ref-SP_unify |
| SP_unregister_atom() (C function): | | Atoms in C |
| SP_unregister_atom() (C function): | | cpg-ref-SP_unregister_atom |
| SP_USE_DEVSYS (system property): | | Customizing the Debugged Runtime System |
| SP_USE_MALLOC (system property): | | System Properties and Environment Variables |
| SP_WHEN_EXIT (foreign resource context): | | Init and Deinit Functions |
| SP_WHEN_EXPLICIT (foreign resource context): | | Init and Deinit Functions |
| SP_WHEN_EXPLICIT (foreign resource context): | | Init and Deinit Functions |
| SP_WHEN_RESTORE (foreign resource context): | | Init and Deinit Functions |
| sqrt /1, square root (evaluable): | | ref-ari-aex |
| ss_choice (statistics key): | | ref-mgc-ove-sta |
| ss_global (statistics key): | | ref-mgc-ove-sta |
| ss_local (statistics key): | | ref-mgc-ove-sta |
| ss_time (statistics key): | | ref-mgc-ove-sta |
| stack, choice: | | ref-mgc-ove |
| stack, global: | | ref-mgc-ove |
| stack, local: | | ref-mgc-ove |
| stack, trail: | | ref-mgc-ove |
| stack_shifts (statistics key): | | ref-mgc-ove-sta |
| stand-alone executable: | | Stand-Alone Executables |
| stand-alone executable (definition): | | Glossary |
| standard streams: | | ref-iou-str |
| standard, order on terms: | | ref-lte-cte-sot |
| start/[0,1] (prologbeans): | | PB Prolog Server Interface |
| startServer on SICStus: | | Java Threads |
| state, program: | | Saving |
| state, saved (definition): | | Glossary |
| state/2 (automaton/9 option): | | Sequence Constraints |
| static predicate (definition): | | Glossary |
| static procedures: | | ref-mdb-dsp |
| static resource: | | Foreign Resources |
| statistics, displaying: | | ref-mgc-ove-sta |
| statistics, memory: | | ref-mgc-ove-sta |
| statistics/1 (zinc option): | | FlatZinc Exported Predicates |
| statistics/1 (zinc option): | | MiniZinc Exported Predicates |
| statistics/[0,2] (built-in): | | ref-mgc-ove-sta |
| statistics/[0,2] (built-in): | | ref-mgc-gcp |
| statistics/[0,2] (built-in, ref page): | | mpg-ref-statistics |
| steadfast predicate (definition): | | Glossary |
| step (labeling/2 option): | | Enumeration Predicates |
| stopServer on SICStus: | | Java Threads |
| store, consistent: | | CLPFD Interface |
| store, contradictory: | | CLPFD Interface |
| store_slot/2 (objects): | | obj-exp-store_slot |
| stream (definition): | | Glossary |
| stream (load context key): | | ref-lps-lco |
| stream alias: | | ref-iou-sfh-sob |
| stream alias (definition): | | Glossary |
| stream errors: | | ref-iou-sfh-est |
| stream exceptions: | | ref-iou-sfh-est |
| stream object: | | ref-iou-sfh-sob |
| stream object (definition): | | Glossary |
| stream position: | | ref-iou-sos |
| stream position (definition): | | Glossary |
| stream position information for terminal I/O: | | ref-iou-sos-spt |
| stream position object: | | ref-iou-raf |
| stream property: | | mpg-ref-stream_property |
| stream property (definition): | | Glossary |
| stream, closing: | | ref-iou-sfh-cst |
| stream, current: | | ref-iou-sfh-bos |
| stream, end of: | | mpg-ref-at_end_of_stream |
| stream, position objects: | | mpg-ref-set_stream_position |
| stream, position objects: | | mpg-ref-stream_position |
| streams: | | ref-iou-sfh |
| streams, current input: | | ref-iou-sfh-opn |
| streams, current input: | | ref-iou-sfh-cis |
| streams, current input: | | ref-iou-sfh-cos |
| streams, current input and output: | | ref-iou-bas |
| streams, current output: | | ref-iou-sfh-opn |
| streams, current output: | | ref-iou-sfh-cis |
| streams, current output: | | ref-iou-sfh-cos |
| streams, null: | | ref-iou-sfh-opn |
| streams, opening: | | ref-iou-sfh-opn |
| streams, random access to: | | ref-iou-raf |
| streams, specifying: | | ref-iou-str |
| streams, standard: | | ref-iou-str |
| stream_code/2 (built-in): | | ref-iou-sfh-sob |
| stream_code/2 (built-in): | | Prolog Streams |
| stream_code/2 (built-in, ref page): | | mpg-ref-stream_code |
| stream_object (argument type): | | mpg-ref-aty-ety |
| stream_position/2 (built-in): | | ref-iou-raf |
| stream_position/2 (built-in, ref page): | | mpg-ref-stream_position |
| stream_position_data/3 (built-in, ref page): | | mpg-ref-stream_position_data |
| stream_property/2 (built-in): | | ref-iou-sfh-bos |
| stream_property/2 (built-in, ref page): | | mpg-ref-stream_property |
| stretchmaxlen/2 (automaton/9 option): | | Sequence Constraints |
| stretchminlen/2 (automaton/9 option): | | Sequence Constraints |
| stretchocc/2 (automaton/9 option): | | Sequence Constraints |
| stretchoccmod/3 (automaton/9 option): | | Sequence Constraints |
| strict/1 (diffn/2 option): | | Placement Constraints |
| string (definition): | | Glossary |
| string (definition): | | ref-syn-cpt-sli |
| string first (Tcl command): | | Commands |
| string index (Tcl command): | | Commands |
| string last (Tcl command): | | Commands |
| string length (Tcl command): | | Commands |
| string match (Tcl command): | | Commands |
| string match (Tcl command): | | Commands |
| string range (Tcl command): | | Commands |
| string string (Tcl command): | | Commands |
| string tolower (Tcl command): | | Commands |
| string toupper (Tcl command): | | Commands |
| string trim (Tcl command): | | Commands |
| string trimright (Tcl command): | | Commands |
| string, encoded: | | CPL Notes |
| string, encoded (definition): | | Glossary |
| strings, lists of character codes: | | ref-syn-cpt-sli |
| strings, lists of character codes: | | ref-syn-cpt-sli |
| structs (library package): | | lib-structs |
| structure, control: | | ref-sem-ctr |
| structure, control (definition): | | Glossary |
| subcircuit/1 (all_different/2 option): | | Arithmetic-Logical Constraints |
| subcircuit/1 (all_distinct/2 option): | | Arithmetic-Logical Constraints |
| subcircuit/1 (assignment/3 option): | | Arithmetic-Logical Constraints |
| subcircuit/[1,2] (clpfd): | | Graph Constraints |
| sublist/[3,4,5] (lists): | | lib-lists |
| subseq/3 (lists): | | lib-lists |
| subseq0/2 (lists): | | lib-lists |
| subseq1/2 (lists): | | lib-lists |
| subset/2 (sets): | | lib-sets |
| subsumes/2 (terms): | | lib-terms |
| subsumeschk/2 (terms): | | lib-terms |
| subsumes_term/2 (built-in): | | ref-lte-met-usu |
| subsumes_term/2 (built-in, ref page): | | mpg-ref-subsumes_term |
| subterm selector: | | Queries |
| subterm selector: | | Breakpoint Tests |
| subterm selector (definition): | | Glossary |
| subtract/3 (sets): | | lib-sets |
| sub_atom/5 (built-in): | | ref-lte-atm |
| sub_atom/5 (built-in, ref page): | | mpg-ref-sub_atom |
| sub_term/2 (terms): | | lib-terms |
| success (labeling/2 time_out/2 option value): | | Enumeration Predicates |
| suffix/2 (lists): | | lib-lists |
| suffix_length/3 (lists): | | lib-lists |
| sum/3 (clpfd): | | Arithmetic Constraints |
| sumlist/2 (lists): | | lib-lists |
| sup, plus infinity: | | CLPFD Interface |
| sup/[2,4] (clpqr): | | CLPQR Solver Predicates |
| suppress (redefine_warnings flag value): | | ref-lps-flg |
| SU_initialize() (C function): | | cpg-ref-SU_initialize |
| SU_initialize() (C function): | | too-spld |
| switch (Tcl command): | | Commands |
| symdiff/3 (sets): | | lib-sets |
| symmetric_all_different/1 (clpfd): | | Arithmetic-Logical Constraints |
| symmetric_all_distinct/1 (clpfd): | | Arithmetic-Logical Constraints |
| symmetric_closure/2 (ugraphs): | | lib-ugraphs |
| symmetric_closure/2 (wgraphs): | | lib-wgraphs |
| synchronization: | | lib-linda |
| synchronization/1 (disjoint2/2 option): | | Placement Constraints |
| synopsis, reference page field: | | mpg-ref-ove |
| syntactic rewriting: | | ref-fdi-syn |
| syntax (definition): | | Glossary |
| syntax error: | | Syntax Errors |
| syntax errors: | | ref-ere-err-syn |
| syntax restrictions on operators: | | ref-syn-ops-res |
| syntax, formal: | | ref-syn-syn |
| syntax, of atoms: | | ref-syn-trm-ato |
| syntax, of compound terms: | | ref-syn-cpt |
| syntax, of floats: | | ref-syn-trm-flo |
| syntax, of integers: | | ref-syn-trm-int |
| syntax, of lists: | | ref-syn-cpt-lis |
| syntax, of sentences as terms: | | ref-syn-syn-sen |
| syntax, of terms as tokens: | | ref-syn-syn-trm |
| syntax, of tokens as character strings: | | ref-syn-syn-tok |
| syntax, of variables: | | ref-syn-trm-var |
| syntax, rule notation: | | ref-syn-syn-not |
| syntax_error/[1,5] (error class): | | ref-ere-err |
| syntax_errors (prolog flag): | | Syntax Errors |
| syntax_errors (prolog flag): | | ref-lps-flg |
| syntax_errors (prolog flag): | | ref-ere-err-syn |
| syntax_errors (prolog flag): | | mpg-ref-read |
| syntax_errors (prolog flag): | | mpg-ref-read_term |
| syntax_errors/1 (read_term/[2,3] option): | | ref-ere-err-syn |
| syntax_errors/1 (read_term/[2,3] option): | | mpg-ref-read_term |
| system errors: | | ref-ere-err-sys |
| system properties: | | System Properties and Environment Variables |
| system property (definition): | | Glossary |
| system, development: | | Development and Runtime Systems |
| system, development (definition): | | Glossary |
| system, extended runtime (definition): | | Glossary |
| system, runtime: | | Development and Runtime Systems |
| system, runtime: | | Stand-Alone Executables |
| system, runtime (definition): | | Glossary |
| system_error/[0,1] (error class): | | ref-ere-err |
| system_type (prolog flag): | | ref-lps-flg |
|
| T | | |
|---|
| table/[2,3] (clpfd): | | Extensional Constraints |
| tables, data: | | Data Tables |
| tail/2 (lists): | | lib-lists |
| tan /1, (evaluable): | | ref-ari-aex |
| tanh /1, (evaluable): | | ref-ari-aex |
| task_intervals/1 (cumulatives/3 option): | | Scheduling Constraints |
| task_intervals/1 (geost/[2,3,4] option): | | Placement Constraints |
| taut/2 (clpb): | | CLPB Interface |
| tcl_delete/1 (tcltk): | | Basic Functions |
| tcl_delete/1 (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters |
| tcl_eval/3 (tcltk): | | Evaluation Functions |
| tcl_eval/3 (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters |
| tcl_event/3 (tcltk): | | Event Functions |
| tcl_event/3 (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters |
| tcl_new/1 (tcltk): | | Basic Functions |
| tcl_new/1 (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters |
| tell/1 (built-in): | | ref-iou-sfh-opn |
| tell/1 (built-in, ref page): | | mpg-ref-tell |
| telling/1 (built-in): | | ref-iou-sfh-cos |
| telling/1 (built-in, ref page): | | mpg-ref-telling |
| term (argument type): | | mpg-ref-aty-ety |
| term (definition): | | Glossary |
| term comparison, predicates for: | | ref-lte-sum |
| term comparison, predicates for: | | mpg-top-tcm |
| term conversions: | | Support Functions |
| term handling, predicates for: | | ref-lte-sum |
| term handling, predicates for: | | mpg-top-tha |
| term I/O, predicates for: | | ref-iou-sum |
| term I/O, predicates for: | | mpg-top-tio |
| term input: | | ref-iou-tin |
| term names: | | FDBG Names of Terms |
| term names: | | FDBG Naming Terms |
| term output: | | ref-iou-tou |
| term reference: | | Mixing C and Prolog |
| term, atomic (definition): | | Glossary |
| term, callable (definition): | | Glossary |
| term, compound (definition): | | Glossary |
| term, cyclic: | | mpg-ref-read_term |
| term, cyclic: | | mpg-ref-write_term |
| term, error: | | ref-ere-rex |
| term, exception: | | ref-ere-rex |
| term, exception: | | Exception Handling in C |
| term, indexed: | | LMDB DB-Spec Intro |
| term, layout: | | mpg-ref-read_term |
| term, layout (definition): | | Glossary |
| term, mutable: | | ref-lte-mut |
| term, mutable (definition): | | Glossary |
| term, simple (definition): | | Glossary |
| term/1 (input method): | | Default Input Methods |
| terminal I/O, stream position information for: | | ref-iou-sos-spt |
| terminating a backtracking loop: | | Terminating a Backtracking Loop |
| Terms in C, C functions for: | | cpg-top-tic |
| terms, arguments of: | | ref-lte-act |
| terms, as sentences: | | ref-syn-syn |
| terms, comparison of: | | ref-lte-cte |
| terms, compound: | | ref-syn-cpt |
| terms, cyclic: | | ref-sem-occ |
| terms, input and output of: | | ref-iou-bas |
| terms, ordering on: | | ref-lte-cte-sot |
| terms, predicates for looking at: | | ref-lte |
| term_depth/2 (terms): | | lib-terms |
| term_expansion/6 (hook, ref page): | | mpg-ref-term_expansion |
| term_expansion/6 (user, hook): | | ref-lod-exp |
| term_hash/[2,3,4] (terms): | | lib-terms |
| term_order/3 (terms): | | lib-terms |
| term_position (load context key): | | ref-lps-lco |
| term_size/2 (terms): | | lib-terms |
| term_subsumer/3 (terms): | | lib-terms |
| term_variables/2 (built-in): | | ref-lte-act |
| term_variables/2 (built-in, ref page): | | mpg-ref-term_variables |
| term_variables/3 (aggregate): | | lib-aggregate |
| term_variables_bag/2 (terms): | | lib-terms |
| term_variables_set/2 (terms): | | lib-terms |
| terse (gc_trace flag value): | | ref-lps-flg |
| test condition, breakpoint: | | Goal Tests |
| test, breakpoint: | | Creating Breakpoints |
| test/[1,2] (plunit declaration): | | PlUnit A Unit Test Box |
| test_sub_bag/2 (bags): | | lib-bags |
| text (absolute_file_name/3 file type): | | mpg-ref-absolute_file_name |
| text (Tk widget): | | Types of Widget |
| thread, main: | | Calling Prolog Asynchronously |
| threads: | | OS Threads |
| threads, calling Prolog from: | | Calling Prolog Asynchronously |
| throw/1 (built-in): | | ref-ere-rex |
| throw/1 (built-in, ref page): | | mpg-ref-throw |
| throws/1 (plunit option): | | PlUnit A Unit Test Box |
| timeout/1 (zinc option): | | FlatZinc Exported Predicates |
| timeout/1 (zinc option): | | MiniZinc Exported Predicates |
| timestamp: | | lib-file_systems |
| time_out (labeling/2 time_out/2 option value): | | Enumeration Predicates |
| time_out/2 (labeling/2 option): | | Enumeration Predicates |
| time_out/3 (timeout): | | lib-timeout |
| title (prolog flag): | | ref-lps-flg |
| tk_all_events (tk_do_one_event/1 option): | | Servicing Tk Events |
| tk_destroy_window/1 (tcltk): | | Housekeeping |
| tk_destroy_window/1 (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions |
| tk_dont_wait (tk_do_one_event/1 option): | | Servicing Tk Events |
| tk_do_one_event/[0,1] (tcltk): | | Servicing Tk Events |
| tk_do_one_event/[0,1] (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions |
| tk_file_events (tk_do_one_event/1 option): | | Servicing Tk Events |
| tk_idle_events (tk_do_one_event/1 option): | | Servicing Tk Events |
| tk_main_loop/0 (tcltk): | | Passing Control to Tk |
| tk_main_loop/0 (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions |
| tk_main_window/2 (tcltk): | | Housekeeping |
| tk_main_window/2 (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions |
| tk_make_window_exist/1 (tcltk): | | Housekeeping |
| tk_make_window_exist/1 (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions |
| tk_new/2 (tcltk): | | Basic Functions |
| tk_new/2 (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions |
| tk_next_event/[2,3] (tcltk): | | Event Functions |
| tk_next_event/[2,3] (tcltk): | | Servicing Tk Events |
| tk_next_event/[2,3] (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions |
| tk_num_main_windows/1 (tcltk): | | Housekeeping |
| tk_num_main_windows/1 (tcltk): | | Predicates for Prolog to Interact with Tcl Interpreters with Tk Extensions |
| tk_timer_events (tk_do_one_event/1 option): | | Servicing Tk Events |
| tk_window_events (tk_do_one_event/1 option): | | Servicing Tk Events |
| tokens: | | ref-syn-syn |
| told/0 (built-in): | | ref-iou-sfh-cst |
| told/0 (built-in, ref page): | | mpg-ref-told |
| top level: | | Start |
| toplevel (Tk widget): | | Types of Widget |
| toplevel_print_options (prolog flag): | | Queries |
| toplevel_print_options (prolog flag): | | ref-lps-flg |
| toplevel_print_options (prolog flag): | | Message Phases |
| toplevel_print_options (prolog flag): | | mpg-ref-portray |
| toplevel_print_options (prolog flag): | | mpg-ref-write_term |
| toplevel_show_store (CHR flag): | | CHR Debugging Predicates |
| top_level_events/0 (tk_new/2 option): | | Basic Functions |
| top_sort/2 (ugraphs): | | lib-ugraphs |
| top_sort/2 (wgraphs): | | lib-wgraphs |
| total_runtime (statistics key): | | ref-mgc-ove-sta |
| trace (debugging flag value): | | ref-lps-flg |
| trace (debugging flag value): | | mpg-ref-debugging |
| trace (definition): | | Glossary |
| trace (unknown flag value): | | ref-lps-flg |
| trace (unknown flag value): | | ref-ere-hex-hup |
| trace/0 (built-in): | | Basic Debug |
| trace/0 (built-in, ref page): | | mpg-ref-trace |
| trace/0 (debugger mode control): | | Action Variables |
| trail (statistics key): | | ref-mgc-ove-sta |
| trail stack: | | ref-mgc-ove |
| TRAILSTKSIZE (system property): | | System Properties and Environment Variables |
| trail_free (statistics key): | | ref-mgc-ove-sta |
| trail_used (statistics key): | | ref-mgc-ove-sta |
| transitive_closure/2 (ugraphs): | | lib-ugraphs |
| transitive_closure/2 (wgraphs): | | lib-wgraphs |
| transitive_reduction/2 (ugraphs): | | lib-ugraphs |
| transpose/2 (lists): | | lib-lists |
| transpose_ugraph/2 (ugraphs): | | lib-ugraphs |
| transpose_wgraph/2 (wgraphs): | | lib-wgraphs |
| tree, binary: | | lib-assoc |
| tree, binary: | | lib-avl |
| tree/1 (abolish/2 option): | | mpg-ref-abolish |
| tree_size/2 (trees): | | lib-trees |
| tree_to_list/2 (trees): | | lib-trees |
| trimcore/0 (built-in): | | ref-mgc-ove-rsp |
| trimcore/0 (built-in, ref page): | | mpg-ref-trimcore |
| true/0 (built-in, ref page): | | mpg-ref-true |
| true/0 (debugger condition): | | Other Tests |
| true/0 (plunit option): | | PlUnit A Unit Test Box |
| true/1 (debugger condition): | | Breakpoint Tests |
| true/1 (debugger condition): | | Other Tests |
| true/1 (plunit option): | | PlUnit A Unit Test Box |
| truncate /1, (evaluable): | | ref-ari-aex |
| try (CHR port): | | CHR Ports |
| type errors: | | ref-ere-err-typ |
| type of operators: | | ref-syn-ops-ove |
| type tests, C functions for: | | cpg-top-typ |
| type tests, predicates for: | | ref-lte-met-typ |
| type tests, predicates for: | | ref-lte-met-typ |
| type tests, predicates for: | | ref-lte-sum |
| type tests, predicates for: | | mpg-top-typ |
| type-in module: | | ref-lps-flg |
| type-in module: | | ref-mod-som |
| type-in module (definition): | | Glossary |
| type-in module, changing: | | ref-mod-tyi |
| type/1 (open/4 option): | | mpg-ref-open |
| type/1 (stream property): | | mpg-ref-stream_property |
| typein_module (prolog flag): | | ref-lps-flg |
| type_definition/[2,3] (structs): | | str-etr |
| type_error/[2,4] (error class): | | ref-ere-err |
|
| U | | |
|---|
| ugraph_to_wgraph/2 (wgraphs): | | lib-wgraphs |
| ugraph_to_wgraph/3 (wgraphs): | | lib-wgraphs |
| unbiased_standard_deviation/2 (statistics): | | lib-statistics |
| unbiased_variance/2 (statistics): | | lib-statistics |
| unblock/0 (debugger port value): | | Port Tests |
| unblocked goal (definition): | | Glossary |
| unbound (definition): | | Glossary |
| UNC path: | | ref-fdi-syn |
| undefined predicate: | | Undefined Predicates |
| undefined predicate: | | ref-lps-flg |
| undefined predicate: | | mpg-ref-unknown_predicate_handler |
| undefine_method/3 (objects): | | obj-exp-undefine_method |
| unification: | | ref-sem-sec |
| unification: | | ref-sem-sec |
| unification (definition): | | Glossary |
| unification, explicit: | | ref-lte-met-usu |
| unifier, most general: | | ref-sem-sec |
| unify (debugger command): | | Debug Commands |
| unify_with_occurs_check/2 (built-in): | | ref-lte-met-usu |
| unify_with_occurs_check/2 (built-in, ref page): | | mpg-ref-unify_with_occurs_check |
| uninherit/1 (objects): | | obj-exp-uninherit |
| uninstantiation errors: | | ref-ere-err-uns |
| uninstantiation_error/[1,3] (error class): | | ref-ere-err |
| union/[2,3,4] (sets): | | lib-sets |
| unit clause: | | ref-sem-pro |
| unit clause (definition): | | Glossary |
| unknown (prolog flag): | | Undefined Predicates |
| unknown (prolog flag): | | ref-lps-flg |
| unknown (prolog flag): | | ref-ere-hex-hup |
| unknown (prolog flag): | | mpg-ref-unknown |
| unknown (prolog flag): | | mpg-ref-unknown_predicate_handler |
| unknown procedures, catching: | | ref-mdb-dsp |
| unknown/2 (built-in): | | Undefined Predicates |
| unknown/2 (built-in): | | ref-ere-hex-hup |
| unknown/2 (built-in, ref page): | | mpg-ref-unknown |
| unknown_predicate_handler/3 (hook, ref page): | | mpg-ref-unknown_predicate_handler |
| unknown_predicate_handler/3 (user, hook): | | Undefined Predicates |
| unknown_predicate_handler/3 (user, hook): | | ref-ere-hex-hup |
| unleash/0 (debugger condition): | | Condition Macros |
| unload_foreign_resource/1 (built-in): | | Interface Predicates |
| unload_foreign_resource/1 (built-in, ref page): | | mpg-ref-unload_foreign_resource |
| unreachable code: | | Xref Introduction |
| unregister_event_listener/1 (prologbeans): | | PB Prolog Server Interface |
| unregister_query/1 (prologbeans): | | PB Prolog Server Interface |
| unset (Tcl command): | | Commands |
| up (labeling/2 option): | | Enumeration Predicates |
| update_mutable/2 (built-in): | | ref-lte-mut |
| update_mutable/2 (built-in, ref page): | | mpg-ref-update_mutable |
| uplevel (Tcl command): | | Commands |
| upvar (Tcl command): | | Commands |
| use of full stop: | | ref-iou-tin-trm |
| use of full stop: | | ref-iou-tou-cha |
| user: | | Inserting Clauses |
| user (--main option value): | | too-spld |
| user:breakpoint_expansion/2 (hook): | | Hooks Related to Breakpoints |
| user:breakpoint_expansion/2 (hook): | | Condition Macros |
| user:breakpoint_expansion/2 (hook, ref page): | | mpg-ref-breakpoint_expansion |
| user:debugger_command_hook/2 (hook): | | Hooks Related to Breakpoints |
| user:debugger_command_hook/2 (hook): | | Breakpoint Predicates |
| user:debugger_command_hook/2 (hook, ref page): | | mpg-ref-debugger_command_hook |
| user:error_exception/1 (hook): | | ref-ere-hex |
| user:error_exception/1 (hook): | | Exceptions Debug |
| user:error_exception/1 (hook, ref page): | | mpg-ref-error_exception |
| user:file_search_path/2 (hook): | | ref-fdi-fsp-def |
| user:file_search_path/2 (hook, ref page): | | mpg-ref-file_search_path |
| user:generate_message_hook/3 (hook): | | Message Handling Predicates |
| user:generate_message_hook/3 (hook, ref page): | | mpg-ref-generate_message_hook |
| user:library_directory/1 (hook, ref page): | | mpg-ref-library_directory |
| user:message_hook/3 (hook): | | Message Handling Predicates |
| user:message_hook/3 (hook, ref page): | | mpg-ref-message_hook |
| user:portray/1 (hook): | | ref-iou-tou-por |
| user:portray/1 (hook): | | CLPQR Fragments and Bits |
| user:portray/1 (hook, ref page): | | mpg-ref-portray |
| user:portray_message/2 (hook): | | Message Handling Predicates |
| user:portray_message/2 (hook, ref page): | | mpg-ref-portray_message |
| user:query_class_hook/5 (hook): | | Query Handling Predicates |
| user:query_class_hook/5 (hook, ref page): | | mpg-ref-query_class_hook |
| user:query_hook/6 (hook): | | Query Handling Predicates |
| user:query_input_hook/3 (hook): | | Query Handling Predicates |
| user:query_input_hook/3 (hook, ref page): | | mpg-ref-query_input_hook |
| user:query_map_hook/4 (hook): | | Query Handling Predicates |
| user:query_map_hook/4 (hook, ref page): | | mpg-ref-query_map_hook |
| user:runtime_entry/1 (hook): | | too-spld |
| user:runtime_entry/1 (hook, ref page): | | mpg-ref-runtime_entry |
| user:term_expansion/6 (hook): | | ref-lod-exp |
| user:term_expansion/6 (hook, ref page): | | mpg-ref-term_expansion |
| user:unknown_predicate_handler/3 (hook): | | Undefined Predicates |
| user:unknown_predicate_handler/3 (hook): | | ref-ere-hex-hup |
| user:unknown_predicate_handler/3 (hook, ref page): | | mpg-ref-unknown_predicate_handler |
| username/1 (odbc_db_open/4 option): | | ODBC Predicates |
| user_close() (C function): | | cpg-ref-user_close |
| user_error (prolog flag): | | ref-iou-sfh-sob |
| user_error (prolog flag): | | ref-lps-flg |
| user_error (prolog flag): | | Prolog Streams |
| user_error (stream alias): | | ref-iou-sfh-sob |
| user_flush_output() (C function): | | cpg-ref-user_flush_output |
| user_input (prolog flag): | | ref-iou-sfh-sob |
| user_input (prolog flag): | | ref-lps-flg |
| user_input (prolog flag): | | Prolog Streams |
| user_input (stream alias): | | ref-iou-sfh-sob |
| user_main() (C function): | | User-defined Main Programs |
| user_output (prolog flag): | | ref-iou-sfh-sob |
| user_output (prolog flag): | | ref-lps-flg |
| user_output (prolog flag): | | Prolog Streams |
| user_output (stream alias): | | ref-iou-sfh-sob |
| user_read() (C function): | | cpg-ref-user_read |
| user_write() (C function): | | cpg-ref-user_write |
| use_module/[1,2,3] (built-in): | | ref-mod-lod |
| use_module/[1,2,3] (built-in, ref page): | | mpg-ref-use_module |
| UTC: | | lib-file_systems |
| UTF-8 encoding: | | CPL Notes |
|
| V | | |
|---|
| val/1 (fd_global/[3,4] option): | | The Global Constraint Programming Interface |
| value (all_different/2 consistency/1 value): | | Arithmetic-Logical Constraints |
| value (all_distinct/2 consistency/1 value): | | Arithmetic-Logical Constraints |
| value (global_cardinality/3 consistency/1 value): | | Arithmetic-Logical Constraints |
| value (scalar_product/5 consistency/1 value): | | Arithmetic Constraints |
| value/1 (labeling/2 option): | | Enumeration Predicates |
| valueprec/3 (automaton/9 option): | | Sequence Constraints |
| value_precede_chain/[2,3] (clpfd): | | Sequence Constraints |
| var or Type (argument type): | | mpg-ref-aty-ety |
| var/1 (built-in, ref page): | | mpg-ref-var |
| variable: | | Terminology |
| variable (definition): | | Glossary |
| variable, anonymous: | | ref-syn-trm-var |
| variable, anonymous (definition): | | Glossary |
| variable, domain: | | CLPFD Interface |
| variable/1 (labeling/2 option): | | Enumeration Predicates |
| variables, attributed: | | lib-atts |
| variables, list of: | | FDBG Legend |
| variables, scope of: | | ref-sem-pro |
| variables, syntax of: | | ref-syn-trm-var |
| variables, writing: | | ref-iou-tou-cha |
| variables/1 (read_term/[2,3] option): | | mpg-ref-read_term |
| variables/1 (zinc option): | | FlatZinc Exported Predicates |
| variables/1 (zinc option): | | MiniZinc Exported Predicates |
| variable_names/1 (read_term/[2,3] option): | | mpg-ref-read_term |
| variable_names/1 (write_term/[2,3] option): | | mpg-ref-write_term |
| variant/2 (terms): | | lib-terms |
| varnumbers/[2,3] (varnumbers): | | lib-varnumbers |
| verbose (gc_trace flag value): | | ref-lps-flg |
| verify_attributes/3 (Module): | | lib-atts |
| version (prolog flag): | | ref-lps-flg |
| version_data (prolog flag): | | ref-lps-flg |
| vertices/2 (ugraphs): | | lib-ugraphs |
| vertices/2 (wgraphs): | | lib-wgraphs |
| vertices_edges_to_ugraph/3 (ugraphs): | | lib-ugraphs |
| vertices_edges_to_wgraph/3 (wgraphs): | | lib-wgraphs |
| view/0 (gauge): | | lib-gauge |
| visavis/1 (geost/[2,3,4] option): | | Placement Constraints |
| visavis_floating/1 (geost/[2,3,4] option): | | Placement Constraints |
| visavis_init/1 (geost/[2,3,4] option): | | Placement Constraints |
| visibility rules for modules: | | ref-mod-vis |
| visualizer: | | FDBG Visualizers |
| volatile (definition): | | Glossary |
| volatile (predicate property): | | mpg-ref-predicate_property |
| volatile declaration: | | Volatile Declarations |
| volatile/0 (predicate property): | | ref-lps-app |
| volatile/1 (built-in, ref page): | | mpg-ref-volatile |
| volatile/1 (declaration): | | Volatile Declarations |
|
| W | | |
|---|
| wake (CHR port): | | CHR Ports |
| walltime (statistics key): | | ref-mgc-ove-sta |
| WAM: | | Intro |
| warning (unknown flag value): | | ref-lps-flg |
| warning (unknown flag value): | | ref-ere-hex-hup |
| weighted_mean/3 (statistics): | | lib-statistics |
| weighted_standard_deviation/3 (statistics): | | lib-statistics |
| weighted_variance/3 (statistics): | | lib-statistics |
| wgraph_to_ugraph/2 (wgraphs): | | lib-wgraphs |
| when/1 (load_files/2 option): | | mpg-ref-load_files |
| when/2 (built-in, ref page): | | mpg-ref-when |
| while (Tcl command): | | Commands |
| windowed executable (definition): | | Glossary |
| with_output_to_codes/[2,3,4] (codesio): | | lib-codesio |
| wordocc/2 (automaton/9 option): | | Sequence Constraints |
| wordoccmod/3 (automaton/9 option): | | Sequence Constraints |
| wordprefix/2 (automaton/9 option): | | Sequence Constraints |
| wordsuffix/2 (automaton/9 option): | | Sequence Constraints |
| wrap/2 (disjoint1/2 option): | | Placement Constraints |
| wrap/4 (disjoint2/2 option): | | Placement Constraints |
| write (absolute_file_name/3 access): | | mpg-ref-absolute_file_name |
| write (debugger command): | | Debug Commands |
| write (open/[3,4] mode): | | mpg-ref-open |
| write predicates: | | ref-iou-tou-wrt |
| write predicates, distinctions among: | | ref-iou-tou-dis |
| write/0 (debugger show control): | | Action Variables |
| write/[1,2] (built-in): | | ref-iou-tou-wrt |
| write/[1,2] (built-in, ref page): | | mpg-ref-write |
| writeq/[1,2] (built-in): | | ref-iou-tou-wrt |
| writeq/[1,2] (built-in, ref page): | | mpg-ref-writeq |
| write_canonical/[1,2] (built-in): | | ref-iou-tou-wrt |
| write_canonical/[1,2] (built-in, ref page): | | mpg-ref-write_canonical |
| write_record/[1,2] (csv): | | lib-csv |
| write_records/[1,2] (csv): | | lib-csv |
| write_record_to_codes/2 (csv): | | lib-csv |
| write_term/1 (debugger show control): | | Action Variables |
| write_term/[2,3] (built-in): | | ref-iou-tou-wrt |
| write_term/[2,3] (built-in, ref page): | | mpg-ref-write_term |
| write_term_to_codes/[3,4] (codesio): | | lib-codesio |
| write_to_codes/[2,3] (codesio): | | lib-codesio |
| writing variables: | | ref-iou-tou-cha |
|
| X | | |
|---|
| X, identity for numbers: | | ref-ari-aex |
| xml_parse/[2,3] (xml): | | lib-xml |
| xml_pp/1 (xml): | | lib-xml |
| xml_subterm/2 (xml): | | lib-xml |
| xor /2, bitwise exclusive or (evaluable): | | ref-ari-aex |
|
| Z | | |
|---|
| zero-quote notation for character conversion: | | ref-syn-trm-int |
| zip (debugger command): | | Debug Commands |
| zip (debugging flag value): | | ref-lps-flg |
| zip (debugging flag value): | | mpg-ref-debugging |
| zip (definition): | | Glossary |
| zip/0 (built-in): | | Basic Debug |
| zip/0 (built-in, ref page): | | mpg-ref-zip |
| zip/0 (debugger mode control): | | Action Variables |
|