Tuesday, December 8, 2020

Digest for comp.lang.c++@googlegroups.com - 25 updates in 10 topics

Keith Thompson <Keith.S.Thompson+u@gmail.com>: Dec 04 11:18AM -0800

> it your intention to be rude and insulting? (That is not meant
> as a rhetorical question - I'm asking because I would like to
> hear your answer.)
 
My comments were intended to be critical. My most recent comment,
"I don't believe you" was probably a bit rude, and deliberately so.
It was in response to my perception that you were being rude and
pretending not to be. You claimed it was "just a question", but
it was immediately followed by a refusal to offer "courtesy and
respect", so your claim seemed disingenuous. I had found your
original "Can you first explain" remark to be an inappropriate
response to a reasonable question from Juha, part of what I perceive
to be your pattern of deliberately withholding information and
unreasonably expecting others to figure out what you meant.
 
I'm starting to think that you have geniune difficulty knowing how
you come across to others. (That last statement was not intended
to be either rude or critical.)
 
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips Healthcare
void Void(void) { Void(); } /* The recursive call of the void */
Tim Rentsch <tr.17687@z991.linuxsc.com>: Dec 03 07:22PM -0800

>> questions with courtesy and respect I don't see why I
>> should feel obliged to do so for yours.
 
> It wasn't "just a question", Tim. It was rude and insulting.
 
I'm sorry if it came across that way. It was meant to
be just a question.
"Rick C. Hodgin" <rick.c.hodgin@gmail.com>: Dec 06 10:15AM -0500

On 12/6/20 7:55 AM, Mr Flibble wrote:
>> well-known it is; it's popular among my coworkers.
 
> Please don't push your Christian agenda here; we have enough fruit loops
> doing that already.
 
Said the man who pushes his obscene, vulgar, anti-Christian agenda here.
 
There's so much more than you acknowledge today, Leigh. Your future can
be bright. Full of love to those around you. Full of hope and
affirmation of security and a future. Full of inner peace, love, and joy.
 
You're missing it, Leigh, and you're doing so in support of the purposes
of raging hatred spewing out toward others.
 
-----
Your life is not your own.
You are dominated right now by hateful masters using you.
 
They have blinded you to their presence as they literally usurp your
life, your future, your birthright, your heritage, all opportunity God's
given you to gain for yourself and others in eternity.
 
You are being robbed blind and stripped of everything, and they who are
doing this are preying on your love and embrace of sin to accomplish it.
They hate you, and they want to see you destroyed in Hell. And today,
they are having a full-on, 100% victory and success in their efforts.
They have wasted you and the sad thing is, you are loving every minute
of it ... today.
 
--
Rick C. Hodgin
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Dec 07 12:20AM +0100

On 06.12.2020 13:29, Jorgen Grahn wrote:
> Advent of Code
> https://adventofcode.com/2020
 
Minimal support library: <url:
https://github.com/alf-p-steinbach/kickstart/blob/master/source/examples/hello-world.md>
 
------------------------------------------------------------------------
#include <algorithm>
#include <fstream>
#include <sstream>
using std::max,
std::ifstream,
std::istringstream;
 
#include <kickstart/all.hpp>
using namespace kickstart::all;
 
 
void cpp_main()
{
const auto& filename = "pw-data.txt";
ifstream f( filename );
hopefully( not f.fail() )
or fail( ""s << "Failed to open '" << filename << "'." );
string line;
int n_valid = 0;
while( getline( f, line ) ) {
auto line_stream = istringstream( line );
int i1;
int i2;
char ch;
char dummy;
string password;
 
line_stream >> i1 >> dummy >> i2 >> ch >> dummy >> password
or fail( ""s << "Parsing '" << line << "' failed." );
 
n_valid +=
(ssize(password) >= max( i1, i2 ) )
and (password.at( i1 - 1 ) == ch) != (password.at( i2 - 1 )
== ch);
}
out << n_valid << endl;
}
 
auto main() -> int { return with_exceptions_displayed( cpp_main ); }
------------------------------------------------------------------------
 
 
- Alf (coding mode)
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Dec 06 11:39PM +0100

On 06.12.2020 13:29, Jorgen Grahn wrote:
> Advent of Code
> https://adventofcode.com/2020
 
Minimal support library: <url:
https://github.com/alf-p-steinbach/kickstart/blob/master/source/examples/hello-world.md>
 
------------------------------------------------------------------------
const int data[] =
{
1310,
// ...
};
 
#include <unordered_set>
using std::unordered_set;
 
#include <kickstart/all.hpp>
using namespace kickstart::all; // out, endl, fail, begin, end
 
void cpp_main()
{
const auto values = unordered_set<int>( begin( data ), end( data ) );
for( const int v: values ) {
const int other = 2020 - v;
if( values.count( other ) > 0 ) {
out << v*other << endl;
return;
}
}
fail( "No such value" );
}
 
auto main() -> int { return with_exceptions_displayed( cpp_main ); }
------------------------------------------------------------------------
 
 
- Alf (coding mode)
Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk>: Dec 07 01:21AM

On 06/12/2020 23:20, Alf P. Steinbach wrote:
 
> auto main() -> int { return with_exceptions_displayed( cpp_main ); }
> ------------------------------------------------------------------------
 
> - Alf (coding mode)
 
Your use of "using" directives and your omission of "std::" in function bodies makes you code less readable IMO.
 
/Flibble
 
--
😎
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Dec 07 07:26AM +0100

On 06.12.2020 13:29, Jorgen Grahn wrote:
> Advent of Code
> https://adventofcode.com/2020
 
Minimal support library: <url:
https://github.com/alf-p-steinbach/kickstart/blob/master/source/examples/hello-world.md>
 
I found that one way to screw up this exercise is to inadvertently save
the data file as UTF-8 with BOM. :-o
 
------------------------------------------------------------------------
#include <algorithm>
#include <fstream>
#include <sstream>
using std::max,
std::ifstream;
 
#include <kickstart/all.hpp>
using namespace kickstart::all;
 
auto read_map()
-> vector<string>
{
vector<string> result;
const auto& filename = "map-data.txt";
ifstream f( filename );
hopefully( not f.fail() )
or fail( ""s << "Failed to open '" << filename << "'." );
string line;
while( getline( f, line ) ) {
result.push_back( line );
}
hopefully( f.eof() ) or fail( ""s << "Error reading file '" <<
filename << "'." );
return result;
}
 
struct Point{ int x; int y; };
 
void cpp_main()
{
const vector<string> map = read_map();
const int w = static_cast<int>( ssize( map.front() ) );
const int h = static_cast<int>( ssize( map ) );
 
Point current = {0, 0};
int count = 0;
while( current.y < h ) {
count += (map[current.y][current.x] == '#');
{ //with
auto& _ = current;
_.x = (_.x + 3) % w; _.y += 1;
}
}
out << count << endl;
}
 
auto main() -> int { return with_exceptions_displayed( cpp_main ); }
------------------------------------------------------------------------
 
 
- Alf (morning coding mode)
Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk>: Dec 06 04:30PM

On 06/12/2020 15:15, Rick C. Hodgin wrote:
> You are dominated right now by hateful masters using you.
 
> They have blinded you to their presence as they literally usurp your life, your future, your birthright, your heritage, all opportunity God's given you to gain for yourself and others in eternity.
 
> You are being robbed blind and stripped of everything, and they who are doing this are preying on your love and embrace of sin to accomplish it.  They hate you, and they want to see you destroyed in Hell.  And today, they are having a full-on, 100% victory and success in their efforts. They have wasted you and the sad thing is, you are loving every minute of it ... today.
 
And Satan invented fossils, yes? Spammer?
 
/Flibble
 
--
😎
olcott <NoOne@NoWhere.com>: Dec 06 10:23AM -0600

On 12/6/2020 10:03 AM, Alan Mackenzie wrote:
>> vacuous.
 
> The impossibility of a halt decider is a mathematical theorem. There is
> no need to back that up with further reasoning. It is true.
 
Find the actual mistake in my correct refutation of the Peter Linz proof
Knucklehead !!!
 
Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company.
 
http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
 
 
Just in case your knowledge of software engineering is abysmal I will
give you this little hint whenever an execution trace includes a
function call to the same function from the same machine address without
any intervening conditional branch instructions in-between:
 
(trace lines 13-21 shown below) THIS IS INFINITE RECURSION !!!
 
Actual debug trace of H() deciding halting on H_Hat()
 
 
void H_Hat(u32 P)
{
u32 Input_Halts = H(P, P);
if (Input_Halts)
HERE: goto HERE;
else
HALT
}
 
 
int main()
{
H((u32)H_Hat, (u32)H_Hat);
HALT;
}
 
 
_H_Hat()
[000005e0](01) 55 push ebp
[000005e1](02) 8bec mov ebp,esp
[000005e3](01) 51 push ecx
[000005e4](03) 8b4508 mov eax,[ebp+08]
[000005e7](01) 50 push eax
[000005e8](03) 8b4d08 mov ecx,[ebp+08]
[000005eb](01) 51 push ecx
[000005ec](05) e87ffdffff call 00000370
[000005f1](03) 83c408 add esp,+08
[000005f4](03) 8945fc mov [ebp-04],eax
[000005f7](04) 837dfc00 cmp dword [ebp-04],+00
[000005fb](02) 7404 jz 00000601
[000005fd](02) ebfe jmp 000005fd
[000005ff](02) eb01 jmp 00000602
[00000601](01) f4 hlt
[00000602](02) 8be5 mov esp,ebp
[00000604](01) 5d pop ebp
[00000605](01) c3 ret
 
_main()
[00000610](01) 55 push ebp
[00000611](02) 8bec mov ebp,esp
[00000613](05) 68e0050000 push 000005e0
[00000618](05) 68e0050000 push 000005e0
[0000061d](05) e84efdffff call 00000370
[00000622](03) 83c408 add esp,+08
[00000625](01) f4 hlt
[00000626](01) 5d pop ebp
[00000627](01) c3 ret
 
 
Output_Debug_Trace() Trace_List.size(20)
[00000610](01) 55 push ebp
[00000611](02) 8bec mov ebp,esp
[00000613](05) 68e0050000 push 000005e0
[00000618](05) 68e0050000 push 000005e0
[0000061d](05) e84efdffff call 00000370
[000005e0](01) 55 push ebp
[000005e1](02) 8bec mov ebp,esp
[000005e3](01) 51 push ecx
[000005e4](03) 8b4508 mov eax,[ebp+08]
[000005e7](01) 50 push eax
[000005e8](03) 8b4d08 mov ecx,[ebp+08]
[000005eb](01) 51 push ecx
[000005ec](05) e87ffdffff call 00000370
[000005e0](01) 55 push ebp
[000005e1](02) 8bec mov ebp,esp
[000005e3](01) 51 push ecx
[000005e4](03) 8b4508 mov eax,[ebp+08]
[000005e7](01) 50 push eax
[000005e8](03) 8b4d08 mov ecx,[ebp+08]
[000005eb](01) 51 push ecx
[000005ec](05) e87ffdffff call 00000370
The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
Number of Instructions Executed(2777)
 
 
--
Copyright 2020 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
olcott <NoOne@NoWhere.com>: Dec 06 10:49AM -0600

On 12/6/2020 10:34 AM, Richard Damon wrote:
>> any intervening conditional branch instructions in-between:
 
> Except that the abpve rule is a bit flawed, as it needs to include ALL
> forms of conditional execution, including an indirect jump or call, and
 
In this case there are zero control flow instructions in-between, thus
making this point entirely moot for the current computation.
 
> needs to include ALL instructions in the loop, not just 'User' instructions.
 
> There are gaps in your traces that hide those conditionals.
 
On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
> A computation that would not halt if its simulation were not
> halted is indeed a non-halting computation.
 
On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote:
> Every computation that would not halt if its simulation
> were not halted is by logical necessity a non-halting computation.
 
Because of the above (halt deciding) criterion measure conditionals that
are a part of the halt decider and not a part of the user code are
correctly excluded when determining the non-halting behavior of the user
code.
 
--
Copyright 2020 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
olcott <NoOne@NoWhere.com>: Dec 08 08:44PM -0600

On 12/8/2020 7:31 PM, Ben Bacarisse wrote:
 
>> I AM GOING TO KEEP YOU PINNED DOWN ON THIS NO MATTER WHAT ELSE YOU SAY
>> ABOUT ANYTHING ELSE:
 
> Go for it.
 
You can't find any error in this because you know there is none yet you
continue to use dishonestly and subterfuge to disparage my work.
 
void Confound_Halts(u32 P)
{
if (Halts(P, P))
while (1);
}
 
 
int main()
{
Confound_Halts((u32)Confound_Halts);
HALT;
}
 
 
_Confound_Halts()
[0000063c](01) 55 push ebp
[0000063d](02) 8bec mov ebp,esp
[0000063f](03) 8b4508 mov eax,[ebp+08]
[00000642](01) 50 push eax
[00000643](03) 8b4d08 mov ecx,[ebp+08]
[00000646](01) 51 push ecx
[00000647](05) e800feffff call 0000044c
[0000064c](03) 83c408 add esp,+08
[0000064f](02) 85c0 test eax,eax
[00000651](02) 740b jz 0000065e
[00000653](05) ba01000000 mov edx,00000001
[00000658](02) 85d2 test edx,edx
[0000065a](02) 7402 jz 0000065e
[0000065c](02) ebf5 jmp 00000653
[0000065e](01) 5d pop ebp
[0000065f](01) c3 ret
 
_main()
[0000066c](01) 55 push ebp
[0000066d](02) 8bec mov ebp,esp
[0000066f](05) 683c060000 push 0000063c
[00000674](05) e8c3ffffff call 0000063c
[00000679](03) 83c404 add esp,+04
[0000067c](01) f4 hlt
[0000067d](01) 5d pop ebp
[0000067e](01) c3 ret
 
Output_Debug_Trace() Trace_List.size(17)
[0000066c](01) 55 push ebp
[0000066d](02) 8bec mov ebp,esp
[0000066f](05) 683c060000 push 0000063c
[00000674](05) e8c3ffffff call 0000063c // CALL
Confound_Halts()
[0000063c](01) 55 push ebp
[0000063d](02) 8bec mov ebp,esp
[0000063f](03) 8b4508 mov eax,[ebp+08]
[00000642](01) 50 push eax
[00000643](03) 8b4d08 mov ecx,[ebp+08]
[00000646](01) 51 push ecx
[00000647](05) e800feffff call 0000044c // CALL Halts()
[0000063c](01) 55 push ebp
[0000063d](02) 8bec mov ebp,esp
[0000063f](03) 8b4508 mov eax,[ebp+08]
[00000642](01) 50 push eax
[00000643](03) 8b4d08 mov ecx,[ebp+08]
[00000646](01) 51 push ecx
[00000647](05) e800feffff call 0000044c // CALL Halts()
The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
 
--
Copyright 2020 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
olcott <NoOne@NoWhere.com>: Dec 06 11:14PM -0600

On 12/6/2020 7:56 PM, Ben Bacarisse wrote:
> Confound_Halts(Confound_Halts) and its simulation
> Simulate(Confound_Halts, Confound_Halts) halt. The sentence does not
> apply.
 
The Turing Machine equivalent to a global halt decider would simply be a
UTM that has been adapted to become a halt decider. This adapted UTM
would decide not-halting on all three of the TM equivalent to the
following three computations.
 
Halts(main()) is called thus deciding infinite recursion of all three of
these computations:
 
int main()
{
HERE: goto HERE;
}
 
This is a simplified version of the infinite recursion detector that I
designed two years ago (Hopefully this one is not over Mike's head):
 
This is my 2018-12-13 solution: Every time the same function is called a
second time from the same machine address with no control flow
instructions** in-between we can know that this is definitely infinite
recursion.
 
** A simplification of the original criteria to make my proof easier to
understand.
 
int main()
{
Halts(Confound_Halts, Confound_Halts);
}
 
This one is provided with a full execution trace:
 
int main()
{
Confound_Halts((u32)Confound_Halts);
HALT;
}
 
_Confound_Halts()
[000005e0](01) 55 push ebp
[000005e1](02) 8bec mov ebp,esp
[000005e3](03) 8b4508 mov eax,[ebp+08]
[000005e6](01) 50 push eax
[000005e7](03) 8b4d08 mov ecx,[ebp+08]
[000005ea](01) 51 push ecx
[000005eb](05) e880fdffff call 00000370
[000005f0](03) 83c408 add esp,+08
[000005f3](02) 85c0 test eax,eax
[000005f5](02) 740b jz 00000602
[000005f7](05) ba01000000 mov edx,00000001
[000005fc](02) 85d2 test edx,edx
[000005fe](02) 7402 jz 00000602
[00000600](02) ebf5 jmp 000005f7
[00000602](01) 5d pop ebp
[00000603](01) c3 ret
 
_main()
[00000610](01) 55 push ebp
[00000611](02) 8bec mov ebp,esp
[00000613](05) 68e0050000 push 000005e0
[00000618](05) e8c3ffffff call 000005e0
[0000061d](03) 83c404 add esp,+04
[00000620](01) f4 hlt
[00000621](01) 5d pop ebp
[00000622](01) c3 ret
 
Output_Debug_Trace() Trace_List.size(17)
[00000610](01) EMU_Level(0) 55 push ebp
[00000611](02) EMU_Level(0) 8bec mov ebp,esp
[00000613](05) EMU_Level(0) 68e0050000 push 000005e0
[00000618](05) EMU_Level(0) e8c3ffffff call 000005e0
----CALL [000005e0]
[000005e0](01) EMU_Level(0) 55 push ebp
[000005e1](02) EMU_Level(0) 8bec mov ebp,esp
[000005e3](03) EMU_Level(0) 8b4508 mov eax,[ebp+08]
[000005e6](01) EMU_Level(0) 50 push eax
[000005e7](03) EMU_Level(0) 8b4d08 mov ecx,[ebp+08]
[000005ea](01) EMU_Level(0) 51 push ecx
[000005eb](05) EMU_Level(0) e880fdffff call 00000370
----CALL [00000370]
[000005e0](01) EMU_Level(1) 55 push ebp
[000005e1](02) EMU_Level(1) 8bec mov ebp,esp
[000005e3](03) EMU_Level(1) 8b4508 mov eax,[ebp+08]
[000005e6](01) EMU_Level(1) 50 push eax
[000005e7](03) EMU_Level(1) 8b4d08 mov ecx,[ebp+08]
[000005ea](01) EMU_Level(1) 51 push ecx
[000005eb](05) EMU_Level(1) e880fdffff call 00000370
----CALL [00000370]
The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
 
 
 
 
--
Copyright 2020 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
"Rick C. Hodgin" <rick.c.hodgin@gmail.com>: Dec 05 06:09PM -0500

On 12/5/20 3:53 PM, Mr Flibble wrote:
>> Would you help me with some Open GL questions, Leigh?
 
> Only if you renounce Christian ..tardary and stop spamming this
> newsgroup with same.
 
Do you realize that you spam this newsgroup with your obscene version of
atheism? How do you think the people here feel about you writing
consistently with such vulgarity?
 
I will say this: I love you, Leigh. Jesus loves you. You are loved.
 
--
Rick C. Hodgin
Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk>: Dec 05 08:53PM

On 05/12/2020 17:36, Rick C. Hodgin wrote:
 
> Would you help me with some Open GL questions, Leigh?
 
> I am working on an Open GL project, and you have solved one of the issues I have in my project.
 
> I could benefit from your superior coding knowledge.
 
Only if you renounce Christian fucktardary and stop spamming this newsgroup with same.
 
/Flibble
 
--
😎
Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk>: Dec 05 04:19PM

Hi!
 
neoGFX (C++) Design Studio Demo (Widget Selection / Positioning - Dark Theme / Default Font):
 
https://www.youtube.com/watch?v=blJRkEGcEkk
 
/Flibble
 
--
😎
Vir Campestris <vir.campestris@invalid.invalid>: Dec 04 08:59PM

On 02/12/2020 18:14, Bonita Montero wrote:
>    descendants and not convertible classes.
> 2. With external operators you can attach semantics to a class like
>    if you would have defined a member-operator.
 
Yes, but why?
 
I want to have operators for internal data types within a class whose
behaviour varies depending on the class.
 
Andy
Vir Campestris <vir.campestris@invalid.invalid>: Dec 02 05:57PM

On 01/12/2020 14:24, Bo Persson wrote:
> So if you write a member operator<< with two other parameter types, the
> compiler will treat it as having 3 parameters.
 
... and then refuse to compile it because it is only allowed to have two
parameters, not three :(
 
You can't even make it a static member.
 
Andy
"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>: Dec 08 06:15PM -0800

On 12/7/2020 10:36 PM, Bonita Montero wrote:
>>> No, shared_ptr isn't expensive.
 
>> Ummm.... atomic RMW's and memory barriers are expensive.
 
> 20 cycles on my computer - that's nothing
 
That is a rather naive statement. Humm... Why do you think split
counters were invented? Why do you think RCU was invented? Well, to get
rid of atomic RMW's and memory barriers. ;^)
Bonita Montero <Bonita.Montero@gmail.com>: Dec 06 07:40PM +0100

>> So this way everything is o.k.:
 
> May be. Why you have those shared_ptrs instead of having
> deque<void_task> directly.
 
I don't want to move the task-parameters.
olcott <NoOne@NoWhere.com>: Dec 08 08:41PM -0600

On 12/8/2020 7:28 PM, Ben Bacarisse wrote:
> fails to meet the specification.
 
> I see you have some new friends to talk to about this stuff. You don't
> need me anymore.
 
You disparaged my work using dishonesty and subterfuge.
This is NOT a finite computation:
 
void Confound_Halts(u32 P)
{
if (Halts(P, P))
while (1);
}
 
int main()
{
Confound_Halts((u32)Confound_Halts);
HALT;
}
 
It is aborted according to this criteria:
 
On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
> A computation that would not halt if its simulation were not
> halted is indeed a non-halting computation.
 
On Saturday, November 28, 2020 at 2:00:28 PM UTC-8, olcott wrote:
> Every computation that would not halt if its simulation
> were not halted is by logical necessity a non-halting computation.
 
_Confound_Halts()
[0000063c](01) 55 push ebp
[0000063d](02) 8bec mov ebp,esp
[0000063f](03) 8b4508 mov eax,[ebp+08]
[00000642](01) 50 push eax
[00000643](03) 8b4d08 mov ecx,[ebp+08]
[00000646](01) 51 push ecx
[00000647](05) e800feffff call 0000044c
[0000064c](03) 83c408 add esp,+08
[0000064f](02) 85c0 test eax,eax
[00000651](02) 740b jz 0000065e
[00000653](05) ba01000000 mov edx,00000001
[00000658](02) 85d2 test edx,edx
[0000065a](02) 7402 jz 0000065e
[0000065c](02) ebf5 jmp 00000653
[0000065e](01) 5d pop ebp
[0000065f](01) c3 ret
 
_main()
[0000066c](01) 55 push ebp
[0000066d](02) 8bec mov ebp,esp
[0000066f](05) 683c060000 push 0000063c
[00000674](05) e8c3ffffff call 0000063c
[00000679](03) 83c404 add esp,+04
[0000067c](01) f4 hlt
[0000067d](01) 5d pop ebp
[0000067e](01) c3 ret
 
Output_Debug_Trace() Trace_List.size(17)
[0000066c](01) 55 push ebp
[0000066d](02) 8bec mov ebp,esp
[0000066f](05) 683c060000 push 0000063c
[00000674](05) e8c3ffffff call 0000063c // CALL
Confound_Halts()
[0000063c](01) 55 push ebp
[0000063d](02) 8bec mov ebp,esp
[0000063f](03) 8b4508 mov eax,[ebp+08]
[00000642](01) 50 push eax
[00000643](03) 8b4d08 mov ecx,[ebp+08]
[00000646](01) 51 push ecx
[00000647](05) e800feffff call 0000044c // CALL Halts()
[0000063c](01) 55 push ebp
[0000063d](02) 8bec mov ebp,esp
[0000063f](03) 8b4508 mov eax,[ebp+08]
[00000642](01) 50 push eax
[00000643](03) 8b4d08 mov ecx,[ebp+08]
[00000646](01) 51 push ecx
[00000647](05) e800feffff call 0000044c // CALL Halts()
The PRIOR Instruction Specifies Infinite Recursion: Simulation Stopped:
 
 
 
--
Copyright 2020 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
olcott <NoOne@NoWhere.com>: Dec 08 09:56PM -0600

On 12/8/2020 9:28 PM, Ben Bacarisse wrote:
>>> A computation that would not halt if its simulation were not
>>> halted is indeed a non-halting computation.
 
> There is no simulator in your example.
 
The example was executed by a simulator as I have said many hundreds of
times in the last few weeks.
 
> The simulation of a non-halting
> computation does not halt, and the simulation of a halting one does not
> need to be aborted.
 
It is a simulation that [would not halt if its simulation was not
halted] thus providing the simulator its criterion measure to stop
simulating this otherwise infinite computation and decide not halting.
 
 
 
--
Copyright 2020 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
olcott <NoOne@NoWhere.com>: Dec 03 12:32PM -0600

On 12/3/2020 12:18 PM, Kaz Kylheku wrote:
> is on you to hunt down the specific pieces literature that you wish to
> target, read all of them, and determine what issues are present in which
> piece.
 
It seems then that your assessment of the significance of my work is
based on "shooting from the hip" rather any degree of academic rigor.
 
At least (unlike everyone else) when a clear proof is presented you give
a straight up honest assessment and do not resort to any degree of
dishonestly and subterfuge.
 
I really really, appreciate that. Your review was the threshold that I
was waiting for before I move on to the next level of review. I had to
make sure that my words could be understood before I could proceed.
 
I did apparently at least correctly refute the Linz proof. That by
itself would qualify for publication somewhere.
 
Dishonesty and subterfuge:
Ben even claimed that the difference between two literally identical
programs was so great that it is dishonest of me to call them by the
same name.
 
On 11/30/2020 7:40 PM, Ben Bacarisse wrote:
> void Confound_Halts(u32 P) { if (Halts(P, P)) while (1); }
 
void Confound_Halts(u32 P)
{
if (DebugTrace(P, P))
while (1);
}
 
On 12/2/2020 8:15 PM, Ben Bacarisse wrote:
 
--
Copyright 2020 Pete Olcott
 
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
Brian Wood <woodbrian77@gmail.com>: Dec 08 06:58PM -0800

On Friday, November 27, 2020 at 1:59:14 AM UTC-6, Öö Tiib wrote:
> people can choose one or other.
 
> You are pushing questionable properties like some
> kind of online code generator used ...
 
Services are here to stay. Code generators are here
to stay. My software could be much better than it
already is if the community admitted this 10 years ago.
 
 
Brian
Ebenezer Enterprises
https://github.com/Ebenezer-group/onwards
"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>: Dec 05 11:40PM -0800

On 12/5/2020 9:41 PM, Rick C. Hodgin wrote:
> make it happen, so I'm asking for help.
 
> I asked previously on the comp.graphics.algorithms group:
 
>     https://groups.google.com/g/comp.graphics.algorithms/c/6g61QzuLRHk
 
https://software.intel.com/content/www/us/en/develop/articles/dynamic-resolution-rendering-on-opengl-es-2.html
Brian Wood <woodbrian77@gmail.com>: Dec 08 04:33PM -0800

On Friday, December 4, 2020 at 5:26:23 PM UTC-6, Öö Tiib wrote:
 
> > Does it look like an improvement? Tia.
> Yes. There are no placement new that you originally asked about
> so problem solved?
 
There's one placement new left and it's a pain to
get rid of. Undoubtedly, some won't like my latest
commit, where I ditch unique_ptr:
 
https://github.com/Ebenezer-group/onwards/commit/c08c0fce367dc01462b5a16d7799b6ecff5f3393
 
But it allows me to not include <memory> and the binary is
over 1% smaller as a result.
 
 
> You seem to indent some lines with tabs and some lines with
> spaces. That sometimes makes code to look odd in some tools
> but if you do not use such tools then it does not matter.
 
The tabs were a mistake. I've removed them now.
 
 
Brian
Ebenezer Enterprises
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)