Original sentence: "Jumble this sentence then put it back in order."

Simple coding requirements:
has to be done in a loop
parse the original sentence into words
randomly jumble the words
concatenate them with spaces to form a new sentence string
print new sentence to screen
parse the new sentence and restore it
repeat

I haven't started yet, but I figure it's about 5-8 lines in python. Too
easy. So it has to be written in C.

I'm the judge.

I'm looking for 3 winning entries (including mine):
1) the fastest
2) the best
3) the fewest lines

The best might be the simplest, or the shortest, or the most innovative
use of C, etc. It's subjective, but I'll explain why I chose the best.

Obviously, you can't use anyone else's submission for ideas or tips
before submitting your own.

If you win all 3 categories, you're cola's King Of The Jumble.

On Thu, 7 Mar 2024 09:10:27 -0500, DFS wrote:

> I haven't started yet, but I figure it's about 5-8 lines in python. Too
> easy. So it has to be written in C.

https://nostarch.com/impracticalpythonprojects

I couldn't work up too much interest in the anagrams and cryptography
chapters but one exercise is the Union route Cipher.

https://programmingpraxis.com/2012/03/06/union-route-cipher/

Spice up your challenge! A point he makes with one of the more complex
ciphers is while code can do the grunt work human intervention is needed
to sort the fly shit from the pepper since you'll get grammatically
correct sentences like Chomsky's 'Colorless green ideas sleep furiously'.

On 3/7/2024 1:38 PM, rbowman wrote:
> On Thu, 7 Mar 2024 09:10:27 -0500, DFS wrote:
>
>> I haven't started yet, but I figure it's about 5-8 lines in python. Too
>> easy. So it has to be written in C.
>
>
> Spice up your challenge!

Once you try it, you'll see it doesn't need spice.

It's harder than you think to randomly shuffle the words in a shorter
sentence, so that each word ends up in a different position than it
started in.

Bring it!

On Fri, 8 Mar 2024 08:09:33 -0500, DFS wrote:

> It's harder than you think to randomly shuffle the words in a shorter
> sentence, so that each word ends up in a different position than it
> started in.
>
> Bring it!

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

int main(int argc, char** argv)
{ char* sentence = strdup("Once you try it, you'll see it doesn't need
spice.");
char* tokens[20];
int token_count = 0;
int i;
int j;
int slots;
int candidate;
int* indices;

for (tokens[token_count] = strtok(sentence, " ");
tokens[token_count];
tokens[token_count] = strtok(NULL, " "))
{
token_count++;
}

indices = malloc(token_count * sizeof(int));
for (i=0; i<token_count; i++) {
indices[i] = -1;
}
srand((unsigned int) time(NULL));
for (i=0, slots=0; slots<token_count; i++) {
candidate = rand() % token_count;
for (j=0; j<token_count; j++) {
if (indices[j] == candidate) {
break;
}
else if (indices[j] == -1) {
indices[slots++] = candidate;
break;
}
}
}
printf("\nshuffled:\n");
for (i=0; i<slots; i++) {
printf("%s ", tokens[indices[i]]);
}
printf("\noriginal: \n");
for (i=0; i<slots; i++) {
printf("%s ", tokens[i]);
}
printf("\n");

return 0;
}

../shuffle

shuffled:
doesn't you spice. try Once it, it need see you'll
original:
Once you try it, you'll see it doesn't need spice.

../shuffle

shuffled:
need it, spice. it you you'll see Once try doesn't
original:
Once you try it, you'll see it doesn't need spice.

Get enough monkeys running it and the shuffled sentence may be the same as
the original.

For production, I'd first count the tokens and allocate the tokens array
but I'm lazy. Further enhancements, allow the string to be entered on the
command line, read strings from a file and write shuffled strings to a
file, and so on.

Of course in Python you could use split and shuffle to abstract away all
the messiness.

On 3/8/2024 2:48 PM, rbowman wrote:
> On Fri, 8 Mar 2024 08:09:33 -0500, DFS wrote:
>
>> It's harder than you think to randomly shuffle the words in a shorter
>> sentence, so that each word ends up in a different position than it
>> started in.
>>
>> Bring it!

Thanks for doing it.

FYI:
--------------------------------------------------------------------------
~$ gcc jumble_rbowman.c -o jumble

jumble_rbowman.c: In function ‘main’:
jumble_rbowman.c:9:29: warning: missing terminating " character
9 | char* sentence = strdup("Once you try it, you'll see it
doesn't need
| ^
jumble_rbowman.c:9:29: error: missing terminating " character
9 | char* sentence = strdup("Once you try it, you'll see it
doesn't need
|
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
jumble_rbowman.c:10:1: error: ‘spice’ undeclared (first use in this
function)
10 | spice.");
| ^~~~~
jumble_rbowman.c:10:1: note: each undeclared identifier is reported only
once for each function it appears in
jumble_rbowman.c:10:7: warning: missing terminating " character
10 | spice.");
| ^
jumble_rbowman.c:10:7: error: missing terminating " character
10 | spice.");
| ^~~
jumble_rbowman.c:11:5: error: expected identifier before ‘char’
11 | char* tokens[20];
| ^~~~
jumble_rbowman.c:54:1: error: expected ‘,’ or ‘;’ before ‘}’ token
54 | }
| ^
jumble_rbowman.c:54:1: error: expected declaration or statement at end
of input
--------------------------------------------------------------------------

> #include <stdio.h>
> #include <stdlib.h>
> #include <string.h>
> #include <time.h>
>
> int main(int argc, char** argv)
> {
> char* sentence = strdup("Once you try it, you'll see it doesn't need
> spice.");
> char* tokens[20];
> int token_count = 0;
> int i;
> int j;
> int slots;
> int candidate;
> int* indices;
>
> for (tokens[token_count] = strtok(sentence, " ");
> tokens[token_count];
> tokens[token_count] = strtok(NULL, " "))
> {
> token_count++;
> }
>
> indices = malloc(token_count * sizeof(int));
> for (i=0; i<token_count; i++) {
> indices[i] = -1;
> }
> srand((unsigned int) time(NULL));
> for (i=0, slots=0; slots<token_count; i++) {
> candidate = rand() % token_count;
> for (j=0; j<token_count; j++) {
> if (indices[j] == candidate) {
> break;
> }
> else if (indices[j] == -1) {
> indices[slots++] = candidate;
> break;
> }
> }
> }
> printf("\nshuffled:\n");
> for (i=0; i<slots; i++) {
> printf("%s ", tokens[indices[i]]);
> }
> printf("\noriginal: \n");
> for (i=0; i<slots; i++) {
> printf("%s ", tokens[i]);
> }
> printf("\n");
>
> return 0;
> }
>
> ./shuffle
>
> shuffled:
> doesn't you spice. try Once it, it need see you'll
> original:
> Once you try it, you'll see it doesn't need spice.
>
> ./shuffle
>
> shuffled:
> need it, spice. it you you'll see Once try doesn't
> original:
> Once you try it, you'll see it doesn't need spice.
>
> Get enough monkeys running it and the shuffled sentence may be the same as
> the original.
>
> For production, I'd first count the tokens and allocate the tokens array
> but I'm lazy. Further enhancements, allow the string to be entered on the
> command line, read strings from a file and write shuffled strings to a
> file, and so on.
>
> Of course in Python you could use split and shuffle to abstract away all
> the messiness.
>
>
>
>

On 3/8/2024 3:22 PM, DFS wrote:
> On 3/8/2024 2:48 PM, rbowman wrote:
>> On Fri, 8 Mar 2024 08:09:33 -0500, DFS wrote:
>>
>>> It's harder than you think to randomly shuffle the words in a shorter
>>> sentence, so that each word ends up in a different position than it
>>> started in.
>>>
>>> Bring it!
>
>
> Thanks for doing it.
>
>
> FYI:
> --------------------------------------------------------------------------
> ~$ gcc jumble_rbowman.c -o jumble
>
> jumble_rbowman.c: In function ‘main’:
> jumble_rbowman.c:9:29: warning: missing terminating " character
>     9 |     char* sentence = strdup("Once you try it, you'll see it
> doesn't need
>       |                             ^
> jumble_rbowman.c:9:29: error: missing terminating " character
>     9 |     char* sentence = strdup("Once you try it, you'll see it
> doesn't need
>       | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> jumble_rbowman.c:10:1: error: ‘spice’ undeclared (first use in this
> function)
>    10 | spice.");
>       | ^~~~~
> jumble_rbowman.c:10:1: note: each undeclared identifier is reported only
> once for each function it appears in
> jumble_rbowman.c:10:7: warning: missing terminating " character
>    10 | spice.");
>       |       ^
> jumble_rbowman.c:10:7: error: missing terminating " character
>    10 | spice.");
>       |       ^~~
> jumble_rbowman.c:11:5: error: expected identifier before ‘char’
>    11 |     char* tokens[20];
>       |     ^~~~
> jumble_rbowman.c:54:1: error: expected ‘,’ or ‘;’ before ‘}’ token
>    54 | }
>       | ^
> jumble_rbowman.c:54:1: error: expected declaration or statement at end
> of input
> --------------------------------------------------------------------------

Sorry. That's ALL from a crlf inserted by the newsreader. It compiled
cleanly after I took it out.

On 3/8/2024 2:48 PM, rbowman wrote:
> On Fri, 8 Mar 2024 08:09:33 -0500, DFS wrote:
>
>> It's harder than you think to randomly shuffle the words in a shorter
>> sentence, so that each word ends up in a different position than it
>> started in.
>>
>> Bring it!
>
> #include <stdio.h>
> #include <stdlib.h>
> #include <string.h>
> #include <time.h>
>
> int main(int argc, char** argv)
> {
> char* sentence = strdup("Once you try it, you'll see it doesn't need
> spice.");
> char* tokens[20];
> int token_count = 0;
> int i;
> int j;
> int slots;
> int candidate;
> int* indices;
>
> for (tokens[token_count] = strtok(sentence, " ");
> tokens[token_count];
> tokens[token_count] = strtok(NULL, " "))
> {
> token_count++;
> }
>
> indices = malloc(token_count * sizeof(int));
> for (i=0; i<token_count; i++) {
> indices[i] = -1;
> }
> srand((unsigned int) time(NULL));
> for (i=0, slots=0; slots<token_count; i++) {
> candidate = rand() % token_count;
> for (j=0; j<token_count; j++) {
> if (indices[j] == candidate) {
> break;
> }
> else if (indices[j] == -1) {
> indices[slots++] = candidate;
> break;
> }
> }
> }
> printf("\nshuffled:\n");
> for (i=0; i<slots; i++) {
> printf("%s ", tokens[indices[i]]);
> }
> printf("\noriginal: \n");
> for (i=0; i<slots; i++) {
> printf("%s ", tokens[i]);
> }
> printf("\n");
>
> return 0;
> }
>
> ./shuffle
>
> shuffled:
> doesn't you spice. try Once it, it need see you'll
> original:
> Once you try it, you'll see it doesn't need spice.
>
> ./shuffle
>
> shuffled:
> need it, spice. it you you'll see Once try doesn't
> original:
> Once you try it, you'll see it doesn't need spice.

------------------------------------------------------------
~$ ./shuffle
slot = 0, candidate = 1
slot = 1, candidate = 8
slot = 2, candidate = 2 (match)
slot = 3, candidate = 7
slot = 4, candidate = 9
slot = 5, candidate = 5 (match)
slot = 6, candidate = 4
slot = 7, candidate = 6
slot = 8, candidate = 0
slot = 9, candidate = 3

original: Once you try it, you'll see it doesn't need spice.
shuffled: you need try doesn't spice. see you'll it Once it,
------------------------------------------------------------

Some words weren't shuffled. Your bank acct is now hacked.

When I was writing my version yesterday (see below), I found ~8% of the
rands matched when the sentence was short.

Double the length of the sentence and the percent of matches falls to
around 5%.

> Get enough monkeys running it and the shuffled sentence may be the same as
> the original.

That would = bad programming.

> For production, I'd first count the tokens and allocate the tokens array
> but I'm lazy. Further enhancements, allow the string to be entered on the
> command line, read strings from a file and write shuffled strings to a
> file, and so on.

I usually try to take command line inputs. Makes the program easier to
test and fun to use.

> Of course in Python you could use split and shuffle to abstract away all
> the messiness.

It amazes me how productive Python can be versus C.

my code
----------------------------------------------------------------------

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

//usage $./prog "sentence in quotes" N-jumbles

//is dest already set in the array
int found(int dest,int rarr[], int cnt) {
int match = 0;
for (int j = 0; j < cnt; j++) {
if (dest == rarr[j]) {match = 1;break;}
}
return match;
}

int main(int argc, char *argv[]) {

int i = 0, j = 0, k = 0;
char *orig = argv[1];
int loops = atoi(argv[2]);
//count words = number of spaces + 1
int wordcnt = 1;
for (int i = 0; i < strlen(orig); i++) {
if(isspace(orig[i]) && !isspace(orig[i+1])) {wordcnt++;}
}

//arrays to hold words and numbers
char **words = malloc(sizeof(char*) * wordcnt);
char **temp = malloc(sizeof(char*) * wordcnt);
int randarr[wordcnt];
for(int i = 0; i < wordcnt ; randarr[i++] = wordcnt + 1);

//split string copy on space, add words to array
char *copy = strdup(orig);
const char delimiter[] = " ";
char *token = strtok(copy, delimiter);
while (token != NULL) {
words[i++] = token;
token = strtok(NULL, delimiter);
}

//show word count
printf(" %d words\n",wordcnt);

//print original sentence
printf("---------------------------------------------------\n");
printf(" %s\n",orig);
printf("---------------------------------------------------\n");
//generate randoms until each word moves to a different position
srand(time(NULL));
int src,dest,fdest;
int totmatches = 0;
k = 1;
while (k <= loops) {
for (int src = 0; src < wordcnt; src++) {
dest = rand() % wordcnt;

//printf("src=%d,dest=%d,found=%d\n",src,dest,found(dest,randarr,wordcnt));
while (1)
{
fdest = found(dest,randarr,wordcnt);
if ((src != dest && fdest == 0) || (src == dest && src ==
(wordcnt-1) && fdest == 0))
{
randarr[src] = dest;
temp[dest] = words[src];
break;
}
else
{
dest = rand() % wordcnt;

//printf("src=%d,dest=%d,found=%d\n",src,dest,found(dest,randarr,wordcnt));
}
}
}

//print jumbled indices and values in arrays
//for(j = 0; j < wordcnt; j++) {
//printf("%d %d %10s %10s\n",j,randarr[j],words[j],temp[j]);
//}

//print jumbled sentence
printf("%2d. ",k);
int matches = 0;
for(j = 0; j < wordcnt; j++) {
printf("%s ",temp[j]);
if (temp[j] == words[j]) {matches++;totmatches++;}
}
if (matches > 0) {printf(" %d match\n",matches);} else {printf("\n");}

//reset arrays
memset(temp, 0, wordcnt * sizeof(temp));
for(int j = 0; j < wordcnt ; randarr[j++] = 999);

k++;
}
printf("---------------------------------------------------\n");
printf("Total matches = %d\n",totmatches);

free(words);
free(temp);
return(0);
}

----------------------------------------------------------------------

~$ ./jumble "Jumble this sentence then put it back in order" 10
9 words
---------------------------------------------------
Jumble this sentence then put it back in order
---------------------------------------------------
1. then put Jumble sentence in this it back order 1 match
2. order in Jumble put back sentence then it this
3. this back in order sentence Jumble it put then
4. put Jumble order it then this sentence back in
5. sentence order then Jumble in this it put back
6. back in it this Jumble sentence order then put
7. put Jumble back it in then order this sentence
8. it order back in this put then Jumble sentence
9. sentence order put Jumble back this in it then
10. it sentence back put then in Jumble this order 1 match
---------------------------------------------------
Total matches = 2

You'll note in mine the match is always the last word of the input. I'm
gonna put in a little kludge to fix that: swap the last word for a
randomly chosen earlier one. That'll make for a 'perfect' jumble.

Thanks for participating. I was about to cancel the challenge for lack
of interest. Our code isn't quite done, since one of the requirements
was to concatenate the tokens, then print. And then split the jumbled
one apart and reconstitute it. Mostly useless exercises, I now realize.

Your code is shorter than mine, but mine takes 2 command line inputs and
prints more information.

On Fri, 8 Mar 2024 15:22:06 -0500, DFS wrote:

> FYI:

Obviously you didn't put it back together after word wrap broke it up.

gcc -pedantic -Wall -Wcast-qual -Wmissing-prototypes -Wshadow shuffle.c -
o shuffle

runs with no errors or warnings. If you throw in -std=c99

gcc -std=c99 shuffle.c -o shuffle
shuffle.c: In function ‘main’:
shuffle.c:8:22: warning: implicit declaration of function ‘strdup’; did
you mean ‘strcmp’? [-Wimplicit-function-declaration]
8 | char* sentence = strdup("Once you try it, you'll see it
doesn't need spice.");
| ^~~~~~
| strcmp
shuffle.c:8:22: warning: initialization of ‘char *’ from ‘int’ makes
pointer from integer without a cast [-Wint-conversion]

Why? you might ask? ISO C99 doesn't include strdup although it's strange
it pulls strcmp out of its ass.

gcc -std=gnu99 shuffle.c -o shuffle

works fine.

On 9 Mar 2024 02:48:10 GMT, rbowman <bowman@montana.com> wrote in
<l520v9FqgibU5@mid.individual.net>:

> On Fri, 8 Mar 2024 15:22:06 -0500, DFS wrote:
>
>> FYI:
>
> Obviously you didn't put it back together after word wrap broke it up.
>
> gcc -pedantic -Wall -Wcast-qual -Wmissing-prototypes -Wshadow shuffle.c
> - o shuffle
>
> runs with no errors or warnings. If you throw in -std=c99
>
> gcc -std=c99 shuffle.c -o shuffle shuffle.c: In function ‘main’:
> shuffle.c:8:22: warning: implicit declaration of function ‘strdup’; did
> you mean ‘strcmp’? [-Wimplicit-function-declaration]
> 8 | char* sentence = strdup("Once you try it, you'll see it
> doesn't need spice.");
> | ^~~~~~
> | strcmp
> shuffle.c:8:22: warning: initialization of ‘char *’ from ‘int’ makes
> pointer from integer without a cast [-Wint-conversion]
>
> Why? you might ask? ISO C99 doesn't include strdup although it's strange
> it pulls strcmp out of its ass.

What about:
char sentence[] = "Once you try it, you'll see it doesn't need spice.";

?

>
> gcc -std=gnu99 shuffle.c -o shuffle
>
> works fine.

--
-v

On Fri, 8 Mar 2024 15:41:13 -0500, DFS wrote:

> Sorry. That's ALL from a crlf inserted by the newsreader. It compiled
> cleanly after I took it out.

Yup...

In production code I'd likely do

char* sentence;

sentence = strdup("Once you try it, you'll see it doesn't need spice.");
if (sentence == NULL) {
printf("strdup() failed: %s", strerror(errno));
return -1;
}

Admittedly is the implied malloc() failed the odds of it printing anything
aren't great but might as well try. I probably would use strtok_r() in
production if there was a remote possibility that there would be another
nested strtok(). That's ruined more than one programmer's day.

It does make one appreciate Python when you're not scrambling for the last
nanosecond. I recently came across an article about MicroPython on the
Pico by someone who hung a logic analyzer on an output. The first
observation was

def Blink():
While True:
pin.on()
pin.off()

Blink()

was faster than an in-line

While True:
pin.on()
pin.off()

The second observation was if you were working with nanoseconds it was
time to move to C. No surprise on the second but apparently the generated
code is a little better optimized in a function.

On 9 Mar 2024 03:14:10 GMT, rbowman <bowman@montana.com> wrote in
<l522g2FqgibU6@mid.individual.net>:

> On Fri, 8 Mar 2024 15:41:13 -0500, DFS wrote:
>
>> Sorry. That's ALL from a crlf inserted by the newsreader. It compiled
>> cleanly after I took it out.
>
> Yup...
>
> In production code I'd likely do
>
> char* sentence;
>
> sentence = strdup("Once you try it, you'll see it doesn't need spice.");
> if (sentence == NULL) {
> printf("strdup() failed: %s", strerror(errno));
> return -1;
> }

Seems like a lot of work that could be handled by
char sentence[] = "initializer";

Am I missing something?

>
> Admittedly is the implied malloc() failed the odds of it printing
> anything aren't great but might as well try. I probably would use
> strtok_r() in production if there was a remote possibility that there
> would be another nested strtok(). That's ruined more than one
> programmer's day.
>

--
-v

On Sat, 9 Mar 2024 03:31:26 -0000 (UTC), vallor wrote:

> Seems like a lot of work that could be handled by char sentence[] =
> "initializer";
>
> Am I missing something?

No, that works too. Force of habit for me. In a more complicated scenario
if you had

void jumble(char* phrase)
{ char* sentence = strdup(phrase);
....
}

you would preserve phrase. In this case after the strtoks if you

printf("%s\n", sentence);

you would get 'Once' since strtok() inserts '\0' after each token.

On Sat, 9 Mar 2024 03:01:37 -0000 (UTC), vallor wrote:

> What about:
> char sentence[] = "Once you try it, you'll see it doesn't need spice.";

That would work for C99 since there isn't a strdup(). In this case, no
problem.

On Fri, 8 Mar 2024 20:53:08 -0500, DFS wrote:

> Thanks for participating. I was about to cancel the challenge for lack
> of interest. Our code isn't quite done, since one of the requirements
> was to concatenate the tokens, then print. And then split the jumbled
> one apart and reconstitute it. Mostly useless exercises, I now realize.

I don't see how that would work without maintaining the original state.
You can't unscramble eggs. A cipher's output isn't random.

On 3/8/2024 11:32 PM, rbowman wrote:
> On Fri, 8 Mar 2024 20:53:08 -0500, DFS wrote:
>
>> Thanks for participating. I was about to cancel the challenge for lack
>> of interest. Our code isn't quite done, since one of the requirements
>> was to concatenate the tokens, then print. And then split the jumbled
>> one apart and reconstitute it. Mostly useless exercises, I now realize.
>
> I don't see how that would work without maintaining the original state.
> You can't unscramble eggs. A cipher's output isn't random.

Yes, you have the original. And you have the shuffled, so you can
parse them again and use strcmp's.

Or, I created an array during the scrambling, ie

int randarr[9] now holds 304618527

This tells me (0-based indexing):
word 3 in the jumble goes back to position 0
word 0 goes to position 1
word 4 goes to position 2
word 6 goes to position 3
word 1 goes to position 4
word 8 goes to position 5
word 5 goes to position 6
word 2 goes to position 7
word 7 goes to position 8

On 3/7/2024 1:38 PM, rbowman wrote:
> On Thu, 7 Mar 2024 09:10:27 -0500, DFS wrote:
>
>> I haven't started yet, but I figure it's about 5-8 lines in python. Too
>> easy. So it has to be written in C.
>
> https://nostarch.com/impracticalpythonprojects
>
> I couldn't work up too much interest in the anagrams and cryptography
> chapters but one exercise is the Union route Cipher.
>
> https://programmingpraxis.com/2012/03/06/union-route-cipher/
>
> Spice up your challenge! A point he makes with one of the more complex
> ciphers is while code can do the grunt work human intervention is needed
> to sort the fly shit from the pepper since you'll get grammatically
> correct sentences like Chomsky's 'Colorless green ideas sleep furiously'.

I did one like this 22 years ago:
https://programmingpraxis.com/2009/08/07/adfgx/

Wrote a working VB app to demo it.
https://imgur.com/a/A4FPlOC

rbowman wrote this copyrighted missive and expects royalties:

> On Fri, 8 Mar 2024 20:53:08 -0500, DFS wrote:
>
>> Thanks for participating. I was about to cancel the challenge for lack
>> of interest. Our code isn't quite done, since one of the requirements
>> was to concatenate the tokens, then print. And then split the jumbled
>> one apart and reconstitute it. Mostly useless exercises, I now realize.
>
> I don't see how that would work without maintaining the original state.
> You can't unscramble eggs. A cipher's output isn't random.

Ask the poster named "%" about that :-)

Heh heh:

--
....people came to the land; the land loved them; they worked and struggled and
had lots of children. There was a Frenchman who talked funny and a greenhorn
from England who was a fancy-pants but when it came to the crunch he was all
courage. Those novels would make you retch.
-- Canadian novelist Robertson Davies, on the generic Canadian novel.

https://arstechnica.com/information-technology/2024/03/matrix-
multiplication-breakthrough-could-lead-to-faster-more-efficient-ai-models/

Now here's a real challenge for the mathematicians in cola... Can you
beat an ω of 2.371552?

rbowman wrote this copyrighted missive and expects royalties:

> https://arstechnica.com/information-technology/2024/03/matrix-multiplication-breakthrough-could-lead-to-faster-more-efficient-ai-models/
>
> Now here's a real challenge for the mathematicians in cola... Can you
> beat an ω of 2.371552?

Yeah, I can beat matrix experts easily... not.

I don't believe there are any COLA mathematicians in COLA. Some dilettantes,
sure.

--
Q: What do you call a boomerang that doesn't come back?
A: A stick.

On Sat, 9 Mar 2024 18:14:32 -0500, Chris Ahlstrom wrote:

> rbowman wrote this copyrighted missive and expects royalties:
>
>> https://arstechnica.com/information-technology/2024/03/matrix-
multiplication-breakthrough-could-lead-to-faster-more-efficient-ai-models/
>>
>> Now here's a real challenge for the mathematicians in cola... Can you
>> beat an ω of 2.371552?
>
> Yeah, I can beat matrix experts easily... not.

https://en.wikipedia.org/wiki/Convolutional_neural_network

Gems like that are what make minute improvements important. I have a
general understanding of what goes on in a CNN. Lucky for code monkeys
like me people who really know what they're doing package it up in Torch,
TensorFlow, and so forth.

Image processing has some uses that aren't intuitive. For wake words like
'alexa' you digitize the audio signal, run STFTs over a sliding windows,
maybe throw in mel filters to emphasize human speech characteristics, and
produce a spectrogram. Image classification is a well trodden path so you
train your model with spectrograms of many different people saying
'alexa', boil it down until you can do inferences on the local device and
you're good to go. Once the device wakes up speech processing gets shipped
off to a server. One goal is to be able to do more locally and avoid the
expense and security problems.

Fortunately you can change the wake word from 'alexa'. I asked one of our
QA people who goes by 'Alex' and she said she changed it to 'echo'. The
other choices are 'amazon' or 'computer'.

Again lucky for me there are nicely packaged libraries for all this good
stuff too.

https://github.com/mborgerding/kissfft

KISS-FFT would be a sacrilege to PhysfitFreak.

"It is wonderful that free, highly optimized libraries like FFT_BRANDX
exist. But such libraries carry a huge burden of complexity necessary to
extract every last bit of performance.

Sometimes simpler is better, even if it's not better."

Microprocessors don't have a lot of SRAM/RAM and many don't have a FPU. If
simple gets the job done processing audio signals it's definitely good
enough.

On Sat, 09 Mar 2024 21:08:32 -0800 (Seattle), Relf wrote:

> Truth is, 16-bit floating-point is gaining popularity in machine
> learning ( due to its efficiency ).

The newer microcontrollers make it feasible even in your toasted :) Even
some of the Cortex M4s have a FPU.

https://en.wikipedia.org/wiki/ARM_Cortex-M

The RPi Pico that was sitting on my deck when I got home is only a M0+ but
it's a whole different class than the Arduino Unos. So far I've only
loaded MicroPython and did the blink thing using Thonny.

Thonny is no VS Code and it does have that annoying

- Thonny 4 is dedicated to Ukraine fighting the Russian invasion. 🇺🇦
Please support Ukraine! 🇺🇦

crap but it's a quick and dirty way to make sure everything is working.

rbowman wrote this copyrighted missive and expects royalties:

> <brevsnip>
>
> Again lucky for me there are nicely packaged libraries for all this good
> stuff too.
>
> https://github.com/mborgerding/kissfft
>
> KISS-FFT would be a sacrilege to PhysfitFreak.
>
> "It is wonderful that free, highly optimized libraries like FFT_BRANDX
> exist. But such libraries carry a huge burden of complexity necessary to
> extract every last bit of performance.
>
> Sometimes simpler is better, even if it's not better."
>
> Microprocessors don't have a lot of SRAM/RAM and many don't have a FPU. If
> simple gets the job done processing audio signals it's definitely good
> enough.

The lack of an integer implementation kept Ogg from overtaking MP3, IIRC.

--
You plan things that you do not even attempt because of your extreme caution.

On 3/10/2024 12:08 AM, Relf wrote:

> DFS, by the way, avoids floating-point like the plague;

It's rarely a conscious decision.

> when he DARES to dip his toe into the pool, it's 64-bit.

On Sat, 09 Mar 2024 23:32:35 -0800 (Seattle), Relf wrote:

> rBowman:
>> [ My 4 $ RPi Pico makes ] sure everything is working.
>
> Could you give us some examples ?

Of the tool chain? The first step is to download the latest MicroPython
package:

https://micropython.org/download/RPI_PICO/

When you hold down the boot seelct button while plugging the device into
the USB bus it shows up in Dolphin as a mass storage device with what I
guess is meant to be a Raspberry Pi icon. You copy the u2e file to the
device and it resets.

Next, start Thonny and make sure it sees the device. I'd never used Thonny
and that was a little different. By default is shows the Python installed
on the host machine, but clicking on the lower left corner brings up a
selection where you can pick the MicroPython on the device. There is a
REPL pane where you can run simple commands.

The device shows up as /dev/ttyACM0 and may require setting group
permissions to access. I haven't tried plugging in an Arduino or another
device but I assume that would show as ttyACM1 (ACM -- abstract control
model) and you'd have to sort out which was which.

I've got the Pico W with Wifi so that's a little different than the plain
Pico. The on board LED is associated with the Wifi chip and not a separate
pin. A lot of the online sites like

https://projects.raspberrypi.org/en/projects/getting-started-with-the-
pico/5

show

from machine import Pin
led = Pin(25, Pin.OUT)

led.toggle()

which does not work with the W. It needs to be 'led = Pin("LED", Pin.OUT).

Then you can do a simple script in the Thonny editor

from machine import Pin
from time import sleep

led = Pin("LED", Pin.OUT)
while True:
led.value(1)
sleep(0.5)
led.value(0)
sleep(0.5)

The Run button transfers the script to the device and it blinks. That's
the 'hello world' of the uP world. There's a lot of other things to check
out

https://docs.micropython.org/en/latest/rp2/quickref.html

The Pico doesn't have a lot of goodies on board so after the simple blink
you need to start wiring it up.

https://peppe8o.com/using-gyroscope-and-accelerometer-with-mpu6050-
raspberry-pi-pico-and-micropython/

The Arduino Nano 33 BLE Sense has a similar form factor and a lot more
included on the board.

https://gilberttanner.com/blog/arduino-nano-33-ble-sense-overview/

Prices are volatile since there are a lot of clones in the market but a
Nano is roughly $40 and a Pico under $10. The Core M4 is a little better
than the M0+ too. It all depends on what you want to do. For example a
remote controller with a thumb joystick and a nRF24L01 transceiver would
require external parts for both so you might as well go cheap. For a
project where you need an IMU the Nano may come out cheaper and will be
easier to package without the external boards. Same for a remote weather
station where the Nano has temperature, pressure, and humidity sensors on
board.

Programming is similar and you can use C/C++ or MicroPython with both. I
know the Nano can use the Mbed RTOS but I'm not sure about the Pico.

On Sun, 10 Mar 2024 20:03:44 -0700 (Seattle), Relf wrote:

> I'd hate to think that you wasted 4 $, rBowman.

Don't fucking worry your little head about it.

> How does your Pico "make sure everything is working" ?

You don't have a clue about setting up a tool chain do you?