On 2/5/2024 9:29 PM, Physfitfreak wrote:

> No.
>
> You must understand the problem first. Any code monkey has good reading
> comprehension, otherwise they're just useless cause they won't know what
> it is that the employer wants them to do.

I think this is what you're looking for.

For any non-pawn piece, starting at any position on the board, it shows
2 values:
* the longest single move available
* the sum of all the squares covered by all available moves

This board is helpful to look at when trying the program:
https://en.wikipedia.org/wiki/Algebraic_notation_(chess)#/media/File:SCD_algebraic_notation.svg

You know how to compile and run it, right?

======================================================================

//This program determines the max number of squares 2 random non-pawn
chess pieces can
//possibly cover with one move each, and with all available moves, from
any random
//starting position on the board.
//Code assumes one piece cannot block the other.

//This code is hereby donated to the public domain

//usage:
//$ ./prog <leave blank and system will generate 2 random pieces>
// or
//$ ./prog <piece1> <piece2> no brackets
//$ ./prog Qe6 Ka1

//pieces and starting position must be entered using standard
// chess algebraic notation: Ba3 Kg1 Ne8 etc
//pieces : K king, Q queen, R rook, B bishop, N knight
//columns: abcdefgh
//rows : 1-8

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

//K king, Q queen, R rook, B bishop, N knight
char *pieces[] = {"K","Q","R","B","N"};
char *pieceslong[] = {"King","Queen","Rook","Bishop","Knight"};

//build random piece and starting position
//column,row is converted to algebraic notation
char *genpiece(char newpiece[])
{ char piece[2], col[2];
sprintf(piece,"%s",pieces[rand() % 5]);
sprintf(col,"%c",(rand() % 8) + 97);
int row = (rand() % 8) + 1;
sprintf(newpiece,"%s%s%d",piece,col,row);
}

//find largest value
int getmax(int a, int b, int c, int d)
{ int max = 0;
if (a > max) {max = a;}
if (b > max) {max = b;}
if (c > max) {max = c;}
if (d > max) {max = d;}
return max;
}

//find smallest value
int getmin(int a, int b, int c, int d)
{ int min = 9;
if (a < min) {min = a;}
if (b < min) {min = b;}
if (c < min) {min = c;}
if (d < min) {min = d;}
return min;
}

// determine max number of squares that can be moved from the starting
position
int calcsquares(char piece[], char *cntmoves) {

//cntmoves flag:
// 'one' means piece can make only 1 move - find max squares covered
// 'all' means piece can make all possible moves - sum them all

//min and max square moves by piece
//king 1,1
//queen 1,7
//rook 1,7
//bishop 1,7
//knight 3,3

int squares = 0;

//convert algebraic notation to col,row
//a1 = col 1,row 1 white, bottom left
//h8 = col 8,row 8 black, top right
int pcol = piece[1]-96;
int prow = atoi(&piece[2]);

//left and right edges of board are 1 and 8
//bottom and top of board are 1 and 8

//kings and knights will always be able to make at least one move of
//1 and 3 squares respectively, no matter the starting position
if (cntmoves == "one")
{
if (piece[0] == 'K') { squares += 1; }
if (piece[0] == 'N') { squares += 3; }
}
if (cntmoves == "all")
{
//king
if (piece[0] == 'K')
{
//positioned in a corner (3 moves of 1 square each)
if (pcol==1 && prow==1) {squares += 3;}
if (pcol==1 && prow==8) {squares += 3;}
if (pcol==8 && prow==1) {squares += 3;}
if (pcol==8 && prow==8) {squares += 3;}

//positioned along an edge but not in a corner (5 moves of 1
square each)
if (pcol==1 && prow>1 && prow<8) {squares += 5;}
if (pcol==8 && prow>1 && prow<8) {squares += 5;}
if (prow==1 && pcol>1 && pcol<8) {squares += 5;}
if (prow==8 && pcol>1 && pcol<8) {squares += 5;}

//positioned at least one square inside all edges (8 moves of 1
square each)
if (pcol>1 && prow>1 && pcol<8 && prow<8) {squares += 8;}
}

//knight
if (piece[0] == 'N')
{
//positioned in a corner (2 moves of 3 squares each)
if (pcol==1 && prow==1) {squares += 6;}
if (pcol==1 && prow==8) {squares += 6;}
if (pcol==8 && prow==1) {squares += 6;}
if (pcol==8 && prow==8) {squares += 6;}

//positioned along an edge but not in a corner (3 moves of 3
squares each)
if (pcol==1 && prow>1 && prow<8) {squares += 9;}
if (pcol==8 && prow>1 && prow<8) {squares += 9;}
if (prow==1 && pcol>1 && pcol<8) {squares += 9;}
if (prow==8 && pcol>1 && pcol<8) {squares += 9;}

//positioned one square in from a corner (4 moves of 3 squares
each)
if (pcol==2 && prow==2) {squares += 12;}
if (pcol==2 && prow==7) {squares += 12;}
if (pcol==7 && prow==2) {squares += 12;}
if (pcol==7 && prow==7) {squares += 12;}

//positioned one square in from an edge, rows 3-6 or cols 3-6
//(6 moves of 3 squares each)
if (pcol==2 && prow>2 && prow<7) {squares += 18;}
if (pcol==7 && prow>2 && prow<7) {squares += 18;}
if (prow==2 && pcol>2 && pcol<7) {squares += 18;}
if (prow==7 && pcol>2 && pcol<7) {squares += 18;}

//positioned at least two squares inside all edges (8 moves of 3
squares each)
if (pcol>2 && prow>2 && pcol<7 && prow<7) {squares += 24;}
}
}

//rooks and queens move on rows or columns (left, right, forward,
backward)
int l=0,r=0,f=0,b=0;
if (piece[0] == 'R' || piece[0] == 'Q')
{
l = pcol - 1;
r = 8 - pcol;
f = 8 - prow;
b = prow - 1;
if (cntmoves == "one")
{ squares += getmax(l,r,f,b); }

if (cntmoves == "all")
{ squares += (l + r + f + b); }

//printf("%s: left %d, right %d, fwd %d, bwd %d
max=%d\n",piece,l,r,f,b,getmax(l,r,f,b));
}

//bishops and queens move on diagonals (down left, down right, up
left, up right)
//but don't use the diagonal moves when searching for the Queen's
longest single move - //that's accounted for in the previous section
(left,right,forward,backward)

//https://www.geeksforgeeks.org/count-the-total-number-of-squares-that-can-be-visited-by-bishop-in-one-move/
//hack: 99 and -99 are used just to send 4 args to the min/max functions
int dl=0, dr=0, ul=0, ur=0;
if (piece[0] == 'B' || piece[0] == 'Q')
{
dl = 8 - getmax(prow, 9-pcol, -99, -99);
dr = getmin(prow, 9-pcol, 99, 99) -1;
ul = getmin(prow, pcol, 99, 99) - 1;
ur = 8 - getmax(prow, pcol, -99, -99);
if (cntmoves == "one" && piece[0] == 'B')
{ squares += getmax(dl,dr,ul,ur); }
if (cntmoves == "all")
{ squares += (dl + dr + ul + ur); }

//printf("%s: down left %d, down right %d, up left %d, up right %d
max=%d\n",piece,dl,dr,ul,ur,getmax(dl,dr,ul,ur));
}

return squares;

}

int main(int argc, char *argv[]) {
//TODO maybe:
// 1. handle piece blocking
// 2. allow 3+ pieces using an array
// 3. capture and display ending position

//random
srand(time(NULL));

//pieces
char p1[4], p2[4];

//no input from user, so system generates 2 random pieces
if (argc == 1)
{ genpiece(p1);
genpiece(p2);
while (strcmp(p1,p2)==0) { genpiece(p2); } //ensure 2 different pieces
}

//invalid entry
if ((argc == 2) || (argc > 3))
{ printf("Enter 2 valid pieces\n");
exit(0);
}
//user inputs
if (argc == 3)
{ sprintf(p1,"%s",argv[1]);
sprintf(p2,"%s",argv[2]);
if (strcmp(p1,p2)==0)
{ printf("You entered 2 of the same piece \n");
exit(0);
}
}

//pieces and algebraic notation must be len(3)
if (strlen(p1)!=3 || strlen(p2)!=3)
{ printf("Enter 2 valid pieces\n");
exit(0);
}

//calc max squares moved per piece
int p1one = calcsquares(p1,"one");
int p1all = calcsquares(p1,"all");
int p2one = calcsquares(p2,"one");
int p2all = calcsquares(p2,"all");

On 2/6/2024 12:06 AM, DFS wrote:
> On 2/5/2024 9:29 PM, Physfitfreak wrote:
>
>
>> No.
>>
>> You must understand the problem first. Any code monkey has good
>> reading comprehension, otherwise they're just useless cause they won't
>> know what it is that the employer wants them to do.
>
>
> I think this is what you're looking for.
>
> For any non-pawn piece, starting at any position on the board, it shows
> 2 values:
> * the longest single move available
> * the sum of all the squares covered by all available moves
>
> This board is helpful to look at when trying the program:
> https://en.wikipedia.org/wiki/Algebraic_notation_(chess)#/media/File:SCD_algebraic_notation.svg

You want to see real chess software?

https://stockfishchess.org
https://en.wikipedia.org/wiki/Stockfish_(chess)

It's GPL3 licensed, command line, and the strongest computer chess
engine in the world.

The C++ code is only 622KB.

On Tue, 6 Feb 2024 09:15:54 -0500, DFS <nospam@dfs.com> wrote in
<sarwN.44027$9cLc.38825@fx02.iad>:

> On 2/6/2024 12:06 AM, DFS wrote:
>> On 2/5/2024 9:29 PM, Physfitfreak wrote:
>>
>>
>>> No.
>>>
>>> You must understand the problem first. Any code monkey has good
>>> reading comprehension, otherwise they're just useless cause they won't
>>> know what it is that the employer wants them to do.
>>
>>
>> I think this is what you're looking for.
>>
>> For any non-pawn piece, starting at any position on the board, it shows
>> 2 values:
>> * the longest single move available
>> * the sum of all the squares covered by all available moves
>>
>> This board is helpful to look at when trying the program:
>> https://en.wikipedia.org/wiki/Algebraic_notation_(chess)#/media/File:SCD_algebraic_notation.svg
>
>
> You want to see real chess software?
>
> https://stockfishchess.org
> https://en.wikipedia.org/wiki/Stockfish_(chess)
>
> It's GPL3 licensed, command line, and the strongest computer chess
> engine in the world.
>
> The C++ code is only 622KB.

That's what Relf used when we had our chess game a while back.
It's not bad.

--
-v

On Mon, 5 Feb 2024 19:39:57 -0600, Physfitfreak wrote:

>
> If the drone calculated coordinates of the two points on that line of
> sight as (x_1, y_1) and (x_2, y_2), with x being the distance and y the
> height, then the distance of the target to launch area would have any of
> the two forms below:
>
> x . y - x . y
> 1 2 2 1
> x = -----------------
> y - y
> 2 1
>
> or:
>
>
> /x - x \ . y
> \ 2 1/ 1
> x = x - --------------
> 1 y - y
> 2 1
>
>
> And the Americans in charge being cro-magnons (and Nazi), seeing that
> one of the above formulas can be derived from the other one, were
> assuming it didn't matter which one to use for calculating x-intercept
> for their missiles to hit Houthis targets. But Houthis, being Modern
> Humans, always chose one of the above, and never the other.
>
> So Physfit found out why about half of American missiles narrowly miss
> their targets, while Houthis missiles always hit the targets.
>
> 1- Verify that the two formulas are correct, and algebraically related.
>
> 2- Assuming the drone calculated (x_1, y_1) as (1.31, 4.76) kilometers,
> and (x_2, y_2) as (1.93, 3.24) kilometers, and assuming that for
> shortest computation time, numbers are rounded to three digits in the
> codes imbedded in drones and missiles, then calculate the x-intercept in
> both ways.
>
> 3- Explain which of the two methods is being used by the Houthis, and why.
>

1)

Multiply first term of second expression by 1 = (y2 - y1)/(y2 - y1):

x1 ⋅ (y2 - y1) (x2 - x1) ⋅ y1
────────────── - ──────────────
y2 - y1 y2 - y1

Combine fractions:

x1 ⋅ y2 - x1 ⋅ y1 - x2 ⋅ y1 + x1 ⋅ y1
─────────────────────────────────────
y2 - y1

Cancel terms:

x1 ⋅ y2 - x2 ⋅ y1
─────────────────
y2 - y1

They are equivalent.

2)

Using exact rational arithmetic based on the values given
(e.g. 1.31 = 131/100), the x-intercept for both expressions
is:

x = 3089/950 = 3.25

For an image of this, see this link:

https://postimg.cc/2LS0KRHr

3)

Because of potential catastrophic cancellation in distance coordinates,
the first expression is preferable due to the absence of subtraction
(i.e. x2 - x1) in the numerator. For the record:

x1 ⋅ y2 - x2 ⋅ y1
─────────────────
y2 - y1

On 2/6/2024 3:00 PM, Farley Flud wrote:
> On Mon, 5 Feb 2024 19:39:57 -0600, Physfitfreak wrote:
>
>>
>> If the drone calculated coordinates of the two points on that line of
>> sight as (x_1, y_1) and (x_2, y_2), with x being the distance and y the
>> height, then the distance of the target to launch area would have any of
>> the two forms below:
>>
>> x . y - x . y
>> 1 2 2 1
>> x = -----------------
>> y - y
>> 2 1
>>
>> or:
>>
>>
>> /x - x \ . y
>> \ 2 1/ 1
>> x = x - --------------
>> 1 y - y
>> 2 1
>>
>>
>> And the Americans in charge being cro-magnons (and Nazi), seeing that
>> one of the above formulas can be derived from the other one, were
>> assuming it didn't matter which one to use for calculating x-intercept
>> for their missiles to hit Houthis targets. But Houthis, being Modern
>> Humans, always chose one of the above, and never the other.
>>
>> So Physfit found out why about half of American missiles narrowly miss
>> their targets, while Houthis missiles always hit the targets.
>>
>> 1- Verify that the two formulas are correct, and algebraically related.
>>
>> 2- Assuming the drone calculated (x_1, y_1) as (1.31, 4.76) kilometers,
>> and (x_2, y_2) as (1.93, 3.24) kilometers, and assuming that for
>> shortest computation time, numbers are rounded to three digits in the
>> codes imbedded in drones and missiles, then calculate the x-intercept in
>> both ways.
>>
>> 3- Explain which of the two methods is being used by the Houthis, and why.
>>
>
> 1)
>
> Multiply first term of second expression by 1 = (y2 - y1)/(y2 - y1):
>
> x1 ⋅ (y2 - y1) (x2 - x1) ⋅ y1
> ────────────── - ──────────────
> y2 - y1 y2 - y1
>
>
> Combine fractions:
>
> x1 ⋅ y2 - x1 ⋅ y1 - x2 ⋅ y1 + x1 ⋅ y1
> ─────────────────────────────────────
> y2 - y1
>
> Cancel terms:
>
> x1 ⋅ y2 - x2 ⋅ y1
> ─────────────────
> y2 - y1
>
>
> They are equivalent.
>
>
> 2)
>
> Using exact rational arithmetic based on the values given
> (e.g. 1.31 = 131/100), the x-intercept for both expressions
> is:
>
> x = 3089/950 = 3.25
>
> For an image of this, see this link:
>
> https://postimg.cc/2LS0KRHr
>
>
> 3)
>
> Because of potential catastrophic cancellation in distance coordinates,
> the first expression is preferable due to the absence of subtraction
> (i.e. x2 - x1) in the numerator. For the record:
>
> x1 ⋅ y2 - x2 ⋅ y1
> ─────────────────
> y2 - y1
>
>

Hmm... But you need to show with actual numbers why in the 3rd part, one
of the expressions is better to use.

Put yourself in the shoes of a computer (inside the drones and missiles)
that rounds every number off (not just the result! But every number it
comes upon in computing the results) to keep only three significant
digits. Follow what happens from begin to end of the computation for
each expression. Then argue why one computed result is better than the
other computed result. Lot's of math lines to write, but all are needed
to see for sure why one result is better than the other.

I may have accidentally chosen the coordinate numbers that don't quite
show the difference, I don't know. I haven't solved this yet (just
concocted it last night). If that's the case, then I'll find coordinate
numbers that will show the difference.

But so far, I'm assuming just about any coordinates measured might work
to show the difference in the results of computations. So I'm asking
that you do that and show it here.

On 2/6/2024 3:43 PM, Physfitfreak wrote:
> On 2/6/2024 3:00 PM, Farley Flud wrote:
>> On Mon, 5 Feb 2024 19:39:57 -0600, Physfitfreak wrote:
>>
>>>
>
> Put yourself in the shoes of a computer (inside the drones and missiles)
> that rounds every number off (not just the result! But every number it
> comes upon in computing the results) to keep only three significant
> digits. Follow what happens from begin to end of the computation for
> each expression. Then argue why one computed result is better than the
> other computed result. Lot's of math lines to write, but all are needed
> to see for sure why one result is better than the other.
>
> I may have accidentally chosen the coordinate numbers that don't quite
> show the difference, I don't know. I haven't solved this yet (just
> concocted it last night). If that's the case, then I'll find coordinate
> numbers that will show the difference.
>
> But so far, I'm assuming just about any coordinates measured might work
> to show the difference in the results of computations. So I'm asking
> that you do that and show it here.
>
>
>

I shouldn't have said, "three significant digits". Significant digit
concept is somewhat different.

Ok, let's talk more accurately.

Machine numbers are in binary form. But these machine numbers can be
expressed in decimal machine numbers like:

0.d_1d_2 ... d_k x 10^n

, where d_1 digit is _not_ zero, and d_2, d_3 ... d_k digits can each be
an integer from zero to 9.

Since this example has k digits after the decimal point, it is called
k-digit decimal machine number.

The decimal machine number form is not exactly equal to the binary form
that machine handles, and the difference has to do with the machine
epsilon. But nevertheless, the two form are very closely the same number.

In this problem, I'm assuming the computers on missiles work on such
binary numbers that have 3-digit decimal machine numbers. And forget the
binary form of them, cause this problem is not about the machine
epsilon. Just assume that the computers deal with decimal machine
numbers and k=3. So for example the number

0.0033169 x 10^4

is rounded off to

0.332 x 10^2

So depending on how your code computes the two given expressons, any
time the computer handles a number, if it is not already in 3-digit
decimal machine number form, it converts it to 3-digit machine number
before using it for computations.

On 2/6/2024 3:00 PM, Farley Flud wrote:
> On Mon, 5 Feb 2024 19:39:57 -0600, Physfitfreak wrote:
>
>>
>> If the drone calculated coordinates of the two points on that line of
>> sight as (x_1, y_1) and (x_2, y_2), with x being the distance and y the
>> height, then the distance of the target to launch area would have any of
>> the two forms below:
>>
>> x . y - x . y
>> 1 2 2 1
>> x = -----------------
>> y - y
>> 2 1
>>
>> or:
>>
>>
>> /x - x \ . y
>> \ 2 1/ 1
>> x = x - --------------
>> 1 y - y
>> 2 1
>>
>>
>> And the Americans in charge being cro-magnons (and Nazi), seeing that
>> one of the above formulas can be derived from the other one, were
>> assuming it didn't matter which one to use for calculating x-intercept
>> for their missiles to hit Houthis targets. But Houthis, being Modern
>> Humans, always chose one of the above, and never the other.
>>
>> So Physfit found out why about half of American missiles narrowly miss
>> their targets, while Houthis missiles always hit the targets.
>>
>> 1- Verify that the two formulas are correct, and algebraically related.
>>
>> 2- Assuming the drone calculated (x_1, y_1) as (1.31, 4.76) kilometers,
>> and (x_2, y_2) as (1.93, 3.24) kilometers, and assuming that for
>> shortest computation time, numbers are rounded to three digits in the
>> codes imbedded in drones and missiles, then calculate the x-intercept in
>> both ways.
>>
>> 3- Explain which of the two methods is being used by the Houthis, and why.
>>
>
> 1)
>
> Multiply first term of second expression by 1 = (y2 - y1)/(y2 - y1):
>
> x1 ⋅ (y2 - y1) (x2 - x1) ⋅ y1
> ────────────── - ──────────────
> y2 - y1 y2 - y1
>
>
> Combine fractions:
>
> x1 ⋅ y2 - x1 ⋅ y1 - x2 ⋅ y1 + x1 ⋅ y1
> ─────────────────────────────────────
> y2 - y1
>
> Cancel terms:
>
> x1 ⋅ y2 - x2 ⋅ y1
> ─────────────────
> y2 - y1
>
>
> They are equivalent.
>
>
> 2)
>
> Using exact rational arithmetic based on the values given
> (e.g. 1.31 = 131/100), the x-intercept for both expressions
> is:
>
> x = 3089/950 = 3.25
>
> For an image of this, see this link:
>
> https://postimg.cc/2LS0KRHr
>
>
> 3)
>
> Because of potential catastrophic cancellation in distance coordinates,
> the first expression is preferable due to the absence of subtraction
> (i.e. x2 - x1) in the numerator. For the record:
>
> x1 ⋅ y2 - x2 ⋅ y1
> ─────────────────
> y2 - y1
>
>

Your reasoning is correct of course, but if you had numerically
calculated the relative errors and compared them to each other, it would
be more convincing.

The second expression, as you said, has a potential problem. If the
drone when recording its own coordinates two times, is very far from the
launch site, then x_1 and x_2 will be represented in 3-digit decimal
machine numbers by two numbers very close to each other, and their
difference when rounded produces a number with lower than 3 significant
digits. If we calculate the relative error compared to case of using
exact numbers (no rounding off), we see that it is much larger than same
relative errors for closer distances to launch site.

So, subtracting two large numbers that are very close to each other is
like asking for failure if you have it done by a machine.

But using the first expression, the closeness of the numbers x_1 and x_2
gets to a good degree ineffective because each is multiplied by the
other point's associated height _before_ subtraction is performed. So,
the difference between first and second terms in the numerator gets much
larger, causing it to lose fewer significant digits when rounded.

That's why Houthis kicked ass :-)

On 2/6/2024 9:55 PM, Physfitfreak wrote:
> On 2/6/2024 3:00 PM, Farley Flud wrote:
>> On Mon, 5 Feb 2024 19:39:57 -0600, Physfitfreak wrote:
>>
>>>
>>> If the drone calculated coordinates of the two points on that line of
>>> sight as (x_1, y_1) and (x_2, y_2), with x being the distance and y the
>>> height, then the distance of the target to launch area would have any of
>>> the two forms below:
>>>
>>>       x  . y  - x  . y
>>>        1    2    2    1
>>> x = -----------------
>>>            y  - y
>>>             2    1
>>>
>>> or:
>>>
>>>
>>>            /x  - x \ . y
>>>            \ 2    1/    1
>>> x = x  - --------------
>>>        1       y  - y
>>>                 2    1
>>>
>>>
>>> And the Americans in charge being cro-magnons (and Nazi), seeing that
>>> one of the above formulas can be derived from the other one, were
>>> assuming it didn't matter which one to use for calculating x-intercept
>>> for their missiles to hit Houthis targets. But Houthis, being Modern
>>> Humans, always chose one of the above, and never the other.
>>>
>>> So Physfit found out why about half of American missiles narrowly miss
>>> their targets, while Houthis missiles always hit the targets.
>>>
>>> 1- Verify that the two formulas are correct, and algebraically related.
>>>
>>> 2- Assuming the drone calculated (x_1, y_1) as (1.31, 4.76) kilometers,
>>> and (x_2, y_2) as (1.93, 3.24) kilometers, and assuming that for
>>> shortest computation time, numbers are rounded to three digits in the
>>> codes imbedded in drones and missiles, then calculate the x-intercept in
>>> both ways.
>>>
>>> 3- Explain which of the two methods is being used by the Houthis, and
>>> why.
>>>
>>
>> 1)
>>
>> Multiply first term of second expression by 1 = (y2 - y1)/(y2 - y1):
>>
>> x1 ⋅ (y2 - y1)   (x2 - x1) ⋅ y1
>> ────────────── - ──────────────
>>      y2 - y1          y2 - y1
>>
>>
>> Combine fractions:
>>
>> x1 ⋅ y2 - x1 ⋅ y1 - x2 ⋅ y1 + x1 ⋅ y1
>> ─────────────────────────────────────
>>                 y2 - y1
>>
>> Cancel terms:
>>
>> x1 ⋅ y2 - x2 ⋅ y1
>> ─────────────────
>>       y2 - y1
>>
>>
>> They are equivalent.
>>
>>
>> 2)
>>
>> Using exact rational arithmetic based on the values given
>> (e.g. 1.31 = 131/100), the x-intercept for both expressions
>> is:
>>
>> x = 3089/950 = 3.25
>>
>> For an image of this, see this link:
>>
>> https://postimg.cc/2LS0KRHr
>>
>>
>> 3)
>>
>> Because of potential catastrophic cancellation in distance coordinates,
>> the first expression is preferable due to the absence of subtraction
>> (i.e. x2 - x1) in the numerator.  For the record:
>>
>> x1 ⋅ y2 - x2 ⋅ y1
>> ─────────────────
>>       y2 - y1
>>
>>
>
>
> Your reasoning is correct of course, but if you had numerically
> calculated the relative errors and compared them to each other, it would
> be more convincing.
>
> The second expression, as you said, has a potential problem. If the
> drone when recording its own coordinates two times, is very far from the
> launch site, then x_1 and x_2 will be represented in 3-digit decimal
> machine numbers by two numbers very close to each other, and their
> difference when rounded produces a number with lower than 3 significant
> digits. If we calculate the relative error compared to case of using
> exact numbers (no rounding off), we see that it is much larger than same
> relative errors for closer distances to launch site.
>
> So, subtracting two large numbers that are very close to each other is
> like asking for failure if you have it done by a machine.
>
> But using the first expression, the closeness of the numbers x_1 and x_2
> gets to a good degree ineffective because each is multiplied by the
> other point's associated height _before_ subtraction is performed. So,
> the difference between first and second terms in the numerator gets much
> larger, causing it to lose fewer significant digits when rounded.
>
> That's why Houthis kicked ass :-)
>
>
>
>

The error in computation of second expression is bad enough when two
large and very close numbers are subtracted. In this particular case
this error is yet magnified by a factor of y_1 ... making it much larger.

On 2/6/2024 3:29 PM, vallor wrote:
> On Tue, 6 Feb 2024 09:15:54 -0500, DFS <nospam@dfs.com> wrote in
> <sarwN.44027$9cLc.38825@fx02.iad>:
>
>> On 2/6/2024 12:06 AM, DFS wrote:
>>> On 2/5/2024 9:29 PM, Physfitfreak wrote:
>>>
>>>
>>>> No.
>>>>
>>>> You must understand the problem first. Any code monkey has good
>>>> reading comprehension, otherwise they're just useless cause they won't
>>>> know what it is that the employer wants them to do.
>>>
>>>
>>> I think this is what you're looking for.
>>>
>>> For any non-pawn piece, starting at any position on the board, it shows
>>> 2 values:
>>> * the longest single move available
>>> * the sum of all the squares covered by all available moves
>>>
>>> This board is helpful to look at when trying the program:
>>> https://en.wikipedia.org/wiki/Algebraic_notation_(chess)#/media/File:SCD_algebraic_notation.svg
>>
>>
>> You want to see real chess software?
>>
>> https://stockfishchess.org
>> https://en.wikipedia.org/wiki/Stockfish_(chess)
>>
>> It's GPL3 licensed, command line, and the strongest computer chess
>> engine in the world.
>>
>> The C++ code is only 622KB.
>
> That's what Relf used when we had our chess game a while back.

Were you using your wet brain?

> It's not bad.

Bit of an understatement: it's the world's strongest computer chess
engine. Totally dominant. Scroll down the wiki page and see.

On 2/6/2024 8:15 AM, DFS wrote:
> You want to see real chess software?

The Radio Shack electronic chessboard I've had since 1980s still beats
me every time at level 7 and higher. It has 9 levels of play.

Who needs a better one :) You? I don't think so.

On Tuesday, February 6, 2024 at 12:06:27 AM UTC-5, DFS wrote:
> //Code assumes one piece cannot block the other.
>
> [snip cesspool of ridiculous code]
>

The code sub-monkey does it yet again.

The entire long-winded and useless junk that he presents amounts to nothing
more than the repetative determination of known CONSTANTS. That's not what
programming is about.

In C programming, known CONSTANTS are best dealt with using LUTs, or look up tables.

For every chess piece there is a known number of moves for a given square. These
known values are entered into a 64-byte LUT, one for each piece. Then, given the piece
and location, the number of moves is quickly determined.

The VARIABLE quantity here is the location of the other piece and thus its effect on
the number of moves. This is the actual problem to be solved.

It can be solved using radii. Each piece has a number of radii on which a blocking
piece can be located. Just determine which radii for a given piece is occupied by
the blocking piece and then subtract the appropriate quantity from the LUT total.

There. I have solved the REAL PROBLEM and the REAL PROBLEM is not the determination
of the total number of possible moves.

Now just give this solution to the code monkeys and let them screech.

But not this sub-monkey. He couldn't code his way out of a paper bag -- a wet paper
bag.

Ha, ha, ha, ha, ha, ha, ha, ha!

On 2/7/2024 12:36 PM, Lord Master wrote:
> On Tuesday, February 6, 2024 at 12:06:27 AM UTC-5, DFS wrote:
>> //Code assumes one piece cannot block the other.
>>
>> [snip cesspool of ridiculous code]
>>
>
> The code sub-monkey does it yet again.
>
> The entire long-winded and useless junk that he presents amounts to nothing
> more than the repetative determination of known CONSTANTS. That's not what
> programming is about.
>
> In C programming, known CONSTANTS are best dealt with using LUTs, or look up tables.
>
> For every chess piece there is a known number of moves for a given square. These
> known values are entered into a 64-byte LUT, one for each piece. Then, given the piece
> and location, the number of moves is quickly determined.
>
> The VARIABLE quantity here is the location of the other piece and thus its effect on
> the number of moves. This is the actual problem to be solved.
>
> It can be solved using radii. Each piece has a number of radii on which a blocking
> piece can be located. Just determine which radii for a given piece is occupied by
> the blocking piece and then subtract the appropriate quantity from the LUT total.
>
> There. I have solved the REAL PROBLEM and the REAL PROBLEM is not the determination
> of the total number of possible moves.
>
> Now just give this solution to the code monkeys and let them screech.
>
> But not this sub-monkey. He couldn't code his way out of a paper bag -- a wet paper
> bag.
>
> Ha, ha, ha, ha, ha, ha, ha, ha!
>

Look up table in C programming is a nice feature, but I'm for now
limited to qbasic, so I'll just use a arrays for that.

You went over only part of the problem.

The move can come from one piece or the other. So the number of all
different moves by first piece (minus what the second piece has blocked)
should be added to the number of all different moves by the second piece
as well (minus what the first piece has blocked). And this is for just
one instance of the position of first and second pieces on the board. So
the problem isn't over yet.

One needs to account for any position of the first piece on board (minus
1 to account for the occupied square by second piece) and any position
of the second piece (minus 1).

In all these situations the max number of possible moves should be
computed, so regardless of where the two pieces happen to land, and what
the two pieces happen to be, the max number be at hand, so Holaku can
bring with him that many coins, to never run short of them, and never
bring one too many.

This is an interesting coding problem :)

The solution given to Holaku will look like a 5 by 5 square table on one
page, with different chess pieces (except pawn) listed along top row and
first column. And in each square on this table, the number of coins that
Holaku should take with him is written.

So the king decides, say, to take a bishop and a knight with him, he
looks up the table and finds out how many coins he should take along.

Code this! Problem is not solved until it's coded. Then tabulate it and
show it here so I can verify your code got the numbers correct.

On 2/7/2024 1:36 PM, Lying Larry wrote:

> On Tuesday, February 6, 2024 at 12:06:27 AM UTC-5, DFS wrote:
>> //Code assumes one piece cannot block the other.

> Each piece has a number of radii on which a blocking
> piece can be located. Just determine which radii for a given piece is occupied by
> the blocking piece and then subtract the appropriate quantity from the LUT total.
>
> There. I have solved the REAL PROBLEM
* YOU didn't solve anything. That was solved decades ago by
good programmers and chess players.
* YOU regurgitated some solution from a chess/programming forum.
* YOU don't know how to play chess.
* YOU are a programming failure.
* YOU are afraid to post your code, but not to criticize others'.
* YOU dropped an entire college class because YOU couldn't handle
bowling scoring (which takes all of 5 minutes to learn). So to think
YOU could write any meaningful, original chess code or provide novel
solutions to chess programming is laughable in the extreme.
* YOU cannot get YOUR lies and plagiarism and faux-expertise by me.

> and the REAL PROBLEM is not the determination
> of the total number of possible moves.

There are LOTS of "REAL PROBLEMS" in chess. Total number of possible
squares covered by all possible moves was the problem SandChimp asked
(as far as I can tell. The weirdo wrapped his problem in a story with
gold coins and clairvoyant sultans and 72 virgins and hookah smoke
wafting all around).

On Wednesday, February 7, 2024 at 1:36:26 PM UTC-5, Lord Master wrote:
>
> For every chess piece there is a known number of moves for a given square.. These
> known values are entered into a 64-byte LUT, one for each piece.
>

Oops. 'Nuther mistake.

I ferget that the chessboard has a four-fold rotational symmetry and thus
only 16 entries are necessary to populate the LUT.

On Wednesday, February 7, 2024 at 5:52:42 PM UTC-5, Physfitfreak wrote:
>
> This is an interesting coding problem :)
>

I pass. Games always bore me and if I am bored it is impossible for my brain
to become engaged.

On 2/7/2024 5:52 PM, Physfitfreak wrote:
> On 2/7/2024 12:36 PM, Lord Master wrote:
>> On Tuesday, February 6, 2024 at 12:06:27 AM UTC-5, DFS wrote:
>>> //Code assumes one piece cannot block the other.
>>>
>>> [snip cesspool of ridiculous code]
>>>
>>
>> The code sub-monkey does it yet again.
>>
>> The entire long-winded and useless junk that he presents amounts to
>> nothing
>> more than the repetative determination of known CONSTANTS.  That's not
>> what
>> programming is about.
>>
>> In C programming, known CONSTANTS are best dealt with using LUTs, or
>> look up tables.
>>
>> For every chess piece there is a known number of moves for a given
>> square.  These
>> known values are entered into a 64-byte LUT, one for each piece.
>> Then, given the piece
>> and location, the number of moves is quickly determined.
>>
>> The VARIABLE quantity here is the location of the other piece and thus
>> its effect on
>> the number of moves.  This is the actual problem to be solved.
>>
>> It can be solved using radii.  Each piece has a number of radii on
>> which a blocking
>> piece can be located.  Just determine which radii for a given piece is
>> occupied by
>> the blocking piece and then subtract the appropriate quantity from the
>> LUT total.
>>
>> There.  I have solved the REAL PROBLEM and the REAL PROBLEM is not the
>> determination
>> of the total number of possible moves.
>>
>> Now just give this solution to the code monkeys and let them screech.
>>
>> But not this sub-monkey.  He couldn't code his way out of a paper bag
>> -- a wet paper
>> bag.
>>
>> Ha, ha, ha, ha, ha, ha, ha, ha!
>>
>
>
> Look up table in C programming is a nice feature, but I'm for now
> limited to qbasic, so I'll just use a arrays for that.
>
> You went over only part of the problem.
>
> The move can come from one piece or the other. So the number of all
> different moves by first piece (minus what the second piece has blocked)
> should be added to the number of all different moves by the second piece
> as well (minus what the first piece has blocked). And this is for just
> one instance of the position of first and second pieces on the board. So
> the problem isn't over yet.
>
> One needs to account for any position of the first piece on board (minus
> 1 to account for the occupied square by second piece) and any position
> of the second piece (minus 1).
>
> In all these situations the max number of possible moves should be
> computed, so regardless of where the two pieces happen to land, and what
> the two pieces happen to be, the max number be at hand, so Holaku can
> bring with him that many coins, to never run short of them, and never
> bring one too many.
>
> This is an interesting coding problem :)
>
> The solution given to Holaku will look like a 5 by 5 square table on one
> page, with different chess pieces (except pawn) listed along top row and
> first column. And in each square on this table, the number of coins that
> Holaku should take with him is written.
>
> So the king decides, say, to take a bishop and a knight with him, he
> looks up the table and finds out how many coins he should take along.
>
> Code this! Problem is not solved until it's coded. Then tabulate it and
> show it here so I can verify your code got the numbers correct.

You're asking Feeb to write a difficult program, AND show his code on cola?

Not a chance. NEVER.

He might plagiarize something then say "Did I say I wrote it?", but he
doesn't have the skills to deliver what you're asking.

You clearly don't understand what kind of phony you're dealing with.

On 2/8/2024 6:42 AM, DFS wrote:
> You're asking Feeb to write a difficult program, AND show his code on cola?

I don't want to see the codes, I want to see the output tabulated in a 5
x 5 table.

On 2/8/2024 6:38 AM, Lord Master wrote:
> On Wednesday, February 7, 2024 at 1:36:26 PM UTC-5, Lord Master wrote:
>>
>> For every chess piece there is a known number of moves for a given square. These
>> known values are entered into a 64-byte LUT, one for each piece.
>>
>
> Oops. 'Nuther mistake.
>
> I ferget that the chessboard has a four-fold rotational symmetry and thus
> only 16 entries are necessary to populate the LUT.
>

Nice observation.

That alone will cut down part of the computation by a factor of 4. But
there are more symmetries than just one :-) Hehe :)

On 2/8/2024 6:21 AM, DFS wrote:
> There are LOTS of "REAL PROBLEMS" in chess.  Total number of possible
> squares covered by all possible moves was the problem SandChimp asked
> (as far as I can tell.  The weirdo wrapped his problem in a story with
> gold coins and clairvoyant sultans and 72 virgins and hookah smoke
> wafting all around).
>

And that's how a cro-magnon with low reading comprehension sees it.

You'd never be able to get a code monkey job. Reading comprehension in
such jobs is paramount!

As a hobby, sure, but not anything more important than that, programming
for you works.

On 2/8/2024 3:05 PM, Physfitfreak wrote:
> On 2/8/2024 6:21 AM, DFS wrote:
>> There are LOTS of "REAL PROBLEMS" in chess.  Total number of possible
>> squares covered by all possible moves was the problem SandChimp asked
>> (as far as I can tell.  The weirdo wrapped his problem in a story with
>> gold coins and clairvoyant sultans and 72 virgins and hookah smoke
>> wafting all around).
>>
>
> And that's how a cro-magnon with low reading comprehension sees it.

FarsiChimp is your 1st language, and English your 2nd, correct? 'Cause
most of your problems in English are incomprehensible.
"PhysFit and the Mountain" was about 1000 words when 100 would do.

This chess thing was even more stupidly conveyed. Just ridiculous.

Next time give us a link to the original, and leave out your weird
imagination.

> You'd never be able to get a code monkey job. Reading comprehension in
> such jobs is paramount!
>
> As a hobby, sure, but not anything more important than that, programming
> for you works.

I'll smoke your doodling in ANY language.

On 2/8/2024 2:15 PM, DFS wrote:
> On 2/8/2024 3:05 PM, Physfitfreak wrote:
>> On 2/8/2024 6:21 AM, DFS wrote:
>>> There are LOTS of "REAL PROBLEMS" in chess.  Total number of possible
>>> squares covered by all possible moves was the problem SandChimp asked
>>> (as far as I can tell.  The weirdo wrapped his problem in a story
>>> with gold coins and clairvoyant sultans and 72 virgins and hookah
>>> smoke wafting all around).
>>>
>>
>> And that's how a cro-magnon with low reading comprehension sees it.
>
> FarsiChimp is your 1st language, and English your 2nd, correct?  'Cause
> most of your problems in English are incomprehensible.
> "PhysFit and the Mountain" was about 1000 words when 100 would do.
>
> This chess thing was even more stupidly conveyed.  Just ridiculous.
>
> Next time give us a link to the original, and leave out your weird
> imagination.
>
>
>
>> You'd never be able to get a code monkey job. Reading comprehension in
>> such jobs is paramount!
>>
>> As a hobby, sure, but not anything more important than that,
>> programming for you works.
>
> I'll smoke your doodling in ANY language.
>
>

Cro-magnon's loser talk.

No I got tested on my reading comprehension and writing ability just two
months after getting here, with the GRE test, which is essentially
nothing but a tough exam for reading comprehension and writing in the
English language. And my score was high.

So don't worry about me :)

Worry about yourself. You don't fool me.

On 2/8/2024 4:29 PM, Physfitfreak wrote:
> On 2/8/2024 2:15 PM, DFS wrote:
>> On 2/8/2024 3:05 PM, Physfitfreak wrote:
>>> On 2/8/2024 6:21 AM, DFS wrote:
>>>> There are LOTS of "REAL PROBLEMS" in chess.  Total number of
>>>> possible squares covered by all possible moves was the problem
>>>> SandChimp asked (as far as I can tell.  The weirdo wrapped his
>>>> problem in a story with gold coins and clairvoyant sultans and 72
>>>> virgins and hookah smoke wafting all around).
>>>>
>>>
>>> And that's how a cro-magnon with low reading comprehension sees it.
>>
>> FarsiChimp is your 1st language, and English your 2nd, correct?
>> 'Cause most of your problems in English are incomprehensible.
>> "PhysFit and the Mountain" was about 1000 words when 100 would do.
>>
>> This chess thing was even more stupidly conveyed.  Just ridiculous.
>>
>> Next time give us a link to the original, and leave out your weird
>> imagination.
>>
>>
>>
>>> You'd never be able to get a code monkey job. Reading comprehension
>>> in such jobs is paramount!
>>>
>>> As a hobby, sure, but not anything more important than that,
>>> programming for you works.

That sentence is meaningless. Like I said, your monkey babble English
is inscrutable.

>> I'll smoke your doodling in ANY language.

crickets

> Cro-magnon's loser talk.
>
> No I got tested on my reading comprehension and writing ability just two
> months after getting here, with the GRE test, which is essentially
> nothing but a tough exam for reading comprehension and writing in the
> English language. And my score was high.

So? That was a a long time ago, and chimps lose a lot of their meager
brainpower over the years.

> So don't worry about me :)
>
> Worry about yourself. You don't fool me.

Bring it, bozo. Talk's cheap.

The way to do it is this:
* you or I propose a code challenge/problem, which might be accepted or
rejected. Call us D and P
* D finishes his code solution first, but doesn't post it to cola. D
zips it up with a password and posts a link to the .zip file.
* P downloads the .zip file (but he can't open it without the password)
* P finishes his code and posts his code to cola in a message
* D posts the password to the .zip file

This way nobody can piggyback on the other's code.

Note: I will NEVER accept another code challenge like these 2 recent
ones of yours. You use 100 words when 10 will do. I won't even read
them. I'm sure they're funny to you, but it's painful to read even a
few sentences.

=======================================================================
"Physfit And The Mountain

In a sweet dream, Physfit, as he is typing away with his machine gun
fingers calling somebody in COLA "cro-magnon", and giving him the sage
advice of fingering himself, he notices through the window blinds, over
there, two blocks away from him, there is a strange mountain in an empty
field that he had never paid any attention to. In fact he had never seen
it before.

Calling it a mountain was just ridiculous of course, cause it was only
100 yards high. Physfit tells himself, "Today is my eating day, so after
eating, to relax a bit I'll climb it and sit there on top of it for a
few minutes."

So after he was done with eating the hearty soup he begins walking
towards the mountain, but as he gets closer, he realizes that its shape
is not that friendly for a quick climb, and in fact more likely he'll
need to have ropes and crampons and harnesses, and you name it to climb it.

So he walks back home and gets in the attic, brings down the dusty box
that had his old mountaineer's equipment (which he never had a use for
in Texas). Opens it up and takes what he thinks he'd need, and together
with some other supplies walks back to the mountain to get on top and
relax before coming back home.

The climb proves not easy. And this makes him even more eager to get it
done and conquer the damn strange thing.

At last, he had gone up no more than 11 yards when he notices the Sun is
already setting!... After all that effort, he thinks to himself,
"Getting back down will take too long and at best I'll make it home
several hours after my sleeping time, plus I'd have to start over
tomorrow from the ground level, making it to this height around the same
time as it is now, with no progress made after 24 hours."

So going back down would beat the purpose. He decides to camp at the
spot he is, for the night, and continue the climb next day. He gets his
sleeping bag in order and crawls inside and falls into a deep wonderful
sleep.

But during the night, as Physfit is snoring in his sleeping bag, this
strange mountain grows itself a hundred yards taller!... So Physfit's
distance to the top gets larger than before he even had begun climbing.
But fortunately, this growth didn't just add another 100 yards to the
height of the mountain, but was done proportionally, which means during
that night, Physfit's height from the ground has also increased
proportionally. So the shape of the mountain remained intact, only its
size got increased and thus added 100 more yards to the overall height.

Physfit wakes up in the morning and finds himself at the height of 22
yards on a mountain that was 200 yards high!... So in this new day, with
much effort and perseverance, he manages to climb another 11 yards up
before the Sun begins setting. And by the same logic he decides to sleep
at the spot he was and continue the climb the next day.

While asleep, the strange mountain grows itself proportionally to make
its height another 100 yards larger...

In the morning, Physfit wakes up and finds himself at the height of 49.5
yards on a mountain 300 yards tall.

While brewing his Walmart National Cup tea-bag (which amazingly after
all the recent inflation was still $1 for 100 tea-bags), he admits to
himself that conquering this summit will be harder than he expected.

Every day, from then on, he climbed another 11 yards, and every night
the mountain grew another 100 yards taller, taking him a bit higher with it.

Did Physfit reach the summit? If he reached, why he could reach it, and
how many days total it took him to get there? And if he could not reach
it, prove why he couldn't reach the summit."
=======================================================================

wtf? I never have and never will read that bullshit.

Your chess scenario was just as long, and also weird as hell (what I
read of it):

======================================================================
Thus the story continues...

The two scientists got out and locked the gate and left.

That day, in the evening, a party was to hold in Holaku's Summer
residence not that far from Maragheh. And the two were both invited!

Ghotbeddin got home and hit the sack fast and early to wake up fully
rested before attending the party. He couldn't be contained inside his
own skin, when thinking about the prospect of seeing Holaku's daughter
again within that same day...

As he slowly drifted off into sleep he dreamed that wherever he was, he
was actually already in that party but had just noticed it! He didn't
get time to think how it happened and why he'd only now realized where
he'd been all this time. Holaku was sitting on a throne across the huge
room and some of the vazirs were here and there chatting. But he knew
that he had not yet seen the daughter, so he made himself sure he'll
stay until she shows up. Also, he knew that he and Holaku both were
waiting for Tusi to arrive, because Holaku had something to ask from him.

But there was no sign of Tusi. At his home, he had come up with an idea
which needed the use of some tables of numbers kept at the observatory,
and he had chosen to go to the observatory in the evening, not even to
Hulaku's party where he was invited!

So after some time, at some point Holaku signaled to have a talk with
Ghotbeddin. A servant and one of the vazirs immediately came over to
Ghotbeddin and together walked to where Holaku was sitting.

Holaku to Ghotbeddin:

"They tell me you are a very smart man to be in the observatory,
helping someone like Tusi. Do you think you are as smart as Tusi?"

Ghotbeddin made a faint smile and said:

"Your Majesty, I am not blessed with as much talent as God has
bestowed upon Your Majesty _or_ Tusi."

Holaku:

"I have a task for Tusi to accomplish, but in his absence I want you
to do it."

Ghotbeddin:

"Your Majesty's wish is my utmost desire."

Holaku:

"In each of my parties, a session is always included in which a
chessboard is placed on the floor, with no chess pieces on it. There is
a contest, and the winner is blindfolded and given two random chess
pieces of same color - but not any pawns - out of my pocket, to place
somewhere on the chessboard by the winner, in two of the squares. Then
the blindfold is removed and the winner will look at the chessboard and
counts the number of different moves he can make with the chess pieces
from the squares that they are in. The winner will get as many gold
coins from me as that count is. If I know in advance which two pieces
will be given to the winner, I need to know how many gold coins I should
bring with me to the party, so I could never find myself with not enough
coins to give to the winner, and never carry with me even one gold coin
that would never be needed to be given to the winner. Find how many
coins I should bring with me to the party."

On 2/8/2024 6:04 PM, DFS wrote:
> Talk's cheap

You've proven yourself in action too :)

On 2/6/20966666624 6:19 PM, Physfitfreak wrote:
> Machine numbers are in binary form. But these machine numbers can be
> expressed in decimal machine numbers like:
>
> 0.d_1d_2 ... d_k x 10^n
>
> , where d_1 digit is _not_ zero, and d_2, d_3 ... d_k digits can each be
> an integer from zero to 9.

By the way, can FriCAS show the above math expression correctly in
pretty print? Diagon cannot! At least I don't know how to use it to
write that number in the familiar way.

Diagon seems to treat each digit as a separate number, and therefore
requires a math operation inbetween them! Hehe :) What a flaw. I just
noticed it.

But perhaps friCAS is like that too.

Le 06-02-2024, Physfitfreak <Physfitfreak@gmail.com> a écrit :
>
> You must understand the problem first. Any code monkey has good reading
> comprehension, otherwise they're just useless cause they won't know what
> it is that the employer wants them to do.

No employer will refuse to explain differently what has been
misunderstood. When an employer hires a programmer, he's not sure the
programmer knows the context in which the program will be used. The job
of the programmer is to develop a program, not to know every way in
which it can be used. You are like a lot of teachers I had: they never
went outside of their university but they believed they know what the
employers will need. And like you, they were just plain wrong.

--
Si vous avez du temps à perdre :
https://scarpet42.gitlab.io