You can also watch a (slightly dated) slide-show about this algorithm here:

http://omadeon.com/tsp

• You don’t need PowerPoint to see this, but the PowerPoint presentation can also be downloaded here: http://omadeon.com/tsp/ogtsp.ppt

I am currently using this algorithm’s DLL inside a large-scale Scheduling Application for Multiple Tasks, in LPA WIN-Prolog. Some screen-shots from the program’s main window are shown in the following animated GIF:

O.G.T.S.P. Algorithm sample screen-shots

Related articles by Zemanta

• Assembly Language for Visual Prolog Meta-programming (prologsource.wordpress.com)
• Prolog message queue (dbtune.org)
• TAKASHI’S WORKSPACE: A Prolog In Haskell (propella.blogspot.com)
• Introduction of the Microsoft Office PowerPoint 2007 (5min.com)

apply_func(PRED, [Arg,Arg2,...]) <=> PRED(Arg1,Arg2,…)

GLOBAL DOMAINS
dom_iii = determ INTEGER (INTEGER,INTEGER,INTEGER) -(i,i,i) language c % <– example domain

GLOBAL PREDICATES
apply_func(DWORD,ListDomain) -(i,i) language c  % where arg-1 is a predicate-domain, such as “dom_iii”

PREDICATES
func2dword(dom_iii,DWORD) % converts a predicate to a doubleword memory-address

CLAUSES
func2dword(FUNC,DW):- DW = cast(dword,FUNC).

GOAL
func2dword(add3,DW),
Out = apply_func(DW,[10,20,30]),
write(“result = “,Out), nl, readchar(_).

OK, so here is the Assembly language code:

; ======================= _apply_func.asm ==========================
; Code for TASM 5 Assembler, command-line call for compilation:
; C:\TASM\BIN\TASM32.EXE /p /z /w2 /m2 /ml _apply_func.asm

IDEAL
P586
MODEL    flat
CODESEG
ALIGN 4

public _apply_func    ; (i,i)

PROC _apply_func near
ARG    func:dword, list:dword
LOCAL    fcnt:dword
ENTER 4,0
push    esi        ;
push    edi        ;
push    ebx        ;
mov    ecx,[func]  ; function………… ARG 1
mov    esi,[list]  ; list……………. ARG 2
xor    ebx,ebx     ; make EBX=0
mov    [fcnt],ebx  ; initialize local variable ‘fcnt’ to 0
lodsd              ; load the first list-element’s “element-flag”
dec    al          ; decrement it, to check if it was equal to 1
jnz short @@x1     ; exit if not so (i.e. if it was the end of the list)
; ———————- else…
@@L1:                  ; loop to read the (Visual-Prolog-) argument-list
inc    ebx        ; increment ebx (counter for number_of_arguments)
lodsd             ; load next list-element (argument of function)
push    eax       ; push it into the stack (for later function-call)
lodsd             ; load the pointer to the next list-element in EAX
mov    esi,eax    ; now ESI = (pointer-to-) next list-element
lodsd             ; load element-flag of next list-element
dec    al         ; decrement it, to check if it was a 1
jz short @@L1     ; if so, not yet the end of the list, so repeat!
; ====================== else…
@@x1:
call   ecx         ; call the (external) function (given in ARG-1)
mov    ecx,[fcnt]  ; get the function’s number of arguments from fcnt
@@L2:
jcxz @@x2          ; if the called function had NO arguments, exit
; ———————- else…
@@L3:                  ; loop to POP function-arguments, after the call
pop        edx     ; recover next argument from the stack
mov    ecx,[fcnt]  ; recover remaining arguments_counter
dec        ecx     ; decrement the remaining number_of_arguments
mov    [fcnt],ecx  ; store it again, in the local variable fcnt
jnz short @@L3     ; if not zeroed, continue popping arguments…
; ———————-
@@x2:
pop        ebx     ;
pop        edi     ;
pop        esi     ;
LEAVE
ENDP _apply_func

end

Recently, I discovered some Assembly language techniques to enhance G.I.S. Prolog even further, potentially valuable for a multitude of other purposes. They also have an intrinsic fascination in themselves, as general tools for Prolog meta-programming.

E.g. here is an Assembly language predicate, that takes as inputs another (external) predicate’s memory-address and a (Visual Prolog-) argument-list, and calls this (external) predicate, using the (arbitrary-length-) list of N arguments, as arguments of “arity N”:

apply_func(PRED, [Arg,Arg2,...]) <=> PRED(Arg1,Arg2,…)

Now, in ISO-Prolog there is a standard predicate known as “univ”, written as “=..“, which turns a list like [PRED,ARG1,ARG2,ARG3...] into a predicate call such as PRED(ARG1,ARG2,…). However, this does not exist in Visual Prolog, which sacrifices such “luxuries” for speed (which is the reason I also often use ISO-Prolog compilers, such as LPA-WinProlog and SWI-Prolog).

Anyway… The code you are about to see can be useful more generally, as an example of Prolog meta-programming, implemented in Assembly Language. The only difference between the way it works for Visual Prolog and the way it might work for another Prolog (or -indeed- ANY programming language, using a ‘C’-calling convention) is the Visual-Prolog-specific structure of a LIST, which in Visual Prolog has a different form than in all other languages. If you understand Assembly Language and intend to use this code for other (meta-programming) tasks, all you have to do is modify just a couple of lines in the code that follows. However, before you (even begin to) look at the Assembly Language Code, the following simple definitions in Visual Prolog (5.*) are a prerequisite for easier understanding:

GLOBAL DOMAINS
dom_iii = determ INTEGER (INTEGER,INTEGER,INTEGER)
 	-(i,i,i) language c % <-- example domain

GLOBAL PREDICATES
apply_func(DWORD,ListDomain) -(i,i) language c
% where arg-1 is a predicate-domain, such as "dom_iii"

After you compile the Assembly language code, you could create a simple “EasyWin” Visual Prolog project, with the following ines:

PREDICATES
 func2dword(dom_iii,DWORD) 
 % converts a predicate to a doubleword/address

 add3: dom_iii

CLAUSES
func2dword(FUNC,DW):- DW = cast(dword,FUNC).

add3(_X,_Y,_Z,Out):- Out = _X+_Y+_Z,
 	write("out = ",Out), nl, !
 	;
 	write("error!\n"), Out=-1, !.

GOAL
func2dword(add3,DW),
Out = apply_func(DW,[10,20,30]),
write("result = ",Out), nl, readchar(_).

%This program should produce "result = 60" (sum of [10,20,30]).

OK, so here is the Assembly language code:

; ==================== _apply_func.asm =====================
; Code for TASM 5 Assembler, command-line call for compilation:
; C:\TASM\BIN\TASM32.EXE /p /z /w2 /m2 /ml _apply_func.asm

IDEAL
P586
MODEL    flat
CODESEG
ALIGN 4

public _apply_func    ; (i,i)

PROC _apply_func near
ARG    func:dword, list:dword
LOCAL    fcnt:dword
ENTER 4,0
push    esi        ;
push    edi        ;
push    ebx        ;
push    ecx        ;
mov    ecx,[func]  ; function............ ARG 1
mov    esi,[list]  ; list................ ARG 2
xor    ebx,ebx     ; make EBX=0
mov    [fcnt],ebx  ; initialize local variable 'fcnt' to 0
lodsd              ; load the 1st list-element's "element-flag"
dec    al          ; decrement it, to check if it was a 1
jnz short @@x1     ; exit if not (i.e. if it's the list's end)
; ----------------- else...
@@L1:             ; loop to read the (Visual-Prolog-) arg-list
inc    ebx        ; increment ebx (counter for number_of_args)
lodsd             ; load next list-element (arg. of function)
push    eax       ; push it into the stack (for a function-call)
lodsd             ; load the pointer to next list-element in EAX
mov    esi,eax    ; now ESI = (pointer-to-) next list-element
lodsd             ; load element-flag of next list-element
dec    al         ; decrement it, to check if it was a 1
jz short @@L1     ; if so, not yet the list's end, so repeat!
; ================= else...
@@x1:
mov    [fcnt],ebx  ; store the number_of_args in local var. 'fcnt'
call   ecx         ; call the (external) function (given in ARG-1)
mov    ecx,[fcnt]  ; get the function's number of args from 'fcnt'
@@L2:
jcxz @@x2          ; if the called function had NO args, exit
; ------------------ else...
@@L3:              ; loop to POP function-args after the call
pop        edx     ; recover next argument from the stack
dec        ecx     ; decrement the remaining number_of_args
jnz short @@L3     ; if not zeroed, continue popping args...
; ------------------
@@x2:
pop        ecx     ;
pop        ebx     ;
pop        edi     ;
pop        esi     ;
LEAVE
ENDP _apply_func

end

NOTES:

• A not-so-obvious advantage of this code is that any Prolog interpeters written on the basis of Visual Prolog’s “PIE engine” (such as G.I.S. Prolog) make extensive use of calls such as this, inside their inference engine; using Prolog-lists of arguments to be called by turning them into proper predicate calls of arity=N (where N is the size of the list). So, an Assembly language implementation of such a calling mechanism can speed up such an interpreter considerably, especially inside recursive calls or loops, which call other predicates repeatedly countless times…
• Another not-so-obvious advantage is that -in this way- we managed to… trick Visual Prolog into doing “forbidden” predicate calls, such as PRED(arg1,arg2,….), where both the predicate’s functor and the arguments may appear as static data, stored in a Visual Prolog facts’ database.
• Don’t ask me (yet) how to implement such tricks in Visual Prolog 6.* or 7.*; I still use the version 5.* compilers a lot, because of their speed, as well as robustness in foreign language calls.
  

Related articles by Zemanta

• How to Compile Software From Source Code [Command Line]
• Intel Says to Prepare For “Thousands of Cores”
• Back to Basics: Algorithms
• JIT in Prolog
• Revenge of the Nerds
• Dip into concept programming
• Google Code Search Shows Function Outline
• Ard-e: Cheap Arduino robot platform
• Get Started With Movable Type

Visual DreamProver 1.0 is a new theorem-proving program, developed in LPA Win-Prolog 4.6, with multi-coloured graphics displays of (potentially unlimited) Logic expressions, theorem proofs and deductions in Multiple Form Logic, in the primary algebra of “Laws of Form“, in Boolean Algebra and in a variety of other logic systems (to a large extent used-defined). Here is an animated GIF slide-show of DreamProver’s visual display. It offers unlimited control of size, colour, shape and content for all Logic Expressions and all theorem proofs:

(Click on this image for a better quality animated GIF, of size 450Kb)

Although DreamProver is still at the “alpha stage“, I decided to publish a preliminary first report about its features and capabilities, to a large extent already working, to a lesser extent requiring minor debugging and final extensions, before release. I am also doing this for the benefit (and amusement) of a friendly innovative company: “Logic Programming Associates Ltd”, where I worked for a short pleasant period of a few weeks, some years ago (in 2001). LPA are the creators of the LPA Win-Prolog compiler. I hope that LPA continues a long tradition of innovative success through the latest version of their compiler, which also has MIDI (music) programming capabilities (featured in a recent posting, here).

I am also… officially requesting, after the release of DreamProver (and the ensuing free promotion of LPA’s amazing compiler) a small… personal favour: -A legitimate free copy of their newest LPA Win-Prolog 4.7 compiler! (as my license for using version 4.6 ends on the last day of 2007).

DreamProver is particularly suited for the display of so-called “Boundary Logic Systems” (first created by George Spencer Brown in “Laws of Form” and then extended by various people in various ways – including my own “Multiple Form Logic” system). However, its (almost unlimited) potential allows the display of many other logic systems, including Parse-Trees of used-defined grammars, since both the shapes and the data-structures they represent can be redefined “on the fly”. In the display shown above, only a small example of a logic expression is used, mainly to demonstrate graphics capabilities. However, if -for example- the Grammar of a subset of English is used, instead of a Logic Expression, the ensuing graphic display of coloured shapes resembles a tree which is symmetric with respect to a “horizon” line in the middle.

The data-structure for this unusual kind of tree-representation is relatively simple, straight-forward and documented (in the final release of DreamProver). It is separate from the internal Logic representation but related to it through specific user-defined rules: Both the “productions” and the “leaves” of such a grammar tree are user-defined in shape and content. The only difference between other kinds of systems and those built-in (as regards the current first version of DreamProver) is that the other systems do not include internal Proof Algorithms and automated deductions, and can only be fed from the results of such processes (through external third-party software). Before final release it is hoped that the input-expressions in other systems are expressed in standard XML, so as to make the software useful to almost any researcher or developer, in any topic that includes parsed tree-expressions. The ultimate goal is also to develop a kind of Universal DreamProver library, available under a professional license to developers for a small fee (that might help sustain this work and pay for the effort of future upgrades). However, the current version of DreamProver is likely to appear as Open Source in the near future. Keep in touch!

Related articles by Zemanta

• BREAKING: Internet Creates Obvious Political .GIF! [It's Like Magic!]

However, in LPA Win-Prolog it is possible to preserve the original variable names, as well as sort them on the basis of these names. Finally it is also possible to retrieve the variables with their original names. Some examples follow:

1) LPA Prolog has predicates handling variable names (eread/2 and eprint/2). E.g. if you want Prolog to read a term with variables, preserving user-given variable names and then printing them out, you can use code like this:

| ?- eread(EXP,Vars), nl, eprint(EXP,Vars), nl, nl, nl.

|: this(THING,V,X,W).

this(THING,V,X,W)

EXP = this(_38218,_38220,_38226,_38232) ,

Vars = [('THING',_38218),('V',_38220),('X',_38226),('W',_38232)]

| ?-  

In LPA Prolog, eread/2 reads a term with variables and the it produces a list of names-and-variables [(Name,Var)|...] as a second argument. This has elements like (‘THING’,_38218) -in this example- where ‘THING’ is the user-defined variable name and _38218 is an “internal variable code”, generated by the compiler. The second predicate eprint/2 is similar: If the second argument of eprint/2 is bound to the names-and-variables-list (extracted previously) then the result is a printout of the expression as it was originally entered, preserving all the user-defined variable names.

Now, here is another example, only slightly more complicated. This time, it uses a small source-code file, which you can create easily, by copying and pasting the code that follows into a text file (of extension ‘.pl’).

The program asks the user to type a list (consisting of variables and constants) and then it is required to sort the variables, finally printing-out the resulting list with Variables sorted, but with names exactly the same as those typed originally. So, here is a piece of code that reads such a list from a user-prompt, sorts the list with respect to its variables, and then prints out the resulting list, with all the variables sorted:

test:- repeat, write('type a list of variables and constants:'), nl,

    eread(List,VL), sort(VL,VLsorted), sort(List,List1), varsort(List1,VLsorted,ListOut),

    write('sorted w.r.t. variables: '), eprint(ListOut,VL), nl, 

    write('press escape to exit, any other key to go on: '), get0(CHAR), CHAR = -1, !.

removevar(V,[A|L],L):- V == A, !.
removevar(V,[A|L],[A|Lx]):- removevar(V,L,Lx).

varsort([],_,[]):- !.
varsort(L,[],L):- !.
varsort(L,[(_Name,V)|VL],[V|XL]):-  removevar(V,L,L2), !, varsort(L2,[(_,V)|VL],XL).
varsort(L,[_|VL],XL):- !, varsort(L,VL,XL).

This piece of code is complete; you can copy it, paste it to a file ando compile it in LPA Win-Prolog. After doing this, type ‘test’ at the Prolog prompt. You will get a dialogue such as this:

| ?- test1.
type a list of variables and constants:
|: [A,D,C,2,B,34,X,F,D].
sorted w.r.t. variables: [A,B,C,D,F,X,2,34]
press escape to exit, any other key to go on: |:
yes

| ?-

The main predicate ‘test’ calls ‘eread/2′, which reads user- (or file-) input expressions and parses them into Prolog terms with variables. Then the variable-name-list is sorted. The original list is also sorted, and then the sorted variable names’ list is used to rearrange the sorted original list a second time, this time sorting it as regards variable names.

A very crucial predicate here is ‘removevar/3′, which is similar to the built-in predicate ‘remove/3′, removing an element of a list and producing the list without this element each time it’s called. However, unlike the built-in predicate ‘remove/3′, this one only deletes list-elements which are “identical to the first argument”, without doing any unification. I.e. it is capable of removing variables, if they exist in the list (of arg 2) but does not confuse them with other variables through unification.

Another new predicate in the code above is ‘ varsort’. It assumes that arg-1 contains an input-list (a mixture of variables and constants) and it makes use of the sorted list of variable names, to rearrange the list so that all the variable names are sorted, in the third (output-)argument:

[A,D,C,2,B,34,X,F,D] becomes [A,B,C,D,F,X,2,34] .

As an exercise, if you have some Prolog experience you can now try to write a similar piece of code that works on ANY kind of Prolog term, not just a list. If you do write such code, you can also send it as a comment in this posting, or an e-mail to omadeon@hotmail.com (with your name and any other details you’d like to see included), and I will publish it in this blog (with your name or alias) exactly as you’ve written it (provided of course that… it works )!

Well, I am still using LPA Win-Prolog, ever since that happy period of a few months I spent in the UK, back in 2001, as an employee of LPA Ltd. In fact, I was forced to return to Greece because of a bad accident (a broken tendon in a foot), otherwise I’d rather stay in the UK and work with LPA… forever! BTW, Brian Steel is also -like me- a winter swimmer, in the English sea (in Cornwall) making it even more apealling for me -at the time- to… follow his example.

The latest versions of LPA Prolog (version 4.6 is the one I use at the moment) are full of extra goodies, such as a coloured syntax editor, a nice dialog editor (for the visual design of menus, windows, dialog boxes, etc), and so on. (Not to mention several good extra packages, included in the compiler, such as Flex, Datamite, Proweb, Chimaira Agents, and so on; you can read all about them in LPA Prolog’s site, here).

My only complaint is that (at the moment) the LPA package does not include a Constraints programming extension, (such as CLP, CLP/fd, CHR, etc). However, I plan to adapt some open source code for such extensions and include it inside LPA Prolog, in the near future. Unless -of course- this innovative company has already embarked on a similar project, adding to their compiler Constraints handling extensions. Finally, the very latest (recently announced) next version of LPA Prolog includes something very special, which is useful to musically inclined programmers and hobbyists: A midi interface!

I was probably among those people who first proposed to Brian Steel -back in 2001- that a midi interface would prove to be very popular, as well as a way to expand LPA’s customer base even further. At the time (2001), most of their customers were academics, universities and serious professional people. Today (2007) my guess is that their clients begin to be also musically oriented hobbyists and computer-literate composers. I -for one- (as a composer and remixer) can’t wait to get my hands on this new version of their compiler, since it’s the best way to experiment with L-systems for computer music generation, Prolog-based grammars for parsing and analysing existing MIDI music pieces, and so on.

However, now that the MIDI music Logic Programming client-base of LPA Prolog is beginniing to grow, the issue of Constraints extensions can no longer be neglected. Some of the best work in musical Artificial Intelligence is already using Constraints programming methods.

In this blog, I hope to write quite often about programming projects and experiments with LPA Win-Prolog, including my own (public domain) source-code. In addition, you can browse some professional projects implemented with LPA Prolog in recent years (2001-2005), in my source-code and programming projects’ page.

Finally, there are some rather unusual web-pages I wrote a few years ago, with tips and free code to combine LPA Win-Prolog, with… one of its rivals (PDC/Visual Prolog). At the time, it became evident that it was perfectly possible to combine the best features of both these professional compilers, so the title of the main web-page about this work was “A tale of Two Prologs“.

If you need to convert into Prolog terms “raw data” supplied in EXCEL csv-files, read on! The source code in this posting will read any CSV file, converting each semicolon-delimited line (or record) of the CSV file into a Prolog clause, asserted in RAM. It is also possible to use the same code to read data deliberately provided (e.g. by another application) as a CSV-file, but which is specifically intended for use as a set of Prolog clauses.

This code also uses a couple of specification predicates: time_field_type/1, field1_as_functor/1, and conv_csvhead/2. These predicates control the behaviour of the conversion process, as follows:

time_field_type/1 :

• time_field_type(0). In this case, time-fields in the CSV file (of the form “HH:MM” or “HH:MM:SS…”) are translated into minutes, ignoring seconds or hundredths of a second.
• time_field_type(1). In this case, time-fields in the CSV file (of the form “HH:MM” or “HH:MM:SS…”) are translated into seconds, ignoring hundredths of a second.
• time_field_type(2). In this case, time-fields in the CSV file are kept as they are, as atoms (e.g. ’03:35′, ’12:45:20′, etc).

field1_as_functor/1:

• field1_as_functor(0): Each line in the CSV-file is interpreted as a prolog clause, where the functor of the clause is the first field of the record, and the other fields are arguments.
• field1_as_functor(foo) (where ‘foo’ can be any atom): Each line in the CSV file is interpreted as a prolog clause, where the functor of the clause is foo (or any atom supplied as 1st argument to field1_as_functor/1) and all the fields are arguments.

conv_csvhead/2:

• This predicate is used to convert the contents of the first field (of the CSV-file) into a (user-defined) internal Prolog representation. It is used only if “time_field_type(0)” exists. For example, to convert records where the first field is a Prolog functor ‘job’ but the actual contents of this field are ‘j’ (for brevvity), using a definition “conv_csvhead(j,job)” will convert each ‘j’ into a functor ‘job’. (Use of conv_csvhead/2 is optional; in the default case, it does nothing!)

Finally, some notes:

• The main predicate to call is “loaddb(CSVfile)“, where CSVfile can be e.g. “test.csv”.
• Provision has been taken for special fields which contain Lists of items, comma-delimited. In EXCEL these fields will appear as longish strings, but this code was written to parse them as Prolog atom-lists. (Comment-out this section if you don’t need it).
• The only type of field that is currently not converted into any meaningful internal representation is DATE. Dates are converted to atoms, just as they appear, without parsing their actual contents. (As an exercise, you can re-use parts of the same code to parse date-fields!) The honest reason for this omission is that… I didn’t need dates (in an application I am developing, for which this code was also written).

The source-code follows. There are useful comments inside this code. You can just copy and paste what follows from this point onwards, into a text file saved for compilation by SWI-Prolog, ending in “.pl”:

% ReadingG CSV-files (EXCEL); converting to Prolog clauses

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% Open-source SWI-Prolog code by OMADEON (c)2007/2009.
%% Blogs:
%%%%%%%% http://prologsource.wordpress.com
%%%%%%%% http://omadeon.wordpress.com
% time_field_type/1 defines the type of the TIME-fields:

% Cases:

% (0): minute-accuracy,

% (1): seconds-accuracy,

% (N): time preserved as is (atom, e.g. '03:30'); N > 1 

time_field_type(0).

%time_field_type(1).

%time_field_type(2).

% Reading CSV-file, converting to prolog-clauses:

loaddb(File):-
     open(File, read, Stream),
     read_line_to_codes(Stream, T0),
     parse_line(T0,Stream),
     close(Stream).

% user-specific conversion of 1st field to functor:

%conv_csvhead('j','job'):- !. % activate if really needed!

% default-case, when the 1st field is an internal functor

conv_csvhead(X,X):- !.

% specifies if first field of each record is Prolog functor

field1_is_functor(1). % it is a functor

%field1_is_functor(foo). % NOT a functor; arg1 IS the functor!

% end of file

parse_line(end_of_file,_):- !.

% end of input-stream

parse_line([],_):- !.

% current line is parsed; next line follows

parse_line(CODES,Stream):-
     field1_is_functor(1), !,
     csvparse(CODES,XL),
     XL = [First|XXL],
     conv_csvhead(First,Head),
     TERM =.. [Head|XXL],
     assert(TERM),  % assert prolog-clause
     read_line_to_codes(Stream,T2), 
     parse_line(T2,Stream).

% current line is parsed; next line follows

parse_line(CODES,Stream):-
     field1_is_functor(Head), !,
     csvparse(CODES,XL),
     TERM =.. [Head|XL],
     assert(TERM), %%% assert prolog-clause
     read_line_to_codes(Stream,T2),
     parse_line(T2,Stream).

% error message (rarely invoked; included "just in case")

parse_line(Term,Stream):- 
     format(user_error, 'Bad term: ~p~n', [Term]),
     read_line_to_codes(Stream,T2),
     parse_line(T2,Stream).
csvparse2([],_,[[]]):-!.

csvparse2(Inp,Sep,X):-
     csvparse(Inp,Sep,X), !.

csvparse2a([],[[]]):-!.

csvparse2a(Inp,X):- csvparse(Inp,X), !.

% parsing a line delimited by a semicolon(;)

csvparse([],[]):-!.

csvparse(CODES,[FirstOut|More]):-
     append(First,[59|RestCODES],CODES),
     !,
     conv_codes(First,FirstOut),
     csvparse2a(RestCODES,More).

csvparse(Last,[OutX]):- conv_codes(Last,OutX), !.

% parsing line delimited by given separator-char:

csvparse([],_,[]):-!.

csvparse(CODES,SEPc,[FirstOut|More]):-
     append(First,[SEPc|RestCODES],CODES), !,
     conv_codes(First,FirstOut),
     csvparse2(RestCODES,SEPc,More).

csvparse(Last,_,[OutX]):-
     conv_codes(Last,OutX), !.

% check that input-list is only digits or dot(.)

are_digits([C]):- C >= 46, C =< 57, C =\= 47, !.

are_digits([C|CL]):-
      C >= 46, C =< 57, C =\= 47,
      !, are_digits(CL).

% read string enclosed in double_quotes, e.g. "the"

conv_codes([34|Rest],AtomX):-
     append(MAINx,[34],Rest),
     +\memberchk(44,MAINx),
     atom_codes(AtomX,MAINx), !.

% reading an integer or decimal number

conv_codes(CL,Nx):-
     are_digits(CL),
     atom_codes(Ax,CL),
     atom_number(Ax,Nx), !.

% read comma-delimited list in dup-quotes, e.g. "a,b,cd"

conv_codes([34|Rest],LISTx):-
     append(MAINx,[34],Rest),
     memberchk(44,MAINx),
     csvparse(MAINx,44,LISTx), !.

% time_field of the form "HH:MM"

conv_codes([C1,C2,58,C3,C4],OUTx):-
    time_field_type(TYP),
    atom_codes(A1,[C1,C2]),
    atom_codes(A2,[C3,C4]),
    atom_number(A1,N1x),
    atom_number(A2,N2x),
    (TYP = 0 ->       
      OUTx is N2x + 60*N1x % only minutes-accuracy
      ;

      ( TYP = 1 ->

        ( OUTx is 60*(N2x + 60*N1x) ) % seconds-accuracy

        ;

        atom_codes(OUTx,[C1,C2,58,C3,C4]) % time=string

      )
    ), !.

% time_field of the form "HH:MM:SS..."

conv_codes([C1,C2,58,C3,C4,58,C5,C6|CL],OUTx):-
    time_field_type(TYP),
    atom_codes(A1,[C1,C2]),
    atom_codes(A2,[C3,C4]),
    atom_number(A1,N1x),
    atom_number(A2,N2x),
    MINSx is N2x + 60*N1x,
    ( TYP = 0

      -> OUTx = MINSx % if only minutes-accuracy required

        ;

        ( TYP = 1

          -> % use this if seconds-accuracy is required

          ( atom_codes(A3,[C5,C6]),
            atom_number(A3,SECS),
            OUTx is SECS + 60*MINSx

          )

          ;

          atom_codes(OUTx,[C1,C2,58,C3,C4,58,C5,C6|CL])
          % time=string

        )

    ), !.

% a comma-delimited list

conv_codes(MAIN,LISTx):-
     memberchk(44,MAIN),
     csvparse(MAIN,44,LISTx), !.

% remaining case: just an atom
% (including case of time=string):

conv_codes(MAIN,ATOMx):-
     atom_codes(ATOMx,MAIN), !.

%%% Conversion of Hours-and-minutes to integers and vice-versa (e.g. for CLP problems)

%%% converts number of minutes to a valid time-string e.g. '03:05':

mins2hourmin(MINS,OUTX):- nonvar(MINS), MINS > 0,
    Hours is MINS // 60, Minsx is MINS mod 60,
    num2str2(Hours,S1x), num2str2(Minsx,S2x),
    swritef(OUTX,'%w:%w',[S1x,S2x]), !
    ;
    MINS = 0, OUTX = '00:00', !.
mins2hourmin(HMINx,HRi):- nonvar(HRi),
    sub_atom(HRi,0,2,_,A1x), atom_number(A1x,HOURx),
    sub_atom(HRi,3,2,_,A2x), atom_number(A2x,MINSx),
    HMINx is MINSx + 60*HOURx, !.
mins2hourmin(MINS1,OUTX):- nonvar(MINS1), MINS1 < 0,
    MINS is -MINS1,
    Hours is MINS // 60, Minsx is MINS mod 60,
    num2str2(Hours,S1x), num2str2(Minsx,S2x),
    swritef(OUTX,'-%w:%w',[S1x,S2x]), !.

%% the same predicate operating on Lists of time-entities: 

mins2hourmin_list([],[]):- !.
mins2hourmin_list([M|ML],[X|XL]):- mins2hourmin(M,X), !, mins2hourmin_list(ML,XL).

%%% an auxilliary predicate for mins2hourmin/2:
num2str2(N,Sx):- N >= 10, swritef(Sx,'%w',[N]), !
    ;
    swritef(Sx,'0%w',[N]), !.

The SWI-Prolog predicate ‘between/3′ generates (non-deterministically) a number, ranging from a minimum value to a maximum Value (as ‘bound’ 1st and 2nd arguments). I.e., in the SWI-Prolog console:

?- between(1,3,X).

X = 1 ;

X = 2 ;

X = 3 ;

Well, here is an LPA Win-Prolog implementation of this predicate (also valid in any other ISO-compatible Prolog):

between(Min,_,Min).

between(Min,Max,Out):- M2 is Min+1, M2 =< Max, between(M2,Max,Out).

OK, This was an easy example, while most probably the same code already exists in elementary Prolog textbooks. Here are some other (not-so-obvious) examples:

In LPA Prolog there are some very special, very efficient unique commands, like ‘find/3‘, which operates on ‘input streams’ to locate (sub-)strings inside them. Now, the so-called ‘input stream’ can itself (effectively) be just another string (turned into a stream through the special LPA command ‘<~’). The use of this predicate, ‘find/3′ to write quickly efficient code for non-deterministic search (of substrings inside larger strings) is a natural happy consequence. E.g.

findsubs(SubSTR,STR,Px):- len(SubSTR,Len), findrep(SubSTR,Len,Px) <~ STR.

findrep(_,Len,Px):- inpos(EndP), EndP > 0, Px is EndP-Len.
findrep(SubSTR,Len,Px):- find(SubSTR,0,Sx), +Sx=``, findrep(SubSTR,Len,Px). 

I wrote this code after understanding the (well-documented) similar non-deterministic predicate ‘replace’ (not a built-in command but given as simple source-code in LPA-Prolog’s Reference Quide, page 226). The reason I wrote it is because I needed it as a sub-predicate to implement of SWI-Prolog‘s superb predicate ‘sub_atom‘. (This was already used -alas in several places- inside the SWI-Prolog project, which was to be converted into LPA WIn-Prolοg).So, here is the resulting LPA-Prolog implementation of ‘sub_atom‘, valid for (almost) all possible flow-patterns (at least those used in my project, plus a few more):

/*********************************************************************************************

(a description of sub_atom/5 from SWI-Prolog's Open Source documentation):

sub atom(+Atom, ?Before, ?Len, ?After, ?Sub)

    ISO predicate for breaking atoms. It maintains the following relation: Sub is a sub-atom of Atom
    that starts at Before, has Len characters and Atom contains After characters after the match.
?- sub_atom(abc, 1, 1, A, S).
 A = 1, S = b
   The implementation minimises non-determinism and creation of atoms. This is a very flexible
   predicate that can do search, prefix- and suffix-matching, etc.
**********************************************************************************************/

% HERE is my LPA Win-Prolog (exact) implementation of 'sub_atom/5':

%%%%%%%%%% (also valid in most other ISO-ish Prologs) %%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% (i,i,i,o,o)
sub_atom(Atom,Start,Len,LenAfterX,SubX):-
   nonvar(Atom), nonvar(Start), nonvar(Len), var(LenAfterX), var(SubX),
   cat(Lx,Atom,[Start,Len]), Lx = [_,SubX,End], len(End,LenAfterX).

% (i,o,i,i,o)
sub_atom(Atom,Start,Len,LenAfter,SubX):-
   nonvar(Atom), nonvar(Len), nonvar(LenAfter), var(Start), var(SubX),
   len(Atom,LenTotal), Start is LenTotal - LenAfter - Len,
   cat(Lx,Atom,[Start,Len]), Lx = [_,SubX,_].

% (i,o,o,o,i)  (effectively a non-deterministic search-function)
sub_atom(Atom,Startx,SubLenx,LenAfterX,Sub):-
   nonvar(Atom), nonvar(Sub), var(SubLenx), var(LenAfterx), var(Startx),
   len(Sub,SubLenx),  atom_string(Atom,STR), atom_string(Sub,SubSTR), len(STR,Slen),
   findrep(SubSTR,SubLenx,Startx) <~ STR, LenAfterX is Slen-Startx-SubLenx.

% where 'findrep/3' was written previously as a part of 'findsubs' (top of this post).

%(i,i,o,o,o)
sub_atom(Atom,Start,Len,LenAfterX,SubX):-
   nonvar(Atom), nonvar(Start), var(Len), var(LenAfterX), var(SubX),
  cat(Lx,Atom,[Start]), Lx = [_,End], len(End,Len2),
  between(0,Len2,Lenx), cat(Lxx,End,[Lenx]),
  Lxx = [SubX,End2], len(End2,LenAfterX), Len=Lenx.

%(i,o,o,o,o)
sub_atom(Atom,Start,Len,LenAfterX,SubX):-
   nonvar(Atom), var(Start), var(Len), var(LenAfterX), var(SubX),
   len(Atom,Len1), between(0,Len1,Pos),
  cat(Lx,Atom,[Pos]), Lx = [_,End], len(End,Len2),
  between(0,Len2,Lenx), cat(Lxx,End,[Lenx]),
  Lxx = [SubX,End2], len(End2,LenAfterX), Len=Lenx, Start=Pos.

%(i,o,i,o,o)
sub_atom(Atom,Start,Len,LenAfterX,SubX):-
   nonvar(Atom), var(Start), nonvar(Len), var(LenAfterX), var(SubX),
   len(Atom,Len1), LenPre is Len1-Len, between(0,LenPre,Pos),
  cat(Lx,Atom,[Pos,Len]), Lx = [_,Mid,End],
  SubX = Mid, LenAfterX is Len1-Pos-Len, Start=Pos.

%%%%%%%%%% (end of code) %%%%%%%%

Well, that’s it, for the moment, I’m afraid.

I must go back to my project now, but (rest assured) I will be coming back here, soon, again and again, and again…