On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
>>> Re: Draw an infinite square lattice without lifting the pencil.
>>>>
>>>> Too easy.
>>>>
>>>> Infinity borderline 1*10^604
>>>>
>>>> Go across then go down. Some pieces you go over a second time.
>>>>
>>>> A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before.
>>>>
>>>> Then some wiseguy would say, just cover your printing press with ink and stamp the Grid.
>>>
>>> Alright, let us spice up the original question. For Decimal Grid Number Systems is the heart of mathematics concerning numbers. And we throw out the ugly stupid Reals on the trash pile of shame-- their continuum-- their anti-quantum mechanics. For Quantum Mechanics physics is at heart-- discrete. And in a Grid System where the vertical perpendicular meets the horizontal at a point is a individual number. The space in between is empty space, and no numbers.
>>>
>>> So now, Physics is not a game of a human hand with pencil in mind of playing a game where you draw a Grid System and whether you lift your pencil off the paper or not.
>>>
>>> So let me adjust the rules to be physics. Instead of a Hand with pencil say we have electricity as a closed loop and we have magnetism as a closed loop.
>>>
>>> Now we can bunch up the loops of electricity and that of magnetism.
>>>
>>> But the game now is to bunch them up to form a Grid System.
>> A grid system using a vector field:
>
> Yes, Chris, buy the new Apple Vision glasses-- $3,500. to build this Grid. And possibly put your fractals out of business.
> Cheers from some corners of Earth.

Not exactly sure what you mean... My fractal software is compatible with
all types of VR.

On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
> > On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
> >> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
> >>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> >>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> >>> Re: Draw an infinite square lattice without lifting the pencil.
> >>>>
> >>>> Too easy.
> >>>>
> >>>> Infinity borderline 1*10^604
> >>>>
> >>>> Go across then go down. Some pieces you go over a second time.
> >>>>
> >>>> A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before.
> >>>>
> >>>> Then some wiseguy would say, just cover your printing press with ink and stamp the Grid.
> >>>
> >>> Alright, let us spice up the original question. For Decimal Grid Number Systems is the heart of mathematics concerning numbers. And we throw out the ugly stupid Reals on the trash pile of shame-- their continuum-- their anti-quantum mechanics. For Quantum Mechanics physics is at heart-- discrete. And in a Grid System where the vertical perpendicular meets the horizontal at a point is a individual number. The space in between is empty space, and no numbers.
> >>>
> >>> So now, Physics is not a game of a human hand with pencil in mind of playing a game where you draw a Grid System and whether you lift your pencil off the paper or not.
> >>>
> >>> So let me adjust the rules to be physics. Instead of a Hand with pencil say we have electricity as a closed loop and we have magnetism as a closed loop.
> >>>
> >>> Now we can bunch up the loops of electricity and that of magnetism.
> >>>
> >>> But the game now is to bunch them up to form a Grid System.
> >> A grid system using a vector field:
> >
> > Yes, Chris, buy the new Apple Vision glasses-- $3,500. to build this Grid. And possibly put your fractals out of business.
> > Cheers from some corners of Earth.
> Not exactly sure what you mean... My fractal software is compatible with
> all types of VR.

So Chris how is it going.
You have seen the videos so what is your assessment?
The pencil never leaves the paper. Bogus or real?
I definitely believe it is real. The videos prove it.
It is suprising that some that are questioning it have run complex algorithms that left me in the dust
where I had no clue on how they did it.
I will send the largest square lattace ever produced where it runs off the top and bottom of the screen.
In which the old algorithm would have used thousands of these directions R,U,D,L where now
it just uses a handful but in multiple times for completing a large square lattice.
Watch for the new video.

On 6/7/2023 6:56 PM, Dan joyce wrote:
> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
>>>>> Re: Draw an infinite square lattice without lifting the pencil.
>>>>>>
>>>>>> Too easy.
>>>>>>
>>>>>> Infinity borderline 1*10^604
>>>>>>
>>>>>> Go across then go down. Some pieces you go over a second time.
>>>>>>
>>>>>> A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before.
>>>>>>
>>>>>> Then some wiseguy would say, just cover your printing press with ink and stamp the Grid.
>>>>>
>>>>> Alright, let us spice up the original question. For Decimal Grid Number Systems is the heart of mathematics concerning numbers. And we throw out the ugly stupid Reals on the trash pile of shame-- their continuum-- their anti-quantum mechanics. For Quantum Mechanics physics is at heart-- discrete. And in a Grid System where the vertical perpendicular meets the horizontal at a point is a individual number. The space in between is empty space, and no numbers.
>>>>>
>>>>> So now, Physics is not a game of a human hand with pencil in mind of playing a game where you draw a Grid System and whether you lift your pencil off the paper or not.
>>>>>
>>>>> So let me adjust the rules to be physics. Instead of a Hand with pencil say we have electricity as a closed loop and we have magnetism as a closed loop.
>>>>>
>>>>> Now we can bunch up the loops of electricity and that of magnetism.
>>>>>
>>>>> But the game now is to bunch them up to form a Grid System.
>>>> A grid system using a vector field:
>>>
>>> Yes, Chris, buy the new Apple Vision glasses-- $3,500. to build this Grid. And possibly put your fractals out of business.
>>> Cheers from some corners of Earth.
>> Not exactly sure what you mean... My fractal software is compatible with
>> all types of VR.
>
> So Chris how is it going.
> You have seen the videos so what is your assessment?
> The pencil never leaves the paper. Bogus or real?
> I definitely believe it is real. The videos prove it.
> It is suprising that some that are questioning it have run complex algorithms that left me in the dust
> where I had no clue on how they did it.
> I will send the largest square lattace ever produced where it runs off the top and bottom of the screen.
> In which the old algorithm would have used thousands of these directions R,U,D,L where now
> it just uses a handful but in multiple times for completing a large square lattice.
> Watch for the new video.

I have to port your data section in your BASIC code into my C++ code.

550 DATA
1,2,1,3,2,4,3,5,4,6,5,7,6,8,7,9,8,10,9,11,10,12,11,13,12,14,13,15,14,16
,15,17,16,18,17,19,18
560 REM The data above can be carried much higher depending on what you
give t
he pixel value of A to keep the lattice all on the screen.
570 REM if you increase the data by 4 in the 1st going out lattice then
the seco
nd one has to be incresed by 4. example --- add to the end of the first
data l
ine 20,19,21,20 - add 20,19,19,18 to the begining of the second data line.
580 DATA
18,17,17,16,16,15,15,14,14,13,13,12,12,11,11,10,10,9,9,8,8,7,7,6,6,5,5,
4,4,3,3,2,2,1,1

Then I have to emulate the reads, ala READ B into this static data. So,
its not exactly fun to do. I have to keep a running index to emulate the
READS. I want to do a pure port, so we can get on the same page. Your
data section 1,2,1... ect, seems like a list of directions all over
again. Not an algorithm to create them...

On 6/7/2023 6:56 PM, Dan joyce wrote:
> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
>>>>> Re: Draw an infinite square lattice without lifting the pencil.
>>>>>>
>>>>>> Too easy.
>>>>>>
>>>>>> Infinity borderline 1*10^604
>>>>>>
>>>>>> Go across then go down. Some pieces you go over a second time.
>>>>>>
>>>>>> A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before.
>>>>>>
>>>>>> Then some wiseguy would say, just cover your printing press with ink and stamp the Grid.
>>>>>
>>>>> Alright, let us spice up the original question. For Decimal Grid Number Systems is the heart of mathematics concerning numbers. And we throw out the ugly stupid Reals on the trash pile of shame-- their continuum-- their anti-quantum mechanics. For Quantum Mechanics physics is at heart-- discrete. And in a Grid System where the vertical perpendicular meets the horizontal at a point is a individual number. The space in between is empty space, and no numbers.
>>>>>
>>>>> So now, Physics is not a game of a human hand with pencil in mind of playing a game where you draw a Grid System and whether you lift your pencil off the paper or not.
>>>>>
>>>>> So let me adjust the rules to be physics. Instead of a Hand with pencil say we have electricity as a closed loop and we have magnetism as a closed loop.
>>>>>
>>>>> Now we can bunch up the loops of electricity and that of magnetism.
>>>>>
>>>>> But the game now is to bunch them up to form a Grid System.
>>>> A grid system using a vector field:
>>>
>>> Yes, Chris, buy the new Apple Vision glasses-- $3,500. to build this Grid. And possibly put your fractals out of business.
>>> Cheers from some corners of Earth.
>> Not exactly sure what you mean... My fractal software is compatible with
>> all types of VR.
>
> So Chris how is it going.
> You have seen the videos so what is your assessment?
> The pencil never leaves the paper. Bogus or real?
> I definitely believe it is real. The videos prove it.
> It is suprising that some that are questioning it have run complex algorithms that left me in the dust
> where I had no clue on how they did it.
> I will send the largest square lattace ever produced where it runs off the top and bottom of the screen.
> In which the old algorithm would have used thousands of these directions R,U,D,L where now
> it just uses a handful but in multiple times for completing a large square lattice.
> Watch for the new video.

How about this data? That should mimic your DATA in your BASIC code, right?

// BASIC data
unsigned long basic_data[] = {
1,2,1,3,2,4,3,5,4,6,5,7,6,8,
7,9,8,10,9,11,10,12,11,13,12,
14,13,15,14,16,15,17,16,18,17,
19,18,18,17,17,16,16,15,15,14,
14,13,13,12,12,11,11,10,10,9,
9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
1,1
};

On 6/7/2023 6:56 PM, Dan joyce wrote:
> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
[...]

My code for this test on your work:
______________________________
// DAN JOYCE PLOTTER TESTING 123... ;^)
//_____________________________________________________________
#include <array>

namespace ct_dj_plotter
{ void
plot_arrow_line(
ct::plot::cairo::plot_2d& scene,
glm::vec2 p0,
glm::vec2 p1,
ct::plot::cairo::pixel color,
float thickness
) {
glm::vec2 dif = p1 - p0;
glm::vec2 dif_perp = { dif.y, -dif.x };

glm::vec2 arrow_origin = p0 + dif * .8f;

glm::vec2 arrow_p0 = arrow_origin + dif_perp * .08f;
glm::vec2 arrow_p1 = arrow_origin - dif_perp * .08f;

//scene.circle(arrow_origin, .01f, color, 3);
//scene.circle(arrow_p0, .01f, color, 3);
//scene.circle(arrow_p1, .01f, color, 3);

scene.line(arrow_p0, p1, color, thickness);
scene.line(arrow_p1, p1, color, thickness);

scene.line(p0, p1, color, thickness);
}

struct direction
{
glm::vec2 m_normal;
glm::vec3 m_color;
};

struct ct_basic_data
{
unsigned long m_index;
std::array<unsigned long, 72> m_basic_data;

unsigned long
get()
{
if (m_index >= m_basic_data.size())
{
throw;
}

return m_basic_data[m_index++];
}

void
iterate()
{
for (unsigned long i = 0; i < m_basic_data.size(); ++i)
{
std::cout << "i[" << i << "] = " << m_basic_data[i] <<
"\n";
}
}
};

void
manifest(
ct::plot::cairo::plot_2d& scene
) {
std::cout << "ct_dj_plotter::manifest()\n" << std::endl;

// BASIC data
ct_basic_data basic_data = {
0,
{
1,2,1,3,2,4,3,5,4,6,5,7,6,8,
7,9,8,10,9,11,10,12,11,13,12,
14,13,15,14,16,15,17,16,18,17,
19,18,18,17,17,16,16,15,15,14,
14,13,13,12,12,11,11,10,10,9,
9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
1,1
}
};

basic_data.iterate();
}
} ______________________________

Some output, this should be the same as reading your BASIC DATA section,
right? where am I going wrong here?
______________________________
ct_cairo_misc

ct_dj_plotter::manifest()

i[0] = 1
i[1] = 2
i[2] = 1
i[3] = 3
i[4] = 2
i[5] = 4
i[6] = 3
i[7] = 5
i[8] = 4
i[9] = 6
i[10] = 5
i[11] = 7
i[12] = 6
i[13] = 8
i[14] = 7
i[15] = 9
i[16] = 8
i[17] = 10
i[18] = 9
i[19] = 11
i[20] = 10
i[21] = 12
i[22] = 11
i[23] = 13
i[24] = 12
i[25] = 14
i[26] = 13
i[27] = 15
i[28] = 14
i[29] = 16
i[30] = 15
i[31] = 17
i[32] = 16
i[33] = 18
i[34] = 17
i[35] = 19
i[36] = 18
i[37] = 18
i[38] = 17
i[39] = 17
i[40] = 16
i[41] = 16
i[42] = 15
i[43] = 15
i[44] = 14
i[45] = 14
i[46] = 13
i[47] = 13
i[48] = 12
i[49] = 12
i[50] = 11
i[51] = 11
i[52] = 10
i[53] = 10
i[54] = 9
i[55] = 9
i[56] = 8
i[57] = 8
i[58] = 7
i[59] = 7
i[60] = 6
i[61] = 6
i[62] = 5
i[63] = 5
i[64] = 4
i[65] = 4
i[66] = 3
i[67] = 3
i[68] = 2
i[69] = 2
i[70] = 1
i[71] = 1
______________________________

On Wednesday, June 7, 2023 at 10:05:39 PM UTC-4, Chris M. Thomasson wrote:
> On 6/7/2023 6:56 PM, Dan joyce wrote:
> > On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
> >> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
> >>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
> >>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
> >>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> >>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> >>>>> Re: Draw an infinite square lattice without lifting the pencil.
> >>>>>>
> >>>>>> Too easy.
> >>>>>>
> >>>>>> Infinity borderline 1*10^604
> >>>>>>
> >>>>>> Go across then go down. Some pieces you go over a second time.
> >>>>>>
> >>>>>> A much harder, and likely impossible drawing is where you make the grid without lifting the pencil and without retracing where you already been before.
> >>>>>>
> >>>>>> Then some wiseguy would say, just cover your printing press with ink and stamp the Grid.
> >>>>>
> >>>>> Alright, let us spice up the original question. For Decimal Grid Number Systems is the heart of mathematics concerning numbers. And we throw out the ugly stupid Reals on the trash pile of shame-- their continuum-- their anti-quantum mechanics. For Quantum Mechanics physics is at heart-- discrete. And in a Grid System where the vertical perpendicular meets the horizontal at a point is a individual number. The space in between is empty space, and no numbers.
> >>>>>
> >>>>> So now, Physics is not a game of a human hand with pencil in mind of playing a game where you draw a Grid System and whether you lift your pencil off the paper or not.
> >>>>>
> >>>>> So let me adjust the rules to be physics. Instead of a Hand with pencil say we have electricity as a closed loop and we have magnetism as a closed loop.
> >>>>>
> >>>>> Now we can bunch up the loops of electricity and that of magnetism.
> >>>>>
> >>>>> But the game now is to bunch them up to form a Grid System.
> >>>> A grid system using a vector field:
> >>>
> >>> Yes, Chris, buy the new Apple Vision glasses-- $3,500. to build this Grid. And possibly put your fractals out of business.
> >>> Cheers from some corners of Earth.
> >> Not exactly sure what you mean... My fractal software is compatible with
> >> all types of VR.
> >
> > So Chris how is it going.
> > You have seen the videos so what is your assessment?
> > The pencil never leaves the paper. Bogus or real?
> > I definitely believe it is real. The videos prove it.
> > It is suprising that some that are questioning it have run complex algorithms that left me in the dust
> > where I had no clue on how they did it.
> > I will send the largest square lattace ever produced where it runs off the top and bottom of the screen.
> > In which the old algorithm would have used thousands of these directions R,U,D,L where now
> > it just uses a handful but in multiple times for completing a large square lattice.
> > Watch for the new video.
> How about this data? That should mimic your DATA in your BASIC code, right?
>
> // BASIC data
> unsigned long basic_data[] = {
> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,
> 7,9,8,10,9,11,10,12,11,13,12,
> 14,13,15,14,16,15,17,16,18,17,
> 19,18,18,17,17,16,16,15,15,14,
> 14,13,13,12,12,11,11,10,10,9,
> 9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
> 1,1
> };
The going out sequence.
The first (1) that is stand alone never to be accessed again.
You can see the pattern for each set of 4 after that.
2,1,3,2 one rotation
4,3,5,4 next
6,5,7,6 next
8,7,9,8 next
etc.

On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson wrote:
> On 6/7/2023 6:56 PM, Dan joyce wrote:
> > On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
> >> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
> >>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
> >>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
> >>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> >>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> [...]
>
> My code for this test on your work:
> ______________________________
> // DAN JOYCE PLOTTER TESTING 123... ;^)
> //_____________________________________________________________
> #include <array>
>
> namespace ct_dj_plotter
> {
> void
> plot_arrow_line(
> ct::plot::cairo::plot_2d& scene,
> glm::vec2 p0,
> glm::vec2 p1,
> ct::plot::cairo::pixel color,
> float thickness
> ) {
> glm::vec2 dif = p1 - p0;
> glm::vec2 dif_perp = { dif.y, -dif.x };
>
> glm::vec2 arrow_origin = p0 + dif * .8f;
>
> glm::vec2 arrow_p0 = arrow_origin + dif_perp * .08f;
> glm::vec2 arrow_p1 = arrow_origin - dif_perp * .08f;
>
> //scene.circle(arrow_origin, .01f, color, 3);
> //scene.circle(arrow_p0, .01f, color, 3);
> //scene.circle(arrow_p1, .01f, color, 3);
>
> scene.line(arrow_p0, p1, color, thickness);
> scene.line(arrow_p1, p1, color, thickness);
>
> scene.line(p0, p1, color, thickness);
> }
>
> struct direction
> {
> glm::vec2 m_normal;
> glm::vec3 m_color;
> };
>
>
>
>
>
> struct ct_basic_data
> {
> unsigned long m_index;
> std::array<unsigned long, 72> m_basic_data;
>
> unsigned long
> get()
> {
> if (m_index >= m_basic_data.size())
> {
> throw;
> }
>
> return m_basic_data[m_index++];
> }
>
> void
> iterate()
> {
> for (unsigned long i = 0; i < m_basic_data.size(); ++i)
> {
> std::cout << "i[" << i << "] = " << m_basic_data[i] <<
> "\n";
> }
> }
> };
>
>
>
>
> void
> manifest(
> ct::plot::cairo::plot_2d& scene
> ) {
> std::cout << "ct_dj_plotter::manifest()\n" << std::endl;
>
>
> // BASIC data
> ct_basic_data basic_data = {
> 0,
> {
> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,
> 7,9,8,10,9,11,10,12,11,13,12,
> 14,13,15,14,16,15,17,16,18,17,
> 19,18,18,17,17,16,16,15,15,14,
> 14,13,13,12,12,11,11,10,10,9,
> 9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
> 1,1
> }
> };
> basic_data.iterate();
> }
> }
> ______________________________
>
>
>
> Some output, this should be the same as reading your BASIC DATA section,
> right? where am I going wrong here?

Remember each set of pattern 4 is a rotation.
Also in the first going out module set the largest last integer as identifying
the last operation in the going out module. You will see that in the code.
It finishes the read of the first sequence then goes and reads the second
sequence for coming back in.
I should have documented the code a little more with rem statments.
In the coming back in sequence that is why the numbers are larger at the begining
of that sequence that also has a unique 4 pattern of the integers in that sequence.
I just sent a huge video of a square lattice in slow-mo.
I hope this helps.
______________________________
> ct_cairo_misc
>
> ct_dj_plotter::manifest()
>
> i[0] = 1 This is only run once then the 4 patterns for each set take over.
------------------------------------------------------------------------------------
> i[1] = 2
> i[2] = 1
> i[3] = 3
> i[4] = 2
> i[5] = 4
> i[6] = 3
> i[7] = 5
> i[8] = 4
> i[9] = 6
> i[10] = 5
> i[11] = 7
> i[12] = 6
> i[13] = 8
> i[14] = 7
> i[15] = 9
> i[16] = 8
> i[17] = 10
> i[18] = 9
> i[19] = 11
> i[20] = 10
> i[21] = 12
> i[22] = 11
> i[23] = 13
> i[24] = 12
> i[25] = 14
> i[26] = 13
> i[27] = 15
> i[28] = 14
> i[29] = 16
> i[30] = 15
> i[31] = 17
> i[32] = 16
> i[33] = 18
> i[34] = 17
> i[35] = 19
> i[36] = 18
> i[37] = 18
> i[38] = 17
> i[39] = 17
> i[40] = 16
> i[41] = 16
> i[42] = 15
> i[43] = 15
> i[44] = 14
> i[45] = 14
> i[46] = 13
> i[47] = 13
> i[48] = 12
> i[49] = 12
> i[50] = 11
> i[51] = 11
> i[52] = 10
> i[53] = 10
> i[54] = 9
> i[55] = 9
> i[56] = 8
> i[57] = 8
> i[58] = 7
> i[59] = 7
> i[60] = 6
> i[61] = 6
> i[62] = 5
> i[63] = 5
> i[64] = 4
> i[65] = 4
> i[66] = 3
> i[67] = 3
> i[68] = 2
> i[69] = 2
> i[70] = 1
> i[71] = 1
> ______________________________

On Wednesday, June 7, 2023 at 11:08:50 PM UTC-4, Dan joyce wrote:
> On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson wrote:
> > On 6/7/2023 6:56 PM, Dan joyce wrote:
> > > On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
> > >> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
> > >>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
> > >>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
> > >>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> > >>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> > [...]
> >
> > My code for this test on your work:
> > ______________________________
> > // DAN JOYCE PLOTTER TESTING 123... ;^)
> > //_____________________________________________________________
> > #include <array>
> >
> > namespace ct_dj_plotter
> > {
> > void
> > plot_arrow_line(
> > ct::plot::cairo::plot_2d& scene,
> > glm::vec2 p0,
> > glm::vec2 p1,
> > ct::plot::cairo::pixel color,
> > float thickness
> > ) {
> > glm::vec2 dif = p1 - p0;
> > glm::vec2 dif_perp = { dif.y, -dif.x };
> >
> > glm::vec2 arrow_origin = p0 + dif * .8f;
> >
> > glm::vec2 arrow_p0 = arrow_origin + dif_perp * .08f;
> > glm::vec2 arrow_p1 = arrow_origin - dif_perp * .08f;
> >
> > //scene.circle(arrow_origin, .01f, color, 3);
> > //scene.circle(arrow_p0, .01f, color, 3);
> > //scene.circle(arrow_p1, .01f, color, 3);
> >
> > scene.line(arrow_p0, p1, color, thickness);
> > scene.line(arrow_p1, p1, color, thickness);
> >
> > scene.line(p0, p1, color, thickness);
> > }
> >
> > struct direction
> > {
> > glm::vec2 m_normal;
> > glm::vec3 m_color;
> > };
> >
> >
> >
> >
> >
> > struct ct_basic_data
> > {
> > unsigned long m_index;
> > std::array<unsigned long, 72> m_basic_data;
> >
> > unsigned long
> > get()
> > {
> > if (m_index >= m_basic_data.size())
> > {
> > throw;
> > }
> >
> > return m_basic_data[m_index++];
> > }
> >
> > void
> > iterate()
> > {
> > for (unsigned long i = 0; i < m_basic_data.size(); ++i)
> > {
> > std::cout << "i[" << i << "] = " << m_basic_data[i] <<
> > "\n";
> > }
> > }
> > };
> >
> >
> >
> >
> > void
> > manifest(
> > ct::plot::cairo::plot_2d& scene
> > ) {
> > std::cout << "ct_dj_plotter::manifest()\n" << std::endl;
> >
> >
> > // BASIC data
> > ct_basic_data basic_data = {
> > 0,
> > {
> > 1,2,1,3,2,4,3,5,4,6,5,7,6,8,
> > 7,9,8,10,9,11,10,12,11,13,12,
> > 14,13,15,14,16,15,17,16,18,17,
> > 19,18,18,17,17,16,16,15,15,14,
> > 14,13,13,12,12,11,11,10,10,9,
> > 9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
> > 1,1
> > }
> > };
> > basic_data.iterate();
> > }
> > }
> > ______________________________
> >
> >
> >
> > Some output, this should be the same as reading your BASIC DATA section,
> > right? where am I going wrong here?
> Remember each set of pattern 4 is a rotation.
> Also in the first going out module set the largest last integer as identifying
> the last operation in the going out module. You will see that in the code..
> It finishes the read of the first sequence then goes and reads the second
> sequence for coming back in.
> I should have documented the code a little more with rem statments.
> In the coming back in sequence that is why the numbers are larger at the begining
> of that sequence that also has a unique 4 pattern of the integers in that sequence.
> I just sent a huge video of a square lattice in slow-mo.
> I hope this helps.
> ______________________________
> > ct_cairo_misc
> >
> > ct_dj_plotter::manifest()
> >
> > i[0] = 1 This is only run once then the 4 patterns for each set take over.
> ------------------------------------------------------------------------------------
> > i[1] = 2
> > i[2] = 1
> > i[3] = 3
> > i[4] = 2
> > i[5] = 4
> > i[6] = 3
> > i[7] = 5
> > i[8] = 4
> > i[9] = 6
> > i[10] = 5
> > i[11] = 7
> > i[12] = 6
> > i[13] = 8
> > i[14] = 7
> > i[15] = 9
> > i[16] = 8
> > i[17] = 10
> > i[18] = 9
> > i[19] = 11
> > i[20] = 10
> > i[21] = 12
> > i[22] = 11
> > i[23] = 13
> > i[24] = 12
> > i[25] = 14
> > i[26] = 13
> > i[27] = 15
> > i[28] = 14
> > i[29] = 16
> > i[30] = 15
> > i[31] = 17
> > i[32] = 16
> > i[33] = 18
> > i[34] = 17
> > i[35] = 19
> > i[36] = 18
> > i[37] = 18
> > i[38] = 17
> > i[39] = 17
> > i[40] = 16
> > i[41] = 16
> > i[42] = 15
> > i[43] = 15
> > i[44] = 14
> > i[45] = 14
> > i[46] = 13
> > i[47] = 13
> > i[48] = 12
> > i[49] = 12
> > i[50] = 11
> > i[51] = 11
> > i[52] = 10
> > i[53] = 10
> > i[54] = 9
> > i[55] = 9
> > i[56] = 8
> > i[57] = 8
> > i[58] = 7
> > i[59] = 7
> > i[60] = 6
> > i[61] = 6
> > i[62] = 5
> > i[63] = 5
> > i[64] = 4
> > i[65] = 4
> > i[66] = 3
> > i[67] = 3
> > i[68] = 2
> > i[69] = 2
> > i[70] = 1
> > i[71] = 1
> > ______________________________

On 6/7/2023 8:08 PM, Dan joyce wrote:
> On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson wrote:
>> On 6/7/2023 6:56 PM, Dan joyce wrote:
>>> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
>>>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
>>>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
>>>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
>>>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
>>>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
>> [...]
>>
>> My code for this test on your work:
>> ______________________________
>> // DAN JOYCE PLOTTER TESTING 123... ;^)
>> //_____________________________________________________________
>> #include <array>
>>
>> namespace ct_dj_plotter
>> {
>> void
>> plot_arrow_line(
>> ct::plot::cairo::plot_2d& scene,
>> glm::vec2 p0,
>> glm::vec2 p1,
>> ct::plot::cairo::pixel color,
>> float thickness
>> ) {
>> glm::vec2 dif = p1 - p0;
>> glm::vec2 dif_perp = { dif.y, -dif.x };
>>
>> glm::vec2 arrow_origin = p0 + dif * .8f;
>>
>> glm::vec2 arrow_p0 = arrow_origin + dif_perp * .08f;
>> glm::vec2 arrow_p1 = arrow_origin - dif_perp * .08f;
>>
>> //scene.circle(arrow_origin, .01f, color, 3);
>> //scene.circle(arrow_p0, .01f, color, 3);
>> //scene.circle(arrow_p1, .01f, color, 3);
>>
>> scene.line(arrow_p0, p1, color, thickness);
>> scene.line(arrow_p1, p1, color, thickness);
>>
>> scene.line(p0, p1, color, thickness);
>> }
>>
>> struct direction
>> {
>> glm::vec2 m_normal;
>> glm::vec3 m_color;
>> };
>>
>>
>>
>>
>>
>> struct ct_basic_data
>> {
>> unsigned long m_index;
>> std::array<unsigned long, 72> m_basic_data;
>>
>> unsigned long
>> get()
>> {
>> if (m_index >= m_basic_data.size())
>> {
>> throw;
>> }
>>
>> return m_basic_data[m_index++];
>> }
>>
>> void
>> iterate()
>> {
>> for (unsigned long i = 0; i < m_basic_data.size(); ++i)
>> {
>> std::cout << "i[" << i << "] = " << m_basic_data[i] <<
>> "\n";
>> }
>> }
>> };
>>
>>
>>
>>
>> void
>> manifest(
>> ct::plot::cairo::plot_2d& scene
>> ) {
>> std::cout << "ct_dj_plotter::manifest()\n" << std::endl;
>>
>>
>> // BASIC data
>> ct_basic_data basic_data = {
>> 0,
>> {
>> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,
>> 7,9,8,10,9,11,10,12,11,13,12,
>> 14,13,15,14,16,15,17,16,18,17,
>> 19,18,18,17,17,16,16,15,15,14,
>> 14,13,13,12,12,11,11,10,10,9,
>> 9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
>> 1,1
>> }
>> };
>> basic_data.iterate();
>> }
>> }
>> ______________________________
>>
>>
>>
>> Some output, this should be the same as reading your BASIC DATA section,
>> right? where am I going wrong here?
>
> Remember each set of pattern 4 is a rotation.
> Also in the first going out module set the largest last integer as identifying
> the last operation in the going out module. You will see that in the code.
> It finishes the read of the first sequence then goes and reads the second
> sequence for coming back in.
> I should have documented the code a little more with rem statments.
> In the coming back in sequence that is why the numbers are larger at the begining
> of that sequence that also has a unique 4 pattern of the integers in that sequence.
> I just sent a huge video of a square lattice in slow-mo.
> I hope this helps.
> ______________________________
>> ct_cairo_misc
>>
>> ct_dj_plotter::manifest()
>>
>> i[0] = 1 This is only run once then the 4 patterns for each set take over.
> ------------------------------------------------------------------------------------
[...]

So, 72 / 4 = 18

That is why you have 73 items in the DATA section?

;^D

On Wednesday, June 7, 2023 at 11:08:50 PM UTC-4, Dan joyce wrote:
> On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson wrote:
> > On 6/7/2023 6:56 PM, Dan joyce wrote:
> > > On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
> > >> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
> > >>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
> > >>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
> > >>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> > >>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> > [...]
> >
> > My code for this test on your work:
> > ______________________________
> > // DAN JOYCE PLOTTER TESTING 123... ;^)
> > //_____________________________________________________________
> > #include <array>
> >
> > namespace ct_dj_plotter
> > {
> > void
> > plot_arrow_line(
> > ct::plot::cairo::plot_2d& scene,
> > glm::vec2 p0,
> > glm::vec2 p1,
> > ct::plot::cairo::pixel color,
> > float thickness
> > ) {
> > glm::vec2 dif = p1 - p0;
> > glm::vec2 dif_perp = { dif.y, -dif.x };
> >
> > glm::vec2 arrow_origin = p0 + dif * .8f;
> >
> > glm::vec2 arrow_p0 = arrow_origin + dif_perp * .08f;
> > glm::vec2 arrow_p1 = arrow_origin - dif_perp * .08f;
> >
> > //scene.circle(arrow_origin, .01f, color, 3);
> > //scene.circle(arrow_p0, .01f, color, 3);
> > //scene.circle(arrow_p1, .01f, color, 3);
> >
> > scene.line(arrow_p0, p1, color, thickness);
> > scene.line(arrow_p1, p1, color, thickness);
> >
> > scene.line(p0, p1, color, thickness);
> > }
> >
> > struct direction
> > {
> > glm::vec2 m_normal;
> > glm::vec3 m_color;
> > };
> >
> >
> >
> >
> >
> > struct ct_basic_data
> > {
> > unsigned long m_index;
> > std::array<unsigned long, 72> m_basic_data;
> >
> > unsigned long
> > get()
> > {
> > if (m_index >= m_basic_data.size())
> > {
> > throw;
> > }
> >
> > return m_basic_data[m_index++];
> > }
> >
> > void
> > iterate()
> > {
> > for (unsigned long i = 0; i < m_basic_data.size(); ++i)
> > {
> > std::cout << "i[" << i << "] = " << m_basic_data[i] <<
> > "\n";
> > }
> > }
> > };
> >
> >
> >
> >
> > void
> > manifest(
> > ct::plot::cairo::plot_2d& scene
> > ) {
> > std::cout << "ct_dj_plotter::manifest()\n" << std::endl;
> >
> >
> > // BASIC data
> > ct_basic_data basic_data = {
> > 0,
> > {
> > 1,2,1,3,2,4,3,5,4,6,5,7,6,8,
> > 7,9,8,10,9,11,10,12,11,13,12,
> > 14,13,15,14,16,15,17,16,18,17,
> > 19,18,18,17,17,16,16,15,15,14,
> > 14,13,13,12,12,11,11,10,10,9,
> > 9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
> > 1,1
> > }
> > };
> > basic_data.iterate();
> > }
> > }
> > ______________________________
> >
> >
> >
> > Some output, this should be the same as reading your BASIC DATA section,
> > right? where am I going wrong here?
> Remember each set of pattern 4 is a rotation.
> Also in the first going out module set the largest last integer as identifying
> the last operation in the going out module. You will see that in the code..
> It finishes the read of the first sequence then goes and reads the second
> sequence for coming back in.
> I should have documented the code a little more with rem statments.
> In the coming back in sequence that is why the numbers are larger at the begining
> of that sequence that also has a unique 4 pattern of the integers in that sequence.
> I just sent a huge video of a square lattice in slow-mo.
> I hope this helps.
> ______________________________
> > ct_cairo_misc
> >
> > ct_dj_plotter::manifest()
> >
> > i[0] = 1 This is only run once then the 4 patterns for each set take over.
> ------------------------------------------------------------------------------------
> > i[1] = 2
> > i[2] = 1
> > i[3] = 3
> > i[4] = 2
> > i[5] = 4
> > i[6] = 3
> > i[7] = 5
> > i[8] = 4
> > i[9] = 6
> > i[10] = 5
> > i[11] = 7
> > i[12] = 6
> > i[13] = 8
> > i[14] = 7
> > i[15] = 9
> > i[16] = 8
> > i[17] = 10
> > i[18] = 9
> > i[19] = 11
> > i[20] = 10
> > i[21] = 12
> > i[22] = 11
> > i[23] = 13
> > i[24] = 12
> > i[25] = 14
> > i[26] = 13
> > i[27] = 15
> > i[28] = 14
> > i[29] = 16
> > i[30] = 15
> > i[31] = 17
> > i[32] = 16
> > i[33] = 18
> > i[34] = 17
> > i[35] = 19
> > i[36] = 18
> > i[37] = 18
> > i[38] = 17
> > i[39] = 17
> > i[40] = 16
> > i[41] = 16
> > i[42] = 15
> > i[43] = 15
> > i[44] = 14
> > i[45] = 14
> > i[46] = 13
> > i[47] = 13
> > i[48] = 12
> > i[49] = 12
> > i[50] = 11
> > i[51] = 11
> > i[52] = 10
> > i[53] = 10
> > i[54] = 9
> > i[55] = 9
> > i[56] = 8
> > i[57] = 8
> > i[58] = 7
> > i[59] = 7
> > i[60] = 6
> > i[61] = 6
> > i[62] = 5
> > i[63] = 5
> > i[64] = 4
> > i[65] = 4
> > i[66] = 3
> > i[67] = 3
> > i[68] = 2
> > i[69] = 2
> > i[70] = 1
> > i[71] = 1
> > ______________________________
If you could just post that video anywhere. I don't care where it will remove a lot of doubt.

On Wednesday, June 7, 2023 at 11:16:37 PM UTC-4, Chris M. Thomasson wrote:
> On 6/7/2023 8:08 PM, Dan joyce wrote:
> > On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson wrote:
> >> On 6/7/2023 6:56 PM, Dan joyce wrote:
> >>> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
> >>>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
> >>>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
> >>>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
> >>>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> >>>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> >> [...]
> >>
> >> My code for this test on your work:
> >> ______________________________
> >> // DAN JOYCE PLOTTER TESTING 123... ;^)
> >> //_____________________________________________________________
> >> #include <array>
> >>
> >> namespace ct_dj_plotter
> >> {
> >> void
> >> plot_arrow_line(
> >> ct::plot::cairo::plot_2d& scene,
> >> glm::vec2 p0,
> >> glm::vec2 p1,
> >> ct::plot::cairo::pixel color,
> >> float thickness
> >> ) {
> >> glm::vec2 dif = p1 - p0;
> >> glm::vec2 dif_perp = { dif.y, -dif.x };
> >>
> >> glm::vec2 arrow_origin = p0 + dif * .8f;
> >>
> >> glm::vec2 arrow_p0 = arrow_origin + dif_perp * .08f;
> >> glm::vec2 arrow_p1 = arrow_origin - dif_perp * .08f;
> >>
> >> //scene.circle(arrow_origin, .01f, color, 3);
> >> //scene.circle(arrow_p0, .01f, color, 3);
> >> //scene.circle(arrow_p1, .01f, color, 3);
> >>
> >> scene.line(arrow_p0, p1, color, thickness);
> >> scene.line(arrow_p1, p1, color, thickness);
> >>
> >> scene.line(p0, p1, color, thickness);
> >> }
> >>
> >> struct direction
> >> {
> >> glm::vec2 m_normal;
> >> glm::vec3 m_color;
> >> };
> >>
> >>
> >>
> >>
> >>
> >> struct ct_basic_data
> >> {
> >> unsigned long m_index;
> >> std::array<unsigned long, 72> m_basic_data;
> >>
> >> unsigned long
> >> get()
> >> {
> >> if (m_index >= m_basic_data.size())
> >> {
> >> throw;
> >> }
> >>
> >> return m_basic_data[m_index++];
> >> }
> >>
> >> void
> >> iterate()
> >> {
> >> for (unsigned long i = 0; i < m_basic_data.size(); ++i)
> >> {
> >> std::cout << "i[" << i << "] = " << m_basic_data[i] <<
> >> "\n";
> >> }
> >> }
> >> };
> >>
> >>
> >>
> >>
> >> void
> >> manifest(
> >> ct::plot::cairo::plot_2d& scene
> >> ) {
> >> std::cout << "ct_dj_plotter::manifest()\n" << std::endl;
> >>
> >>
> >> // BASIC data
> >> ct_basic_data basic_data = {
> >> 0,
> >> {
> >> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,
> >> 7,9,8,10,9,11,10,12,11,13,12,
> >> 14,13,15,14,16,15,17,16,18,17,
> >> 19,18,18,17,17,16,16,15,15,14,
> >> 14,13,13,12,12,11,11,10,10,9,
> >> 9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
> >> 1,1
> >> }
> >> };
> >> basic_data.iterate();
> >> }
> >> }
> >> ______________________________
> >>
> >>
> >>
> >> Some output, this should be the same as reading your BASIC DATA section,
> >> right? where am I going wrong here?
> >
> > Remember each set of pattern 4 is a rotation.
> > Also in the first going out module set the largest last integer as identifying
> > the last operation in the going out module. You will see that in the code.
> > It finishes the read of the first sequence then goes and reads the second
> > sequence for coming back in.
> > I should have documented the code a little more with rem statments.
> > In the coming back in sequence that is why the numbers are larger at the begining
> > of that sequence that also has a unique 4 pattern of the integers in that sequence.
> > I just sent a huge video of a square lattice in slow-mo.
> > I hope this helps.
> > ______________________________
> >> ct_cairo_misc
> >>
> >> ct_dj_plotter::manifest()
> >>
> >> i[0] = 1 This is only run once then the 4 patterns for each set take over.
> > ------------------------------------------------------------------------------------
> [...]
>
> So, 72 / 4 = 18
>
> That is why you have 73 items in the DATA section?
>
> ;^D
If you are talking about the first sequence because the first number is never
used again. Then it is just sets of 4 with a pattern for each rotation.

On 6/7/2023 8:17 PM, Dan joyce wrote:
> On Wednesday, June 7, 2023 at 11:08:50 PM UTC-4, Dan joyce wrote:
>> On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson wrote:
>>> On 6/7/2023 6:56 PM, Dan joyce wrote:
>>>> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
>>>>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
>>>>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
>>>>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
>>>>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
>>>>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
[...]
>>> void
>>> manifest(
>>> ct::plot::cairo::plot_2d& scene
>>> ) {
>>> std::cout << "ct_dj_plotter::manifest()\n" << std::endl;
>>>
>>>
>>> // BASIC data
>>> ct_basic_data basic_data = {
>>> 0,
>>> {
>>> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,
>>> 7,9,8,10,9,11,10,12,11,13,12,
>>> 14,13,15,14,16,15,17,16,18,17,
>>> 19,18,18,17,17,16,16,15,15,14,
>>> 14,13,13,12,12,11,11,10,10,9,
>>> 9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
>>> 1,1
>>> }
>>> };
>>> basic_data.iterate();
>>> }
>>> }
>>> ______________________________
[...]
>> ______________________________
>>> ct_cairo_misc
>>>
>>> ct_dj_plotter::manifest()
>>>
>>> i[0] = 1 This is only run once then the 4 patterns for each set take over.
>> ------------------------------------------------------------------------------------
>>> i[1] = 2
>>> i[2] = 1
>>> i[3] = 3
>>> i[4] = 2

[...]
>>> i[64] = 4
>>> i[65] = 4
>>> i[66] = 3
>>> i[67] = 3
>>> i[68] = 2
>>> i[69] = 2
>>> i[70] = 1
>>> i[71] = 1
>>> ______________________________
> If you could just post that video anywhere. I don't care where it will remove a lot of doubt.

I need to port the rest of your code over. I need to port your drawing
instructions. Then I can compare it with your animation.

On 6/7/2023 8:22 PM, Dan joyce wrote:
> On Wednesday, June 7, 2023 at 11:16:37 PM UTC-4, Chris M. Thomasson wrote:
>> On 6/7/2023 8:08 PM, Dan joyce wrote:
>>> On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson wrote:
>>>> On 6/7/2023 6:56 PM, Dan joyce wrote:
>>>>> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
>>>>>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
>>>>>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
>>>>>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
>>>>>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
>>>>>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
>>>> [...]
>>>>
>>>> My code for this test on your work:
>>>> ______________________________
>>>> // DAN JOYCE PLOTTER TESTING 123... ;^)
>>>> //_____________________________________________________________
>>>> #include <array>
>>>>
>>>> namespace ct_dj_plotter
>>>> {
>>>> void
>>>> plot_arrow_line(
>>>> ct::plot::cairo::plot_2d& scene,
>>>> glm::vec2 p0,
>>>> glm::vec2 p1,
>>>> ct::plot::cairo::pixel color,
>>>> float thickness
>>>> ) {
>>>> glm::vec2 dif = p1 - p0;
>>>> glm::vec2 dif_perp = { dif.y, -dif.x };
>>>>
>>>> glm::vec2 arrow_origin = p0 + dif * .8f;
>>>>
>>>> glm::vec2 arrow_p0 = arrow_origin + dif_perp * .08f;
>>>> glm::vec2 arrow_p1 = arrow_origin - dif_perp * .08f;
>>>>
>>>> //scene.circle(arrow_origin, .01f, color, 3);
>>>> //scene.circle(arrow_p0, .01f, color, 3);
>>>> //scene.circle(arrow_p1, .01f, color, 3);
>>>>
>>>> scene.line(arrow_p0, p1, color, thickness);
>>>> scene.line(arrow_p1, p1, color, thickness);
>>>>
>>>> scene.line(p0, p1, color, thickness);
>>>> }
>>>>
>>>> struct direction
>>>> {
>>>> glm::vec2 m_normal;
>>>> glm::vec3 m_color;
>>>> };
>>>>
>>>>
>>>>
>>>>
>>>>
>>>> struct ct_basic_data
>>>> {
>>>> unsigned long m_index;
>>>> std::array<unsigned long, 72> m_basic_data;
>>>>
>>>> unsigned long
>>>> get()
>>>> {
>>>> if (m_index >= m_basic_data.size())
>>>> {
>>>> throw;
>>>> }
>>>>
>>>> return m_basic_data[m_index++];
>>>> }
>>>>
>>>> void
>>>> iterate()
>>>> {
>>>> for (unsigned long i = 0; i < m_basic_data.size(); ++i)
>>>> {
>>>> std::cout << "i[" << i << "] = " << m_basic_data[i] <<
>>>> "\n";
>>>> }
>>>> }
>>>> };
>>>>
>>>>
>>>>
>>>>
>>>> void
>>>> manifest(
>>>> ct::plot::cairo::plot_2d& scene
>>>> ) {
>>>> std::cout << "ct_dj_plotter::manifest()\n" << std::endl;
>>>>
>>>>
>>>> // BASIC data
>>>> ct_basic_data basic_data = {
>>>> 0,
>>>> {
>>>> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,
>>>> 7,9,8,10,9,11,10,12,11,13,12,
>>>> 14,13,15,14,16,15,17,16,18,17,
>>>> 19,18,18,17,17,16,16,15,15,14,
>>>> 14,13,13,12,12,11,11,10,10,9,
>>>> 9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
>>>> 1,1
>>>> }
>>>> };
>>>> basic_data.iterate();
>>>> }
>>>> }
>>>> ______________________________
>>>>
>>>>
>>>>
>>>> Some output, this should be the same as reading your BASIC DATA section,
>>>> right? where am I going wrong here?
>>>
>>> Remember each set of pattern 4 is a rotation.
>>> Also in the first going out module set the largest last integer as identifying
>>> the last operation in the going out module. You will see that in the code.
>>> It finishes the read of the first sequence then goes and reads the second
>>> sequence for coming back in.
>>> I should have documented the code a little more with rem statments.
>>> In the coming back in sequence that is why the numbers are larger at the begining
>>> of that sequence that also has a unique 4 pattern of the integers in that sequence.
>>> I just sent a huge video of a square lattice in slow-mo.
>>> I hope this helps.
>>> ______________________________
>>>> ct_cairo_misc
>>>>
>>>> ct_dj_plotter::manifest()
>>>>
>>>> i[0] = 1 This is only run once then the 4 patterns for each set take over.
>>> ------------------------------------------------------------------------------------
>> [...]
>>
>> So, 72 / 4 = 18
>>
>> That is why you have 73 items in the DATA section?
>>
>> ;^D
> If you are talking about the first sequence because the first number is never
> used again. Then it is just sets of 4 with a pattern for each rotation.

I need to start porting your drawing functions from GWBASIC over to my
C++ program. I will show you the progress so you can tell me if I am on
the right track, so to speak, right?

On 6/7/2023 8:38 PM, Chris M. Thomasson wrote:
> On 6/7/2023 8:22 PM, Dan joyce wrote:
>> On Wednesday, June 7, 2023 at 11:16:37 PM UTC-4, Chris M. Thomasson
>> wrote:
>>> On 6/7/2023 8:08 PM, Dan joyce wrote:
>>>> On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson
>>>> wrote:
>>>>> On 6/7/2023 6:56 PM, Dan joyce wrote:
>>>>>> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson
>>>>>> wrote:
>>>>>>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
>>>>>>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M.
>>>>>>>> Thomasson wrote:
>>>>>>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
>>>>>>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes
>>>>>>>>>> Plutonium wrote:
>>>>>>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
[...]
>>>> ______________________________
>>>>> ct_cairo_misc
>>>>>
>>>>> ct_dj_plotter::manifest()
>>>>>
>>>>> i[0] = 1 This is only run once then the 4 patterns for each set
>>>>> take over.
>>>> ------------------------------------------------------------------------------------
>>> [...]
>>>
>>> So, 72 / 4 = 18
>>>
>>> That is why you have 73 items in the DATA section?
>>>
>>> ;^D
>> If you are talking about the first sequence because the first number
>> is never
>> used again. Then it is just sets of 4 with a pattern for each rotation.
>
> I need to start porting your drawing functions from GWBASIC over to my
> C++ program. I will show you the progress so you can tell me if I am on
> the right track, so to speak, right?

I will start with these drawing commands:
___________________________________________
10 CLS
20 G$=INKEY$:IF G$=""THEN 20
30 A=9.49:X=0
40 SCREEN 9
50 READ B
60 DRAW "R=A;
70 DRAW "U=A;
80 READ B
90 DRAW "L=A;
100 DRAW "D=A;
110 B=B-1:IF B=0 THEN 120 ELSE 90
120 READ B
130 DRAW "R=A;
140 DRAW "D=A;
150 B=B-1:IF B=0 THEN 160 ELSE 130
160 READ B
___________________________________________

The lines seems to work for this snippet of your code, 160, 120, 90, 20,
ect... Well, I will get to work pretty soon!

On 6/7/2023 8:40 PM, Chris M. Thomasson wrote:
> On 6/7/2023 8:38 PM, Chris M. Thomasson wrote:
>> On 6/7/2023 8:22 PM, Dan joyce wrote:
>>> On Wednesday, June 7, 2023 at 11:16:37 PM UTC-4, Chris M. Thomasson
>>> wrote:
>>>> On 6/7/2023 8:08 PM, Dan joyce wrote:
>>>>> On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson
>>>>> wrote:
>>>>>> On 6/7/2023 6:56 PM, Dan joyce wrote:
>>>>>>> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M.
>>>>>>> Thomasson wrote:
>>>>>>>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
>>>>>>>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M.
>>>>>>>>> Thomasson wrote:
>>>>>>>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
>>>>>>>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes
>>>>>>>>>>> Plutonium wrote:
>>>>>>>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> [...]
>>>>> ______________________________
>>>>>> ct_cairo_misc
>>>>>>
>>>>>> ct_dj_plotter::manifest()
>>>>>>
>>>>>> i[0] = 1 This is only run once then the 4 patterns for each set
>>>>>> take over.
>>>>> ------------------------------------------------------------------------------------
>>>> [...]
>>>>
>>>> So, 72 / 4 = 18
>>>>
>>>> That is why you have 73 items in the DATA section?
>>>>
>>>> ;^D
>>> If you are talking about the first sequence because the first number
>>> is never
>>> used again. Then it is just sets of 4 with a pattern for each rotation.
>>
>> I need to start porting your drawing functions from GWBASIC over to my
>> C++ program. I will show you the progress so you can tell me if I am
>> on the right track, so to speak, right?
>
> I will start with these drawing commands:
> ___________________________________________
> 10 CLS
> 20 G$=INKEY$:IF G$=""THEN 20
> 30 A=9.49:X=0
> 40 SCREEN 9
> 50 READ B
> 60 DRAW "R=A;
> 70 DRAW "U=A;
> 80 READ B
> 90 DRAW "L=A;
> 100 DRAW "D=A;
> 110 B=B-1:IF B=0 THEN 120 ELSE 90
> 120 READ B
> 130 DRAW "R=A;
> 140 DRAW "D=A;
> 150 B=B-1:IF B=0 THEN 160 ELSE 130
> 160 READ B
> ___________________________________________
>
> The lines seems to work for this snippet of your code, 160, 120, 90, 20,
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

I meant 130, not 120. Sorry. ;^o

AFAICT, this snippet of code can jump to lines:

20, 120, 90, 160, 130

Right? So, they are all self contained within this snippet. Right?

> ect... Well, I will get to work pretty soon!
>
>

On 6/7/2023 8:42 PM, Chris M. Thomasson wrote:
> On 6/7/2023 8:40 PM, Chris M. Thomasson wrote:
>> On 6/7/2023 8:38 PM, Chris M. Thomasson wrote:
>>> On 6/7/2023 8:22 PM, Dan joyce wrote:
>>>> On Wednesday, June 7, 2023 at 11:16:37 PM UTC-4, Chris M. Thomasson
>>>> wrote:
>>>>> On 6/7/2023 8:08 PM, Dan joyce wrote:
>>>>>> On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M.
>>>>>> Thomasson wrote:
>>>>>>> On 6/7/2023 6:56 PM, Dan joyce wrote:
>>>>>>>> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M.
>>>>>>>> Thomasson wrote:
>>>>>>>>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
>>>>>>>>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M.
>>>>>>>>>> Thomasson wrote:
>>>>>>>>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
>>>>>>>>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes
>>>>>>>>>>>> Plutonium wrote:
>>>>>>>>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
>> [...]
>>>>>> ______________________________
>>>>>>> ct_cairo_misc
>>>>>>>
>>>>>>> ct_dj_plotter::manifest()
>>>>>>>
>>>>>>> i[0] = 1 This is only run once then the 4 patterns for each set
>>>>>>> take over.
>>>>>> ------------------------------------------------------------------------------------
>>>>> [...]
>>>>>
>>>>> So, 72 / 4 = 18
>>>>>
>>>>> That is why you have 73 items in the DATA section?
>>>>>
>>>>> ;^D
>>>> If you are talking about the first sequence because the first number
>>>> is never
>>>> used again. Then it is just sets of 4 with a pattern for each rotation.
>>>
>>> I need to start porting your drawing functions from GWBASIC over to
>>> my C++ program. I will show you the progress so you can tell me if I
>>> am on the right track, so to speak, right?
>>
>> I will start with these drawing commands:
>> ___________________________________________
>> 10 CLS
>> 20 G$=INKEY$:IF G$=""THEN 20
>> 30 A=9.49:X=0
>> 40 SCREEN 9
>> 50 READ B
>> 60 DRAW "R=A;
>> 70 DRAW "U=A;
>> 80 READ B
>> 90 DRAW "L=A;
>> 100 DRAW "D=A;
>> 110 B=B-1:IF B=0 THEN 120 ELSE 90
>> 120 READ B
>> 130 DRAW "R=A;
>> 140 DRAW "D=A;
>> 150 B=B-1:IF B=0 THEN 160 ELSE 130
>> 160 READ B
>> ___________________________________________
>>
>> The lines seems to work for this snippet of your code, 160, 120, 90, 20,
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>
> I meant 130, not 120. Sorry. ;^o
>
> AFAICT, this snippet of code can jump to lines:
>
> 20, 120, 90, 160, 130
>
> Right? So, they are all self contained within this snippet. Right?
>
>> ect... Well, I will get to work pretty soon!

Shit. Been a while since I have read BASIC! Wow.

On Wednesday, June 7, 2023 at 11:23:30 PM UTC-4, Chris M. Thomasson wrote:
> On 6/7/2023 8:17 PM, Dan joyce wrote:
> > On Wednesday, June 7, 2023 at 11:08:50 PM UTC-4, Dan joyce wrote:
> >> On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson wrote:
> >>> On 6/7/2023 6:56 PM, Dan joyce wrote:
> >>>> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M. Thomasson wrote:
> >>>>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
> >>>>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M. Thomasson wrote:
> >>>>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
> >>>>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes Plutonium wrote:
> >>>>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> [...]
> >>> void
> >>> manifest(
> >>> ct::plot::cairo::plot_2d& scene
> >>> ) {
> >>> std::cout << "ct_dj_plotter::manifest()\n" << std::endl;
> >>>
> >>>
> >>> // BASIC data
> >>> ct_basic_data basic_data = {
> >>> 0,
> >>> {
> >>> 1,2,1,3,2,4,3,5,4,6,5,7,6,8,
> >>> 7,9,8,10,9,11,10,12,11,13,12,
> >>> 14,13,15,14,16,15,17,16,18,17,
> >>> 19,18,18,17,17,16,16,15,15,14,
> >>> 14,13,13,12,12,11,11,10,10,9,
> >>> 9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,
> >>> 1,1
> >>> }
> >>> };
> >>> basic_data.iterate();
> >>> }
> >>> }
> >>> ______________________________
> [...]
> >> ______________________________
> >>> ct_cairo_misc
> >>>
> >>> ct_dj_plotter::manifest()
> >>>
> >>> i[0] = 1 This is only run once then the 4 patterns for each set take over.
> >> ------------------------------------------------------------------------------------
> >>> i[1] = 2
> >>> i[2] = 1
> >>> i[3] = 3
> >>> i[4] = 2
> [...]
> >>> i[64] = 4
> >>> i[65] = 4
> >>> i[66] = 3
> >>> i[67] = 3
> >>> i[68] = 2
> >>> i[69] = 2
> >>> i[70] = 1
> >>> i[71] = 1
> >>> ______________________________
> > If you could just post that video anywhere. I don't care where it will remove a lot of doubt.
> I need to port the rest of your code over. I need to port your drawing
> instructions. Then I can compare it with your animation.
I know you will figure it out but any questions you have please ask becuase the code is a jumbled mess
with all the inkey$ to slow it down. I am going to add up all the integers in both sequences in a smaller
square lattice and then count all the single lines in that lattice and both integer numbers and line
numbers will have to match to prove there is no retrace of a line. Like more in the integer sun then total
lines. The new video is a better quality but nothing like you produce. This is off a 47" big screen tv.
I don't know if a hdmI1 hookup would do anything for me.

On Wednesday, June 7, 2023 at 11:42:32 PM UTC-4, Chris M. Thomasson wrote:
> On 6/7/2023 8:40 PM, Chris M. Thomasson wrote:
> > On 6/7/2023 8:38 PM, Chris M. Thomasson wrote:
> >> On 6/7/2023 8:22 PM, Dan joyce wrote:
> >>> On Wednesday, June 7, 2023 at 11:16:37 PM UTC-4, Chris M. Thomasson
> >>> wrote:
> >>>> On 6/7/2023 8:08 PM, Dan joyce wrote:
> >>>>> On Wednesday, June 7, 2023 at 10:22:24 PM UTC-4, Chris M. Thomasson
> >>>>> wrote:
> >>>>>> On 6/7/2023 6:56 PM, Dan joyce wrote:
> >>>>>>> On Wednesday, June 7, 2023 at 6:19:03 PM UTC-4, Chris M.
> >>>>>>> Thomasson wrote:
> >>>>>>>> On 6/6/2023 11:14 PM, Archimedes Plutonium wrote:
> >>>>>>>>> On Wednesday, June 7, 2023 at 12:32:31 AM UTC-5, Chris M.
> >>>>>>>>> Thomasson wrote:
> >>>>>>>>>> On 6/6/2023 6:03 PM, Archimedes Plutonium wrote:
> >>>>>>>>>>> On Tuesday, June 6, 2023 at 12:14:50 AM UTC-5, Archimedes
> >>>>>>>>>>> Plutonium wrote:
> >>>>>>>>>>>> On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> > [...]
> >>>>> ______________________________
> >>>>>> ct_cairo_misc
> >>>>>>
> >>>>>> ct_dj_plotter::manifest()
> >>>>>>
> >>>>>> i[0] = 1 This is only run once then the 4 patterns for each set
> >>>>>> take over.
> >>>>> ------------------------------------------------------------------------------------
> >>>> [...]
> >>>>
> >>>> So, 72 / 4 = 18
> >>>>
> >>>> That is why you have 73 items in the DATA section?
> >>>>
> >>>> ;^D
> >>> If you are talking about the first sequence because the first number
> >>> is never
> >>> used again. Then it is just sets of 4 with a pattern for each rotation.
> >>
> >> I need to start porting your drawing functions from GWBASIC over to my
> >> C++ program. I will show you the progress so you can tell me if I am
> >> on the right track, so to speak, right?
> >
> > I will start with these drawing commands:
> > ___________________________________________
> > 10 CLS
> > 20 G$=INKEY$:IF G$=""THEN 20
> > 30 A=9.49:X=0
> > 40 SCREEN 9
> > 50 READ B
> > 60 DRAW "R=A;
> > 70 DRAW "U=A;
> > 80 READ B
> > 90 DRAW "L=A;
> > 100 DRAW "D=A;
> > 110 B=B-1:IF B=0 THEN 120 ELSE 90
> > 120 READ B
> > 130 DRAW "R=A;
> > 140 DRAW "D=A;
> > 150 B=B-1:IF B=0 THEN 160 ELSE 130
> > 160 READ B
> > ___________________________________________
> >
> > The lines seems to work for this snippet of your code, 160, 120, 90, 20,
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>
> I meant 130, not 120. Sorry. ;^o
>
> AFAICT, this snippet of code can jump to lines:
>
> 20, 120, 90, 160, 130
>
> Right? So, they are all self contained within this snippet. Right?
> > ect... Well, I will get to work pretty soon!
> >
> >
You notice that line 50 and 60 and 70 are never used again.

On 6/7/2023 8:51 PM, Dan joyce wrote:
> On Wednesday, June 7, 2023 at 11:42:32 PM UTC-4, Chris M. Thomasson wrote:
[...]
>> AFAICT, this snippet of code can jump to lines:
>>
>> 20, 120, 90, 160, 130
>>
>> Right? So, they are all self contained within this snippet. Right?
>>> ect... Well, I will get to work pretty soon!
>>>
>>>
> You notice that line 50 and 60 and 70 are never used again.

Is this correct?

https://i.ibb.co/ZhXMY9p/image.png

Wrt the following instructions I ported so far into my C++ program?
______________
10 CLS
20 G$=INKEY$:IF G$=""THEN 20
30 A=9.49:X=0
40 SCREEN 9
50 READ B
60 DRAW "R=A;
70 DRAW "U=A;
80 READ B
90 DRAW "L=A;
100 DRAW "D=A;
______________

My coloring and normalized direction code is:
______________

struct direction
{ glm::vec2 m_normal;
ct::plot::cairo::pixel m_color;
};

// DIRECTION DATA
std::array<direction, 4> directions = {{
{ { 1, 0 }, CT_RGBF(1, 0, 0) }, // right, red
{ { 0, 1 }, CT_RGBF(0, 1, 0) }, // up, green
{ { -1, 0 }, CT_RGBF(0, 0, 1) }, // left, blue
{ { 0, -1 }, CT_RGBF(0, 1, 1) }, // down, cyan
}};
______________

Does that graphic look correct to you?

Thanks.

On 6/7/2023 9:05 PM, Chris M. Thomasson wrote:
> On 6/7/2023 8:51 PM, Dan joyce wrote:
>> On Wednesday, June 7, 2023 at 11:42:32 PM UTC-4, Chris M. Thomasson
>> wrote:
> [...]
>>> AFAICT, this snippet of code can jump to lines:
>>>
>>> 20, 120, 90, 160, 130
>>>
>>> Right? So, they are all self contained within this snippet. Right?
>>>> ect... Well, I will get to work pretty soon!
>>>>
>>>>
>> You notice that line 50 and 60 and 70 are never used again.
>
> Is this correct?
>
> https://i.ibb.co/ZhXMY9p/image.png

I increased the unit scale here, to make it bigger without zooming in...

https://i.ibb.co/n3HFsTR/image.png

>
> Wrt the following instructions I ported so far into my C++ program?
> ______________
> 10 CLS
> 20 G$=INKEY$:IF G$=""THEN 20
> 30 A=9.49:X=0
> 40 SCREEN 9
> 50 READ B
> 60 DRAW "R=A;
> 70 DRAW "U=A;
> 80 READ B
> 90 DRAW "L=A;
> 100 DRAW "D=A;
> ______________
>
> My coloring and normalized direction code is:
> ______________
>
> struct direction
> {
>     glm::vec2 m_normal;
>     ct::plot::cairo::pixel m_color;
> };
>
> // DIRECTION DATA
> std::array<direction, 4> directions = {{
>     { { 1, 0 }, CT_RGBF(1, 0, 0) }, // right, red
>     { { 0, 1 }, CT_RGBF(0, 1, 0)  }, // up, green
>     { { -1, 0 }, CT_RGBF(0, 0, 1)  }, // left, blue
>     { { 0, -1 }, CT_RGBF(0, 1, 1)  }, // down, cyan
> }};
> ______________
>
>
> Does that graphic look correct to you?
>
> Thanks.

On 6/7/2023 9:08 PM, Chris M. Thomasson wrote:
> On 6/7/2023 9:05 PM, Chris M. Thomasson wrote:
>> On 6/7/2023 8:51 PM, Dan joyce wrote:
>>> On Wednesday, June 7, 2023 at 11:42:32 PM UTC-4, Chris M. Thomasson
>>> wrote:
>> [...]
>>>> AFAICT, this snippet of code can jump to lines:
>>>>
>>>> 20, 120, 90, 160, 130
>>>>
>>>> Right? So, they are all self contained within this snippet. Right?
>>>>> ect... Well, I will get to work pretty soon!
>>>>>
>>>>>
>>> You notice that line 50 and 60 and 70 are never used again.
>>
>> Is this correct?
>>
>> https://i.ibb.co/ZhXMY9p/image.png
>
> I increased the unit scale here, to make it bigger without zooming in...
>
> https://i.ibb.co/n3HFsTR/image.png
[...]

It goes red, green, blue, cyan... Is this correct so far?

On 6/4/2023 10:18 AM, Dan joyce wrote:
> I know this sounds rediculus but, drawing an --->oo lattice
> because to draw this you have to come back in from --->oo
> to the origin or the center of this --->oo lattice.
[...]

This is ported up to line 160 in your GWBASIC code:

https://i.ibb.co/mDLYbg0/image.png

Looking good? Any mistakes?

On Sunday, June 4, 2023 at 12:18:14 PM UTC-5, Dan joyce wrote:
> I know this sounds rediculus but, drawing an --->oo lattice

Dan needs a little advice here in mathematics. Of course in the old days, in math you could whip out the word "infinity and infinite" at free will. But in new true blue Math, that slipshod old math is no longer acceptable.

So Dan Joyce needs to say-- what his infinite borderline is exactly , and not pretend it is "never ending". This slipshod attitude got Cantor and Godel and most everyone in Old Math, got them on the wrong side of the track.

Chris Thomasson the mosquito prick of math, when all his posts belong in --- art.talk. Help get Chris out of sci.math and into a more insane newsgroup where he can thrive.

On Wednesday, June 7, 2023 at 11:41:23 PM UTC-5, Chris M. Thomasson wrote:
> On 6/4/2023 10:18 AM, Dan joyce wrote:
> > I know this sounds rediculus but, drawing an --->oo lattice
> > because to draw this you have to come back in from --->oo
> > to the origin or the center of this --->oo lattice.
> [...]
>
> This is ported up to line 160 in your GWBASIC code:
>
> https://i.ibb.co/mDLYbg0/image.png
>
> Looking good? Any mistakes?

On 6/7/2023 9:41 PM, Chris M. Thomasson wrote:
> On 6/4/2023 10:18 AM, Dan joyce wrote:
>> I know this sounds rediculus but, drawing an --->oo lattice
>> because to draw this you have to come back in from --->oo
>> to the origin or the center of this --->oo lattice.
> [...]
>
> This is ported up to line 160 in your GWBASIC code:
>
> https://i.ibb.co/mDLYbg0/image.png
>
> Looking good? Any mistakes?
>

Ported up to line 220, looking right?

https://i.ibb.co/LCp6yQz/image.png

:^)