So I was bored in a meeting and decided to implement a generic template for defining complex numbers, dual numbers, quaternions and many other possible algebras by simply defining a set of rules and the components on which they act:


alias quaternion = Algebra!(
        float,
        "1,i,j,k",
        op("1",     any)  = any,
        op("i,j,k", self) = "-1",
        op("i",     "j")  = "k".antiCommutative,
        op("j",     "k")  = "i".antiCommutative,
        op("k",     "i")  = "j".antiCommutative,
    );

source:

https://gist.github.com/Biotronic/833680b37d4afe774c8562fd21554c6b

--
  Simen

On Thursday, 8 February 2018 at 15:23:05 UTC, Simen Kjærås wrote:
> So I was bored in a meeting and decided to implement a generic template for defining complex numbers, dual numbers, quaternions and many other possible algebras by simply defining a set of rules and the components on which they act:
>
>
> alias quaternion = Algebra!(
>         float,
>         "1,i,j,k",
>         op("1",     any)  = any,
>         op("i,j,k", self) = "-1",
>         op("i",     "j")  = "k".antiCommutative,
>         op("j",     "k")  = "i".antiCommutative,
>         op("k",     "i")  = "j".antiCommutative,
>     );
>
> source:
>
> https://gist.github.com/Biotronic/833680b37d4afe774c8562fd21554c6b
>
> --
>   Simen

It would be nice if you learned how to document your code. It's not always easy for someone on the outside to be able to pick it up and it ultimately means your hard work will be less used as it could be. I know that sometimes comments can be redundant but it can also provide a better understanding.

For example, it seems that you are using a group presentation to define the a algebra... but a few examples are not enough to provide a complete context in what it can be used for besides the example. This requires understanding the details in detail, which can be too time consuming for some. For example, can it be used to define an algebra on sets? If not, could it be modified to do so easily? To answer that one probably has to know how the code works in detail... which means spending time, which then goes to if it is worth it over a new implementation, etc.

On 02/08/2018 04:37 PM, Amorphorious wrote:
> On Thursday, 8 February 2018 at 15:23:05 UTC, Simen Kjærås wrote:
>> So I was bored in a meeting and decided to implement a generic template for defining complex numbers, dual numbers, quaternions and many other possible algebras by simply defining a set of rules and the components on which they act:
>>
>> source:
>>
>> https://gist.github.com/Biotronic/833680b37d4afe774c8562fd21554c6b
>>

Cool. Took me a while to start to understand it and still not 100% grokked (partly because I've never quite been able to fully grasp quaternion math (at least, beyond Unity3D's ultra-easy abstraction for it) and never heard of dual numbers before), but staring at the complex number example helped see how this works. It's a very cool idea!

> It would be nice if you learned how to document your code. It's not always easy for someone on the outside to be able to pick it up and it ultimately means your hard work will be less used as it could be. I know that sometimes comments can be redundant but it can also provide a better understanding.
> 

Well, that's the difference between a formal library package release vs sharing a working proof of concept jotted down to pass time ;)

On Friday, 9 February 2018 at 02:40:06 UTC, Nick Sabalausky (Abscissa) wrote:
> On 02/08/2018 04:37 PM, Amorphorious wrote:
>> On Thursday, 8 February 2018 at 15:23:05 UTC, Simen Kjærås wrote:
>>> So I was bored in a meeting and decided to implement a generic template for defining complex numbers, dual numbers, quaternions and many other possible algebras by simply defining a set of rules and the components on which they act:
>>>
>>> source:
>>>
>>> https://gist.github.com/Biotronic/833680b37d4afe774c8562fd21554c6b
>>>
>
> Cool. Took me a while to start to understand it and still not 100% grokked (partly because I've never quite been able to fully grasp quaternion math (at least, beyond Unity3D's ultra-easy abstraction for it) and never heard of dual numbers before), but staring at the complex number example helped see how this works. It's a very cool idea!
>

quats are just complex numbers with extra variables like i. Each one is the square root of -1, but they are obviously incompatible.

i^2 = j^2 = k^2 = -1

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

See the multiplication table.

It's just an "extension" of complex numbers. They are homomorphic to 4x4 matrices but sometimes easier to work with.

Nothing really special about them... sorta like pepsi vs coke.

>> It would be nice if you learned how to document your code. It's not always easy for someone on the outside to be able to pick it up and it ultimately means your hard work will be less used as it could be. I know that sometimes comments can be redundant but it can also provide a better understanding.
>> 
>
> Well, that's the difference between a formal library package release vs sharing a working proof of concept jotted down to pass time ;)

Yes, but he can go back an add some friendly text at some point... He knows most about it so it is much easier and shouldn't take more than a few mins.

On Friday, 9 February 2018 at 15:45:11 UTC, Amorphorious wrote:
> On Friday, 9 February 2018 at 02:40:06 UTC, Nick Sabalausky (Abscissa) wrote:
>> Well, that's the difference between a formal library package release vs sharing a working proof of concept jotted down to pass time ;)
>
> Yes, but he can go back an add some friendly text at some point... He knows most about it so it is much easier and shouldn't take more than a few mins.

Indeed I can, and I have:

https://gist.github.com/Biotronic/833680b37d4afe774c8562fd21554c6b

Doing so after a long, tiring day at work for something I just did to pass the time, though - not worth it when I wanted a shower and some sleep. Luckily, today was just as boring, so I cleaned up the syntax a bit, added more sensible error messages, and even made it do the right thing by default when you leave out a rule:

alias complex = Algebra!(
        float,
        "1,i",
        "i" * "i".op = -1);
alias dual = Algebra!(
        float,
        "1,e",
        "e" * "e".op = 0);
alias splitComplex = Algebra!(
        float,
        "1,j",
        "j" * "j".op = 1
        );
alias quaternion = Algebra!(
        float,
        "1,i,j,k",
        "i,j,k" * "i,j,k".op = -1,
        "i,j,k" * "j,k,i".op = "k,i,j".antiCommutative
        );

--
  Simen

On Thursday, 8 February 2018 at 15:23:05 UTC, Simen Kjærås wrote:
> So I was bored in a meeting and decided to implement a generic template for defining complex numbers, dual numbers, quaternions and many other possible algebras by simply defining a set of rules and the components on which they act:
>
>
> alias quaternion = Algebra!(
>         float,
>         "1,i,j,k",
>         op("1",     any)  = any,
>         op("i,j,k", self) = "-1",
>         op("i",     "j")  = "k".antiCommutative,
>         op("j",     "k")  = "i".antiCommutative,
>         op("k",     "i")  = "j".antiCommutative,
>     );
>
> source:
>
> https://gist.github.com/Biotronic/833680b37d4afe774c8562fd21554c6b
>
> --
>   Simen

Nice. An interesting potential extension is to support composition (for instance, defining the complex numbers using the template and then defining the quaternions as an two-dimensional algebra over the complex).

On Friday, 9 February 2018 at 17:10:11 UTC, Simen Kjærås wrote:
> On Friday, 9 February 2018 at 15:45:11 UTC, Amorphorious wrote:
>> On Friday, 9 February 2018 at 02:40:06 UTC, Nick Sabalausky (Abscissa) wrote:
>>> Well, that's the difference between a formal library package release vs sharing a working proof of concept jotted down to pass time ;)
>>
>> Yes, but he can go back an add some friendly text at some point... He knows most about it so it is much easier and shouldn't take more than a few mins.
>
> Indeed I can, and I have:
>
> https://gist.github.com/Biotronic/833680b37d4afe774c8562fd21554c6b
>
> Doing so after a long, tiring day at work for something I just did to pass the time, though - not worth it when I wanted a shower and some sleep. Luckily, today was just as boring, so I cleaned up the syntax a bit, added more sensible error messages, and even made it do the right thing by default when you leave out a rule:
>
> alias complex = Algebra!(
>         float,
>         "1,i",
>         "i" * "i".op = -1);
> alias dual = Algebra!(
>         float,
>         "1,e",
>         "e" * "e".op = 0);
> alias splitComplex = Algebra!(
>         float,
>         "1,j",
>         "j" * "j".op = 1
>         );
> alias quaternion = Algebra!(
>         float,
>         "1,i,j,k",
>         "i,j,k" * "i,j,k".op = -1,
>         "i,j,k" * "j,k,i".op = "k,i,j".antiCommutative
>         );
>
> --
>   Simen

Lol, thanks, but that wasn't much. What I was thinking is a sort of paragraph of text at the top that sorta describes the overall conceptualization/overview. One still has to understand how all the pieces fit and the only way to learn that is by learning the pieces. And English equivalent of D code isn't really all that useful because anyone that knows D can understand the D code.

E.g.,

// Create a canonical list of rules from compound rules.
template Canonicalize(string units, Rules...)

is not really all that useful

rather, which I'm making up some type of overview:

"Creates algebraic structures[Algebra!(base type, relators/varables, relations...)]  using composition rules(relations) to define the structure. To define an algebra type, say, the quaternions of base type float,

 alias quaternion = Algebra!(
         float,
         "1,i,j,k",
         "i,j,k" * "i,j,k".op = -1,
         "i,j,k" * "j,k,i".op = "k,i,j".antiCommutative
         );

which can be used a type:

quaternion(a,b,c,d) q;  // Defines the quaternion q = a + bi + cj + dk.

--

the main bulk of defining an algebra as the relations. Each relation consists of  a string expressions sk involving the realtors expressing the relation equation as

f(s1,..,fn).op = s0

where f is an algebraic function and s0 is a the special relator(whatever). relators can be used as a csl.

e.g., for quats,

"i,j,k" * "i,j,k".op = -1

says that i*i = -1, j*j = -1, k*k = -1. Each of the rules could have been specified individually:

"i" * "i".op = -1
"j" * "j".op = -1
"k" * "k".op = -1

One can append a string expression using "property syntax":

"i,j,k" * "j,k,i".op = "k,i,j".antiCommutative

.antiCommutative states that the relator is anti commutative. Other properties are:

........
........
........ (no others?)

Once and algebra is established it can then act as any complex type and used as a functioning algebra.
"

etc.

The idea here is that to write a few paragraphs of English text so that one can read from the start to finish and understanding the general idea of what is going on without having to read through the entire code(which is much longer) and try to put the pieces together. The code I presented is what gleaned from what you are trying to accomplish and my knowledge of abstract algebra(which most don't have).

What's important is that the average person shouldn't have to learn your code to know how to use it. It is not important of the details(of which I haven't looked at) but just how to use them. While you give examples, which is good, the only problem is one can't necessarily glean from those examples how to create their own algebras. e.g., what about the GL(n,Z)? Is it possible?


 alias GLnZ = Algebra!(
         Matrix!(n,Z),
         "e_i_j" = 1,
         );

Obviously I doubt this would work, but it would be cool if it did, but the only way I could know is if I learned your code and tried to figure out how to massage it to work, if it could.. and that may take up more time than it would be to do my own implementation which I would understand better.

Hence adding clarifications to the code then help one make better decisions:

e.g.,

"Base Type must be a D primitive".

(again, the only way one can know if your code supports a general type is to learn the code, which may require one to learn all the code).


I'm not saying you have to do this, of course... just saying it would be more more helpful. I'm not sure how general your code is but if one could basically make arbitrary algebraic types, it would be very cool indeed and probably be pretty useful when people learned where to use it.