Complex spaces

Recommended Posts

By eliminating symbolic signs for multiplication, complex spaces are possible.

I studied this problem for over a decade until it was resolved.

Complex spaces fulfill all municipal conditions.

Please find the code below to test the municipal rules.

!

Moderator Note

No one should have to reverse engineer your code to understand what you are talking about.

Explain what you want to say.

Edited by Strange
Deleted code
Share on other sites

What is this program supposed to do?

Share on other sites

3 hours ago, Passenger said:

By eliminating symbolic signs for multiplication, complex spaces are possible.

I have limited knowledge of this but was ”complex spaces” not possible before? I think have come across the term earlier, maybe more definitions are needed? What complex spaces are we discussing?

what is GeneroiKantaolioidenTulot? Generates Constants Revenue? Lack of comments combined with usage of non-english definitions makes the program hard to read.

Share on other sites

Multidimensional algebra

The capabilities of Algebra also include a tool that can concatenate and approximate parallel cause and effect functions into compact functions. By drawing an approximately smooth graph on the screen, the algebra succeeds in approximating a given set of points to a short function. Algebra's skill is in its ability to describe phenomena and nature.

What about drawing different colored curves on the screen. The white set of points is temperature, the yellow wind direction, the orange season, the blue one represents the humidity, etc. Each set of points can be described as a single phenomenon, but what about the function that alone describes the cause-effect relationship between the whole set?

The relation of the function can also be asymmetric. The weather function can have n-excitations as the inputt, and only one relatively fuzzy parameter between 0-1 whether or not to go fishing.

***

You can program your computer to study math. With robust algebra axioms and inconsistent series development, bit fear further delves into geometry and symmetry. In the final solution, the computer had to partly abandon the symbolic concepts of positive, negative, real and imaginary. Algebra does not need to take a stand on how the monitor is placed on the table.

Algebra's algorithms are standard, and its objects can describe anything. One of the most beautiful algebra formulas is the least squares polynomial fit:

k0∑xj0 + k1∑xj1 + k2∑xj2 +, ..., + kn∑xjn+0 = ∑yjxj0

k0∑xj1 + k1∑xj2 + k2∑xj3 +, ..., + kn∑xjn+1 = ∑yjxj1

k0∑xj2 + k1∑xj3 + k2∑xj4 +, ..., + kn∑xjn+2 = ∑yjxj2
...
k0∑xjn + k1∑xjn+1 + k2∑xjn+2 +, ..., + kn∑xjn+n = ∑yjxjn

If the object to be placed in the formula is valid and in equilibrium with itself, the algebra processes the substance with reasonable results, otherwise it does not. A good example is quaternions. Algebra does not comment on the quaternion internal calculation logic.

***

i2 is -1, but what is the object raised to another to give -i? i's companions have an interesting connection:

|exi + yj + zk + ...| = 1

The following is a simple computation of the recomplex number with C ++ examples.

~ recomplex
~ order
~ class definition
~ subtraction
~ multiplication
~ income of parent vectors
~ dividing
~ abs(recomplex)
~ pow(recomplex, int)
~ code notes

***

~~~ recomplex ~~~

A complex number is a real subset of a recomplex number. Real numbers and imaginary numbers, in turn, are real subsets of a complex number. The prefix "re" refers to feedback, a repetition of the same basic logic in the following scale.

~~~ order ~~~

The order of magnitude is the power of two, 1, 2, 4, ..., 2n. The real numbers are tuned by an order of 1. The complex numbers take effect by an order of 2. In the order of 4, the complex numbers get a parallel logic object. Their combination allows, for example, simple function mappings for parallel cause-and-effect phenomena.

~~~ Class Definition ~~~

C ++ carried out the load on the operators, so that the computation of numerical structures, especially on a computer, did not deviate from the usual straightforwardness.

class recomplex
{
public:

/************************************
* The dimension should be 2 ^ n.    *
* DIMENSION 1 -> real numbers       *
* DIMENSION 2 -> complex numbers    *
* DIMENSION 4 -> 4D complex numbers *
* DIMENSION 8 -> 8D complex numbers *
************************************/
#define DIMENSION 4
double e[DIMENSION];

recomplex(void);
~recomplex(void);
recomplex(char*, ...);

recomplex(int);
recomplex(int, int);
recomplex(int, int, int, int);

friend void print(recomplex);
friend double abs(recomplex);

friend recomplex operator-(recomplex);
friend recomplex operator+(recomplex, recomplex);
friend recomplex operator-(recomplex, recomplex);

friend recomplex operator*(recomplex, recomplex);
friend recomplex operator/(recomplex, recomplex);

friend recomplex operator*(recomplex, double);
friend recomplex operator/(recomplex, double);

friend recomplex operator*(double, recomplex);
friend recomplex operator/(double, recomplex);

friend recomplex pow(recomplex, int);
};

The recomplex definition includes basic calculations, a prime number and an absolute value. In addition to this, there is a value printing function as well as value generators.

recomplex operator+(recomplex a, recomplex b)
{
for (int n=0; n<DIMENSION; n++)
a.e[n]+=b.e[n];
return a;
}

If C is a stranger, a few words about it. C is based on saving sheets. All unnecessary and unnecessary deliberation has been removed from the syntax. The operators of C are very efficient. For example, +=, *=, /=, ... will first execute this. mission, followed by placement. a.e [n] + = b.e [n] thus means the same as a.e[n] = a.e[n]+b.e[n]. Because the latter style consumes more paper, C uses the shorter notation a.e[n] += b.e[n] for the same thing.

For example:

recomplex A(2, 3, -5, 7);
recomplex B(7, 5, -3, 2);
print(A + B);

Prints a value of 9 + 8i - 8j + 9k.

~~~ subtraction ~~~
recomplex operator-(recomplex a, recomplex b)
{
for (int n=0; n<DIMENSION; n++)
a.e[n]-=b.e[n];
return a;
}
For exsample:
recomplex A(2, 3, 5, 7);
recomplex B(7, 5, 3, 2);
print(A-B); 

The difference value is -5 - 2i + 2j + 5k.

~~~ multiplication ~~~
recomplex operator*(recomplex a, recomplex b)
{
int *ConstantIncome(void);
int *R=ConstantIncome();
int i, j, n=DIMENSION*2;

double x[DIMENSION*2];
double y[DIMENSION*2];
double t[DIMENSION*2];

for (i=j=0; i<DIMENSION; i++, j+=2)
x[j+1]=y[j+1]=t[j]=t[j+1]=0.0,
x[j]=a.e[i], y[j]=b.e[i];

for (i=0; i<n; i++)
for (j=0; j<n; j++)
t[R[i*n+j]]+=x[i]*y[j];

for (i=j=0x00; i<DIMENSION; i++, j+=2)
t[i]=(double)(t[j] - t[j+1]);
return *(recomplex*) t;
}

The multiplication first requires an input definition for the base vectors. Input looping does not take a stand on the formal definitions of positive, negative, real, imaginary, etc. The result of the multiplication is returned to the sum form only in the last loop.

For exsample:

recomplex A(2, 3, 5, 7);
recomplex B(7, 5, 3, 2);
print(A * B);

The result is -32 + 32i + 87k. Multiplication is an exchange. If A and B are complex, the result is complex:

recomplex A(2, 3, 0, 0);
recomplex B(7, 5, 0, 0);
print(A * B);

Prints -1 + 31i.

~~~ basic vectors revenue ~~~

The product of the base vectors is generated by a recursive function. The table summarizes all income for the parent vectors related to the order 4:

   #  1 | -1 |  i | -i |  j | -j |  k | -k |
############################################
1 #  1 | -1 |  i | -i |  j | -j |  k | -k |
---#----|----|----|----|----|----|----|----|
-1 # -1 |  1 | -i |  i | -j |  j | -k |  k |
---#----|----|----|----|----|----|----|----|
i #  i | -i | -1 |  1 |  k | -k | -j |  j |
---#----|----|----|----|----|----|----|----|
-i # -i |  i |  1 | -1 | -k |  k |  j | -j |
---#----|----|----|----|----|----|----|----|
j #  j | -j |  k | -k |  i | -i | -1 |  1 |
---#----|----|----|----|----|----|----|----|
-j # -j |  j | -k |  k | -i |  i |  1 | -1 |
---#----|----|----|----|----|----|----|----|
k #  k | -k | -j |  j | -1 |  1 | -i |  i |
---#----|----|----|----|----|----|----|----|
-k # -k |  k |  j | -j |  1 | -1 |  i | -i |
---#----|----|----|----|----|----|----|----|

For example, ijk = -i, and especially k2 = -i. The trade remains because:

ikj = jik = jki = kij = kji = -i

void GenerateBaseVectorsInputs(int *R, int n)
{
int I=0, J=n-1, i;
int X=n, Y=J+n, j;
int k=DIMENSION*2;

for (i=I; i<=J; i++)
for (j=I; j<=J; j++)
{
R[i*k+X+j]=R[i*k+j]+X;
R[(X+j)*k+i]=R[i*k+j]+X;
R[(Y-i)*k+Y-j]=J-R[i*k+j];
}

if (n+n < DIMENSION*2)
{
GenerateBaseVectorsInputs(R, n+n);
}
}

int* ConstantIncome(void)
{
static int R[DIMENSION*DIMENSION*4]={-1};
if (R[0] == -1)
{
int FirstThereWasZero=0;
R[0]=(int)FirstThereWasZero;
GenerateBaseVectorsInputs(R, 1);
}
return R;
}

~~~ dividing ~~~

recomplex operator/(recomplex x, recomplex y)
{
recomplex z;

for (int i, n=DIMENSION; n>=2; n/=2)
{
for (z=y, i=n/2; i<n; i++)
z.e[i] = -z.e[i];
x=x*z; y=y*z;
}

return x/y.e[0];
}

In a divisor, a divisor is produced for the divisor, multiplying by the divisor and divisor. At the end of each loop step, the divider axis values are less than half (the rest add up to zero). When the value of the divisor is real, the value divides the elements of the divisor. For example, 2 + 3i + 5j + 7k has a compound number of 2 + 3i - 5j - 7k.

For exsample:

recomplex A(2, 3, 5, 7);
recomplex B(7, 5, 3, 2);
print(A / B);

The result of the split calculation is 0.5488136 - 0.1575801i + 0.7181670j + 0.3977540k. If A and B are complex, the result is complex:

recomplex A(2, 3, 0, 0);
recomplex B(7, 5, 0, 0);
print(A / B);

Returns 0.3918919 + 0.1486486i.

~~~ abs(recomplex) ~~~

double abs(recomplex x)
{
recomplex z;
double r, c;
int i, j=1, n;

for (n=DIMENSION; n>=2; n/=2, j+=j)
{
for (z=x, i=n/2; i<n; i++)
z.e[i]=-z.e[i];
x=x*z;
}

r=fabs(x.e[0]);
c=1.0/(double)j;
return pow(r, c);
}

In the eigenvalue, x is multiplied by its compound number until its value is completely real. The value then returns the junction power collected by j.

For exsample:

recomplex A(2, 3, 5, 7);
recomplex B(7, 5, 3, 2);
printf("%25.20f \n", abs(A / B));

C double is accurate because the absolute value of the result is exactly 1.0000000000000000000000

~~~ pow(recomplex, int) ~~~

recomplex pow(recomplex x, int n)
{
if (n)
{
recomplex t=x;
int i=n<0? -n: n;
for (--i; i; i--) t=t*x;
return n>0? t: recomplex(1) / t;
}
else
{
return recomplex(1);
}
}

The limit for x0 is 1 as x approaches zero. Calculators have varying interpretations of whether 00 is approximately 1 or whether the calculation is interrupted and an error condition is printed. In the least squares fit, x0 must also be 1 for x. The exponent n can be a positive or a negative integer.

~~~ code notes ~~~

Recomplex figures form the municipality. All municipal billing rules apply.

The code below can be used to test how recomplex numbers behave.

#include <memory.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

class recomplex
{
public:

/************************************
* The dimension should be 2 ^ n.    *
* DIMENSION 1 -> real numbers       *
* DIMENSION 2 -> complex numbers    *
* DIMENSION 4 -> 4D complex numbers *
* DIMENSION 8 -> 8D complex numbers *
************************************/
#define DIMENSION 4
double e[DIMENSION];

recomplex(void);
~recomplex(void);
recomplex(char*, ...);

recomplex(int);
recomplex(int, int);
recomplex(int, int, int, int);

friend void print(recomplex);
friend double abs(recomplex);

friend recomplex operator-(recomplex);
friend recomplex operator+(recomplex, recomplex);
friend recomplex operator-(recomplex, recomplex);

friend recomplex operator*(recomplex, recomplex);
friend recomplex operator/(recomplex, recomplex);

friend recomplex operator*(recomplex, double);
friend recomplex operator/(recomplex, double);

friend recomplex operator*(double, recomplex);
friend recomplex operator/(double, recomplex);

friend recomplex pow(recomplex, int);
};

/************************************************************************
* The recomplex(void) -generator initializes the values to zero.        *                                         *
************************************************************************/
recomplex::recomplex(void)
{
memset(this, 0, sizeof(recomplex));
}

recomplex::~recomplex(void)
{
}

/************************************************************************
* Generator recomplex(char *, ...)                                      *
*                                                                       *
* For example:                                                          *
*                                                                       *
* recomplex x("2d", 2, 3),           x gets a value of 2.0000 + 3.0000i *
* recomplex y("2f", 1.2345, 6.7898), y gets a value of 1.2345 + 6.7898i *
*                                                                       *
* The format first gives the recomplex of chapters, for example 4.      *
* - 'd' means that the numbers are given as integers.                   *
* - 'f' means that the numbers are given in floating point form.        *
************************************************************************/
recomplex::recomplex(char *f, ...)
{
char format='d';
int i, kpl=atoi(f);
int step=(int)sizeof(int);
memset(this, 0x00, sizeof(recomplex));
unsigned long P=(unsigned long)&f+sizeof(char*);

for (i=0; f[i]; i++)
{
if (f[i] == 'f')
{
step=sizeof(double);
format='f';
}
}

for (i=0; i<kpl; i++, P+=step)
e[i] = (char)format=='d'?
*(int*)P: *(double*)P;
}

/************************************************************************
* Somewhere around 20 elements when the parent vector ID is larger      *
* like 'z', the base vector ID may be a letter abnormal character.      *
* In fact, the calculation of the base vectors no comment is made on    *
* symbolic symbols.                                                     *
************************************************************************/
void print(recomplex a)
{
printf("%0.9f ", a.e[0]);
for (int n=1; n<DIMENSION; n++)
printf("%c %0.9f%c ", a.e[n]<0?
'-': '+', fabs(a.e[n]), 'h'+n);
printf("\n");
}

recomplex::recomplex(int a)
{
memset(this, 0, sizeof(recomplex));
e[0]=a;
}

recomplex::recomplex(int a, int b)
{
memset(this, 0, sizeof(recomplex));
e[0]=a; e[1]=b;
}

recomplex::recomplex(int a, int b, int c, int d)
{
memset(this, 0, sizeof(recomplex));
e[0]=a; e[1]=b; e[2]=c; e[3]=d;
}

recomplex operator-(recomplex a)
{
for (int n=0; n<DIMENSION; n++)
a.e[n]=-a.e[n];
return a;
}

recomplex operator+(recomplex a, recomplex b)
{
for (int n=0; n<DIMENSION; n++)
a.e[n]+=b.e[n];
return a;
}

recomplex operator-(recomplex a, recomplex b)
{
for (int n=0; n<DIMENSION; n++)
a.e[n]-=b.e[n];
return a;
}

recomplex operator*(recomplex a, recomplex b)
{
int *ConstantIncome(void);
int *R=ConstantIncome();
int i, j, n=DIMENSION*2;

double x[DIMENSION*2];
double y[DIMENSION*2];
double t[DIMENSION*2];

for (i=j=0x00; i<DIMENSION; i++, j+=2)
x[j+1]=y[j+1]=t[j]=t[j+1]=0.0,
x[j]=a.e[i], y[j]=b.e[i];

for (i=0; i<n; i++)
for (j=0; j<n; j++)
t[R[i*n+j]]+=x[i]*y[j];

for (i=j=0x00; i<DIMENSION; i++, j+=2)
t[i]=(double)(t[j] - t[j+1]);
return *(recomplex*) t;
}

void GenerateBaseVectorsInputs(int *R, int n)
{
int I=0, J=n-1, i;
int X=n, Y=J+n, j;
int k=DIMENSION*2;

for (i=I; i<=J; i++)
for (j=I; j<=J; j++)
{
R[i*k+X+j]=R[i*k+j]+X;
R[(X+j)*k+i]=R[i*k+j]+X;
R[(Y-i)*k+Y-j]=J-R[i*k+j];
}

if (n+n < DIMENSION*2)
{
GenerateBaseVectorsInputs(R, n+n);
}
}

int* ConstantIncome(void)
{
static int R[DIMENSION*DIMENSION*4]={-1};
if (R[0] == -1)
{
int FirstThereWasZero=0;
R[0]=(int)FirstThereWasZero;
GenerateBaseVectorsInputs(R, 1);
}
return R;
}

recomplex operator/(recomplex x, recomplex y)
{
recomplex z;

for (int i, n=DIMENSION; n>=2; n/=2)
{
for (z=y, i=n/2; i<n; i++)
z.e[i] = -z.e[i];
x=x*z; y=y*z;
}

return x/y.e[0];
}

recomplex operator/(recomplex x, double k)
{
for (int i=0; i<DIMENSION; i++)
x.e[i]/=(double)k;
return x;
}

recomplex operator*(double k, recomplex x)
{
for (int i=0; i<DIMENSION; i++)
x.e[i]*=(double)k;
return x;
}

recomplex operator*(recomplex x, double k)
{
return k*x;
}

recomplex operator/(double k, recomplex x)
{
recomplex y("1f", k);
return (recomplex)y/x;
}

double abs(recomplex x)
{
recomplex z;
double r, c;
int i, j=1, n;

for (n=DIMENSION; n>=2; n/=2, j+=j)
{
for (z=x, i=n/2; i<n; i++)
z.e[i]=-z.e[i];
x=x*z;
}

r=fabs(x.e[0]);
c=1.0/(double)j;
return pow(r, c);
}

recomplex pow(recomplex x, int n)
{
if (n)
{
recomplex t=x;
int i=n<0? -n: n;
for (--i; i; i--) t=t*x;
return n>0? t: recomplex(1) / t;
}
else
{
return recomplex(1);
}
}

/************************************************************************
* the mainfunction tests the income swap law.                           *
************************************************************************/
void main(void)
{
recomplex x("4f", 0.12, -0.34, 0.56, -0.78);
recomplex y("4f", 0.98, -0.76, 0.54, -0.32);

printf("x = "); print(x);
printf("y = "); print(y);

printf("\n");

printf("x*y = "); print(x*y);
printf("y*x = "); print(y*x);

printf("\n");
}

Edited by Passenger
Edit
Share on other sites

Could you try answer my initial question "what complex spaces are we discussing", possibly without posting huge amounts of source code?

6 hours ago, Passenger said:

i2 is -1, but what is the object raised to another to give -i?

$\sqrt{-i}=-(-1)^{ \frac{3}{4} }$ Or approximately 0.707-0.707i ?

(This was the only question and opening for discussion I could find)

6 hours ago, Passenger said:

Real numbers and imaginary numbers, in turn, are real subsets of a complex number.

The above seems to imply that an imaginary number is a real number? But as far as I know an imaginary number is not a real number since it is a real number multiplied by the imaginary unit. Is the text machine translated, causing the post to look like it has errors?

Share on other sites

The usual generalization of the reals, complex numbers, quaternions, octonions, sedenions, etc., is the Cayley-Dickson construction. It's also related to the subject of Clifford algebras.

I haven't perused the code but if the OP would express his/her idea in a couple of sentences perhaps we'd be interested to know more. Source code is not a good medium for communicating ideas to people. Its sole purpose is to allow trained programmers to communicate ideas to computers. I thought everyone knew that. Hey let's see the machine code!

On 8/24/2019 at 12:43 PM, Ghideon said:

i=(1)34 Or approximately 0.707-0.707i ?

There's a nice visualization that $\sqrt{i} = \pm (\frac{\sqrt 2}{2} + \frac{\sqrt 2}{2} i)$. In the plane, $i$ makes an angle of $\frac{\pi}{2}$ with the positive $x$-axis. Now the geometric insight is that when you multiply complex numbers, you add the angles. To find a (not "the") square root of $i$, we ask ourselves: What angle, when added to itself, gives $\frac{\pi}{2}$? Then it's obvious, it's just $\frac{\pi}{4}$. A line making an angle of $\frac{\pi}{4}$ with the positive $x$-axis crosses the unit circle at the point $(\cos \frac{\pi}{4}, \ \sin \frac{\pi}{4})$ in trig form, giving one square root. The other one is its negative, which is the point directly opposite it on the unit circle.

ps -- I just noticed the question was for $- i$. Same visualization applies with suitable modifications, which I didn't feel like making. You take half of $\frac{3 \pi}{2}$ which is $\frac{3 \pi}{4}$, etc. Doing it that way gives the negative of the answer you got. My value's in the second quadrant and yours is in the fourth. I don't think there's a convention as to which is preferred.

On 8/24/2019 at 12:43 PM, Ghideon said:

The above seems to imply that an imaginary number is a real number? But as far as I know an imaginary number is not a real number since it is a real number multiplied by the imaginary unit. Is the text machine translated, causing the post to look like it has errors?

This was in response to @Passenger writing, "Real numbers and imaginary numbers, in turn, are real subsets of a complex number."

If you substitute the word actual, or legitimate, or proper, for the second use of "real," then this makes sense. Perhaps that's what was meant.

On the other hand the phrasing was the real subsets of '"a complex number" and NOT "the complex numbers." Making me think that perhaps they mean the real and imaginary parts of a complex number, which are always real numbers by definition. That would be another interpretation.

FWIW zero is the only number that is both real and imaginary.

Edited by wtf
Share on other sites

On 8/30/2019 at 2:47 AM, wtf said:

Now the geometric insight is that when you multiply complex numbers, you add the angles.

Thanks for the reminder! I had forgotten that!

(I used that set of rules, quite a lot, a long time ago in analysis of AC circuits, made calculations easier wikipedia.org/Electrical_impedance )

Share on other sites

~~~ least squares fitting example ~~~

For example:

One phenomenon related to the time was that at time 1 the value 14 + 8j + 11l - 3n was measured. At time 2, a value of -3 + 10j + 15l - 7n was measured. It was found that the cause-effect of the phenomenon was approximately in accordance with the values:

x0 = 1, y0 = 14 + 8j + 11l - 3n
x1 = 2, y1 = -3 + 10j + 15l - 7n
x2 = 3, y2 = -12 + 14j + 20l - 11n
x3 = 4, y3 = -20 + 17j + 23l - 15n
x4 = 5, y4 = -25 + 19j + 24l - 17n
x5 = 6, y5 = -28 + 22j + 24l - 21n
x6 = 7, y6 = -27 + 24j + 23l - 24n
x7 = 8, y7 = -25 + 27j + 20l - 27n
x8 = 9, y8 = -23 + 27j + 17l - 28n
x9 = 10, y9 = -18 + 27j + 13l - 32n
x10 = 11, y10 = -13 + 28j + 11l - 33n
x11 = 12, y11 = -4 + 28j + 6l - 35n
x12 = 13, y12 = 1 + 28j + 2l - 35n
x13 = 14, y13 = 9 + 27j - 3l - 35n
x14 = 15, y14 = 15 + 26j - 6l - 35n
x15 = 16, y15 = 22 + 24j - 10l - 37n
x16 = 17, y16 = 26 + 21j - 13l - 37n
x17 = 18, y17 = 30 + 21j - 17l - 36n
x18 = 19, y18 = 33 + 17j - 18l - 35n
x19 = 20, y19 = 34 + 13j - 19l - 33n
x20 = 21, y20 = 32 + 11j - 17l - 32n
x21 = 22, y21 = 28 + 7j - 15l - 30n
x22 = 23, y22 = 22 + 2j - 11l - 29n
x23 = 24, y23 = 12 - 2j - 7l - 26n
x24 = 25, y24 = -1 - 8j + 0l - 22n

Based on the graphical analysis, it was decided to fit a cube parable to the phenomenon. Placing the measured response values in the least squares formula gives the cubic parabola coefficients:

f(x) = k0 + k1x^1 + k2x^2 + k3x^3, where

k0 =  31.479 + 2.882j + 2.508l + 1.642n
k1 = -20.364 + 4.297j + 8.735l - 4.578n
k2 =   2.068 - 0.179j - 1.029l + 0.124n
k3 =  -0.052 + 0.000j + 0.027l + 0.001n

the recomplex cube parabola describes the phenomenon well. At initial values of x, the function values are:

f (recomplex(1)) = 13.131 + 7.000j + 10.241l - 2.810n
f (recomplex(2)) = -1.394 + 10.758j + 16.080l - 7.009n
f (recomplex(3)) = -12.409 + 14.152j + 20.185l - 10.950n
f (recomplex(4)) = -20.227 + 17.181j + 22.720l - 14.628n
f (recomplex(5)) = -25.163 + 19.842j + 23.846l - 18.038n
f (recomplex(6)) = -27.528 + 22.134j + 23.725l - 21.175n
f (recomplex(7)) = -27.638 + 24.053j + 22.520l - 24.035n
f (recomplex(8)) = -25.805 + 25.598j + 20.393l - 26.612n
f (recomplex(9)) = -22.342 + 26.766j + 17.506l - 28.903n
f (recomplex(10)) = -17.563 + 27.554j + 14.021l - 30.901n
f (recomplex(11)) = -11.782 + 27.961j + 10.100l - 32.602n
f (recomplex(12)) = -5.311 + 27.984j + 5.906l - 34.002n
f (recomplex(13)) = 1.536 + 27.621j + 1.600l - 35.095n
f (recomplex(14)) = 8.445 + 26.870j - 2.655l - 35.876n
f (recomplex(15)) = 15.103 + 25.728j - 6.697l - 36.342n
f (recomplex(16)) = 21.197 + 24.192j - 10.364l - 36.487n
f (recomplex(17)) = 26.413 + 22.261j - 13.493l - 36.305n
f (recomplex(18)) = 30.438 + 19.932j - 15.924l - 35.794n
f (recomplex(19)) = 32.959 + 17.203j - 17.493l - 34.946n
f (recomplex(20)) = 33.661 + 14.072j - 18.038l - 33.759n
f (recomplex(21)) = 32.232 + 10.535j - 17.397l - 32.226n
f (recomplex(22)) = 28.359 + 6.592j - 15.408l - 30.343n
f (recomplex(23)) = 21.727 + 2.239j - 11.909l - 28.106n
f (recomplex(24)) = 12.024 - 2.525j - 6.737l - 25.509n
f (recomplex(25)) = -1.064 - 7.704j + 0.269l - 22.547n

Algebra does not take a stand on the quality symbolically agreed for each axis. The unit vector l may represent, for example, snowfall as moles.

The real axis, i and its companion features have remarkable automation where different qualities can communicate with each other.

Multidimensional algebra is recursively generated from zero.

Share on other sites

On 9/11/2019 at 5:35 AM, Passenger said:

Algebra does not take a stand on the quality symbolically agreed for each axis. The unit vector l may represent, for example, snowfall as moles.

The real axis, i and its companion features have remarkable automation where different qualities can communicate with each other.

Multidimensional algebra is recursively generated from zero.

This forum allows this nonsense and bans a discussion of the ordinal numbers?

Share on other sites

!

Moderator Note

Passenger, you have not explained what this thread is about, you have not answered any questions and your use of English is so idiosyncratic that it is almost incomprehensible.

6 hours ago, wtf said:

This forum allows this nonsense and bans a discussion of the ordinal numbers?

!

Moderator Note

It would be better to use the Report function for this sort of comment to ensure it is seen by the moderators.

If you think the other thread is worth continuing, please report it and make a case for keeping it open.