But I guess it would be legit to show it automatically
in scientific form, since there is no ambiguity in re-read
when shown as follows (Dogelog runtime output):

:- X is 30000000000000000000000000+0.0, write(X), nl.
3.0E25

Yes, such an output would also work in Picat:

Picat> X is 3.0E25.
X = 30000000000000000570425344.0
yes

Its the same float.

Mostowski Collapse schrieb am Donnerstag, 29. Juli 2021 um 13:46:31 UTC+2:
> I just tried:
>
> Picat 3.1, (C) picat-lang.org, 2013-2021.
> Picat> X is float(30000000000000000000000000).
> *** Undefined procedure: float/1
>
> So float/1 doesn't exist. What am I supposed to do?
> This here seems to be a work around though?
>
> Picat> X is 30000000000000000000000000+0.0.
> X = 30000000000000000570425344.0
> yes
>
> It is even correct! (Tested on Mac)

TauProlog 0.3.1 (beta)

?- number_chars(X,"30000000000000000000000000").
X = 3.
?- X is 30000000000000000000000000.
X = 3.

Was rather expecting an overflow error, because of the flag value:

?- current_prolog_flag(bounded, X).
X = true

Mostowski Collapse schrieb am Donnerstag, 29. Juli 2021 um 13:47:49 UTC+2:
> But I guess it would be legit to show it automatically
> in scientific form, since there is no ambiguity in re-read
> when shown as follows (Dogelog runtime output):
>
> :- X is 30000000000000000000000000+0.0, write(X), nl.
> 3.0E25
>
> Yes, such an output would also work in Picat:
>
> Picat> X is 3.0E25.
> X = 30000000000000000570425344.0
> yes
>
> Its the same float.
> Mostowski Collapse schrieb am Donnerstag, 29. Juli 2021 um 13:46:31 UTC+2:
> > I just tried:
> >
> > Picat 3.1, (C) picat-lang.org, 2013-2021.
> > Picat> X is float(30000000000000000000000000).
> > *** Undefined procedure: float/1
> >
> > So float/1 doesn't exist. What am I supposed to do?
> > This here seems to be a work around though?
> >
> > Picat> X is 30000000000000000000000000+0.0.
> > X = 30000000000000000570425344.0
> > yes
> >
> > It is even correct! (Tested on Mac)

Even Python disagrees:

/* Python: https://www.python.org/shell/ */
>>> int(float(30000000000000000000000000))
30000000000000000570425344

/* SWI-Prolog: https://swish.swi-prolog.org/ */
?- X is integer(float(30000000000000000000000000)).
X = 29999999999999996275458048

Mostowski Collapse schrieb am Donnerstag, 29. Juli 2021 um 13:56:44 UTC+2:
> TauProlog 0.3.1 (beta)
>
> ?- number_chars(X,"30000000000000000000000000").
> X = 3.
> ?- X is 30000000000000000000000000.
> X = 3.
>
> Was rather expecting an overflow error, because of the flag value:
>
> ?- current_prolog_flag(bounded, X).
> X = true
> Mostowski Collapse schrieb am Donnerstag, 29. Juli 2021 um 13:47:49 UTC+2:
> > But I guess it would be legit to show it automatically
> > in scientific form, since there is no ambiguity in re-read
> > when shown as follows (Dogelog runtime output):
> >
> > :- X is 30000000000000000000000000+0.0, write(X), nl.
> > 3.0E25
> >
> > Yes, such an output would also work in Picat:
> >
> > Picat> X is 3.0E25.
> > X = 30000000000000000570425344.0
> > yes
> >
> > Its the same float.
> > Mostowski Collapse schrieb am Donnerstag, 29. Juli 2021 um 13:46:31 UTC+2:
> > > I just tried:
> > >
> > > Picat 3.1, (C) picat-lang.org, 2013-2021.
> > > Picat> X is float(30000000000000000000000000).
> > > *** Undefined procedure: float/1
> > >
> > > So float/1 doesn't exist. What am I supposed to do?
> > > This here seems to be a work around though?
> > >
> > > Picat> X is 30000000000000000000000000+0.0.
> > > X = 30000000000000000570425344.0
> > > yes
> > >
> > > It is even correct! (Tested on Mac)

Maybe I should do more testing, JavaScript describes the method to find a
float as HALFEVEN. I guess this method applied when one calls the conversion
Number(), i.e. the constructor without the new keyword, which is the float/1 evaluable
function equivalent of JavaScript. The conversion Number() can be also
called for bigint arguments. So JavaScript has float/1 from a bigint like
Prolog does have. So how is this conversion described:

" In this specification, the phrase “the Number value for x” where x
represents an exact real mathematical quantity (which might even be
an irrational number such as π) means a Number value chosen in the
following manner. Consider the set of all finite values of the Number type,
with -0𝔽 removed and with two additional values added to it that are not
representable in the Number type, namely 2^1024 (which is +1 × 253 × 2971)
and -2^1024 (which is -1 × 253 × 2971). Choose the member of this set that
is closest in value to x. If two values of the set are equally close, then the
one with an even significand is chosen; for this purpose, the two extra values
2^1024 and -2^1024 are considered to have even significands. Finally, if 2^1024
was chosen, replace it with +∞𝔽; if -21024 was chosen, replace it with -∞𝔽;
if +0𝔽 was chosen, replace it with -0𝔽 if and only if x < 0; any other chosen
value is used unchanged. The result is the Number value for x. (This procedure
corresponds exactly to the behaviour of the IEEE 754-2019 roundTiesToEven mode.)"
https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type

I am not sure whether I tested this already. The current test doesn’t test a tie.
Creating a tie test case is a tick more work. Also the above describes a
choice of negative zero. I should convert negative zero into positive zero
in my system, since I do not want to support that, its currently not in the
ISO core standard. But SWI-Prolog might support it:

/* SWI-Prolog 8.3.26 */
?- X is -0.0.
X = -0.0.

Ok there is no danger of negative zero, since a funny side effect
of mapping small floats to bigint. I have to do that otherwise I cannot
distinguish them from small int, and small float and small int would
both have the same type. Currently result is (Dogelog runtime):

:- X is -1.0*0.0, write(X), nl.
:- 0.0 == -0.0, write(yes), nl; write(no), nl.
0.0
yes

Mostowski Collapse schrieb am Donnerstag, 29. Juli 2021 um 20:52:35 UTC+2:
> Maybe I should do more testing, JavaScript describes the method to find a
> float as HALFEVEN. I guess this method applied when one calls the conversion
> Number(), i.e. the constructor without the new keyword, which is the float/1 evaluable
> function equivalent of JavaScript. The conversion Number() can be also
> called for bigint arguments. So JavaScript has float/1 from a bigint like
> Prolog does have. So how is this conversion described:
>
> " In this specification, the phrase “the Number value for x” where x
> represents an exact real mathematical quantity (which might even be
> an irrational number such as π) means a Number value chosen in the
> following manner. Consider the set of all finite values of the Number type,
> with -0𝔽 removed and with two additional values added to it that are not
> representable in the Number type, namely 2^1024 (which is +1 × 253 × 2971)
> and -2^1024 (which is -1 × 253 × 2971). Choose the member of this set that
> is closest in value to x. If two values of the set are equally close, then the
> one with an even significand is chosen; for this purpose, the two extra values
> 2^1024 and -2^1024 are considered to have even significands. Finally, if 2^1024
> was chosen, replace it with +∞𝔽; if -21024 was chosen, replace it with -∞𝔽;
> if +0𝔽 was chosen, replace it with -0𝔽 if and only if x < 0; any other chosen
> value is used unchanged. The result is the Number value for x. (This procedure
> corresponds exactly to the behaviour of the IEEE 754-2019 roundTiesToEven mode.)"
> https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type
>
> I am not sure whether I tested this already. The current test doesn’t test a tie.
> Creating a tie test case is a tick more work. Also the above describes a
> choice of negative zero. I should convert negative zero into positive zero
> in my system, since I do not want to support that, its currently not in the
> ISO core standard. But SWI-Prolog might support it:
>
> /* SWI-Prolog 8.3.26 */
> ?- X is -0.0.
> X = -0.0.

Oho, Scryer Prolog (v0.8.127) isn't that lucky either. I get:

?- X is float(30000000000000000000000000).
X = 29999999999999996000000000.0.
?- 30000000000000000000000000 < 30000000000000000000000000.1.
true.

Expectation would be rather a different float number,
and subsequently the comparison false.

Now there are some interesting news, we might soon
see SWI-Prolog performing the following feat:

?- A = ४२.
A = 42.

This works already for a while in Dogelog, although
it had a bug, which was only fixed yesterday.

You can try:
http://www.xlog.ch/izytab/moblet/docs/18_live/10_reference/example01/package.html

One could further extend it to Hex. Like for example:

?- A = 0xＢＡＢＥ.
A = 47806.

Works in Dogelog Player and formerly Jekejeke Prolog.
Again I only did it because Java can already do it.

Take this Java code:

int val = Integer.parseInt("ＢＡＢＥ", 16);
System.out.println("val="+val);

It gives me:

val=47806

Mostowski Collapse schrieb am Freitag, 24. Juni 2022 um 10:24:47 UTC+2:
> Now there are some interesting news, we might soon
> see SWI-Prolog performing the following feat:
>
> ?- A = ४२.
> A = 42.
>
> This works already for a while in Dogelog, although
> it had a bug, which was only fixed yesterday.
>
> You can try:
> http://www.xlog.ch/izytab/moblet/docs/18_live/10_reference/example01/package.html

I could also imagine that this feature is banned from
consulting Prolog texts or reading Prolog terms, and
only works for number_codes/2. But somehow there is

a conflict in the ISO Prolog core standard, number_codes/2
refers to the Prolog text syntax. In Java the feature is also
banned from Java texts. This here doesn’t compile:

int val = 0xＢＡＢＥ;
System.out.println("val="+val);

I get this Java compiler error:

java: illegal non-ASCII digit

So its only Integer.parseInt() thingy and not a Java texts
thingy. But I don’t see for number_codes/2 that the ISO
Prolog core standard would be aware of such a difference.

So at the moment its easier to make a solution that conflates
the two, Prolog texts and some built-ins like number_codes/2.

Mostowski Collapse schrieb am Freitag, 24. Juni 2022 um 10:32:13 UTC+2:
> One could further extend it to Hex. Like for example:
>
> ?- A = 0xＢＡＢＥ.
> A = 47806.
>
> Works in Dogelog Player and formerly Jekejeke Prolog.
> Again I only did it because Java can already do it.
>
> Take this Java code:
>
> int val = Integer.parseInt("ＢＡＢＥ", 16);
> System.out.println("val="+val);
>
> It gives me:
>
> val=47806
> Mostowski Collapse schrieb am Freitag, 24. Juni 2022 um 10:24:47 UTC+2:
> > Now there are some interesting news, we might soon
> > see SWI-Prolog performing the following feat:
> >
> > ?- A = ४२.
> > A = 42.
> >
> > This works already for a while in Dogelog, although
> > it had a bug, which was only fixed yesterday.
> >
> > You can try:
> > http://www.xlog.ch/izytab/moblet/docs/18_live/10_reference/example01/package.html

Now I am picking up new vibes for Dogelog Player, its still
a young Prolog system, and the streams are also still pretty
primitive. Maybe some new ideas might even spill back

to formerly Jekejeke Prolog. So whats on the todo list next?
I find that the following goodies concerning open/4 are missing,
its even the case that we even only have an open/3 so far:

- bom(Bool)
Specify detecting or writing a BOM.
- encoding(Atom)
Specify a file encoding.

BTW: This is an interesting read:

> Microsoft compilers and interpreters, and many pieces of software
> on Microsoft Windows such as Notepad treat the BOM as a required
> magic number rather than use heuristics. These tools add a BOM when
> saving text as UTF-8, and cannot interpret UTF-8 unless the BOM is
> present or the file contains only ASCII.
> https://en.wikipedia.org/wiki/Byte_order_mark#UTF-8

So you might find a BOM also for UTF-8 files, not only UTF-16 and other
encodings. The usual heuristic is to choose UTF-8 if there is no BOM, but
the above suggests to throw an error if there is no BOM

and some non-ASCII, i.e. > 7 bit.

Don’t know if any Prolog system throws such an error. One could
make the input stream aware that there was no BOM, and then bark
on a > 7 bit character coming from the stream. Could give more security.

Makes me currious to check what Java, JavaScript and Python do,
whether they have some reader object with such a feature. In the
worst case one could realize this feature in the Prolog systems

streams itself. Again bom(Bool) is not mentioned in the ISO Prolog
core standard, similar to encoding(Atom), but it has already some
support across Prolog systems. For example in formerly Jekejeke

Prolog I have the same, and SWI-Prolog has it as well. Not sure
what newer Prolog systems such as Scryer Prolog provide.
Need to check.

Mostowski Collapse schrieb am Samstag, 25. Juni 2022 um 11:22:01 UTC+2:
> Now I am picking up new vibes for Dogelog Player, its still
> a young Prolog system, and the streams are also still pretty
> primitive. Maybe some new ideas might even spill back
>
> to formerly Jekejeke Prolog. So whats on the todo list next?
> I find that the following goodies concerning open/4 are missing,
> its even the case that we even only have an open/3 so far:
>
> - bom(Bool)
> Specify detecting or writing a BOM.
> - encoding(Atom)
> Specify a file encoding.
>
> BTW: This is an interesting read:
>
> > Microsoft compilers and interpreters, and many pieces of software
> > on Microsoft Windows such as Notepad treat the BOM as a required
> > magic number rather than use heuristics. These tools add a BOM when
> > saving text as UTF-8, and cannot interpret UTF-8 unless the BOM is
> > present or the file contains only ASCII.
> > https://en.wikipedia.org/wiki/Byte_order_mark#UTF-8
>
> So you might find a BOM also for UTF-8 files, not only UTF-16 and other
> encodings. The usual heuristic is to choose UTF-8 if there is no BOM, but
> the above suggests to throw an error if there is no BOM
>
> and some non-ASCII, i.e. > 7 bit.

Q: Why did Prolog miss the OpenAI/ChatGPT bandwagon?

A: Its in the genetics, Prolog is developing backwards:

1) Quintus: library(charsio)

2) SICStus: Na, library(codesio), characters that are atoms
of length 1 could pollute the atom table.

3.1) Scryer Prolog: Na, library(charsio), we have to go backwards,
create a vintage Prolog.

Meanwhile I am seriously considering renaming my
library(charsio) into library(atomsio), since that is
more what it does.

3.2) Dogelog Player: Na, library(atomsio),
what atom table?

Mostowski Collapse schrieb am Montag, 30. Januar 2023 um 17:17:32 UTC+1:
> Q: Why did Prolog miss the OpenAI/ChatGPT bandwagon?
>
> A: Its in the genetics, Prolog is developing backwards:
>
> 1) Quintus: library(charsio)
>
> 2) SICStus: Na, library(codesio), characters that are atoms
> of length 1 could pollute the atom table.
>
> 3.1) Scryer Prolog: Na, library(charsio), we have to go backwards,
> create a vintage Prolog.

Note: Do not confuse multillingual strings, as introduced
by recent Dogelog Player, with Unicode encoding.
I am using the phrase "multilingual strings" for a text

database. Interestingly I managed to make the text
database declarative. Means the strings/3 entries
are not order dependent. You can place languages into
the multifile predicate in any order,

and it will pick the most specific string independent
of the order of the strings/3 facts. I was replicating
the Java Script Resource Bundle lookup on a finer
grained level, by this simple Prolog code:

get_string(Key, Locale, Value) :-
sys_locale_ancestor(Locale, Parent),
strings(Key, Parent, Res), !,
Value = Res.

% sys_locale_ancestor(+Atom, -Atom)
sys_locale_ancestor(L, L).
sys_locale_ancestor(L, M) :-
last_sub_atom(L, P, _, _, '_'),
sub_atom(L, 0, P, _, M).
sys_locale_ancestor(_, '').

The above assumes that locale identifiers use
underscore separator. It also assumes the last_sub_atom/3
predicate from Novacore, unfortunatel ISO Core has
only sub_atom/3, but no last_sub_atom/3.

For locales, see also:

Creating global software: Text handling and localization
in Taligent’s CommonPoint application system
Mark Davis et al. - 1996
https://dev.antiguru.de/davis.pdf

I wasn't sure whether the get_string/3 implementation
will perform. In Jekejeke Prolog, since it has
multi-argument indexing, each string/3 lookup with

mode (+,+,-) will be a little bit faster, whereas
Doglog Player, which has only first argument indexing
will use a little bit more time, since it needs

a scan, can only lookup the Key via an index,
but will scan for the Parent. If the text database
isn't extremly large and/or if the locales do

not have extremly many segments, this is a
non-issue I guess. And Dogelog Player might get
multi-argument indexing in the future.

Mild Shock schrieb:
> Note: Do not confuse multillingual strings, as introduced
> by recent Dogelog Player, with Unicode encoding.
> I am using the phrase "multilingual strings" for a text
>
> database. Interestingly I managed to make the text
> database declarative. Means the strings/3 entries
> are not order dependent. You can place languages into
> the multifile predicate in any order,
>
> and it will pick the most specific string independent
> of the order of the strings/3 facts. I was replicating
> the Java Script Resource Bundle lookup on a finer
> grained level, by this simple Prolog code:
>
> get_string(Key, Locale, Value) :-
> sys_locale_ancestor(Locale, Parent),
> strings(Key, Parent, Res), !,
> Value = Res.
>
> % sys_locale_ancestor(+Atom, -Atom)
> sys_locale_ancestor(L, L).
> sys_locale_ancestor(L, M) :-
> last_sub_atom(L, P, _, _, '_'),
> sub_atom(L, 0, P, _, M).
> sys_locale_ancestor(_, '').
>
> The above assumes that locale identifiers use
> underscore separator. It also assumes the last_sub_atom/3
> predicate from Novacore, unfortunatel ISO Core has
> only sub_atom/3, but no last_sub_atom/3.
>