# Re: Somewhat OT: defining algebras in D

```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.
```

```