Passenger

test...password lost

Test...the password is missing

If someone divides by zero, your own reason. For example, division by zero is allowed in the generation of the least squares polynomial.

Where do I need an IT expert.

/****************************************************************************** * Jouni Aro * * 20.2.20 * * * * The multidimensional algebra * * * * The possibilities of algebra is associated with a sort of tool, with which * * parallel causations can be harnessed and approximated into compact * * functions. When you draw a roughly smooth curve into the screen with the * * mouse, the algebra is able to approximate the given set of dots into a * * short function. The craft of algebra is in its ability to describe * * phenomenons and the nature. * * * * What if you draw curves of different colors into the screen? The white set * * of dots is the temperature, the yellow is the direction of the wind, the * * orange is the time of year, the blue would represent the humidity etc. * * Every set of dots can be described as an individual phenomenon, but what * * about the function, that alone would describe the causations of the whole * * set? * * * * The relation of the function can also be asymmetrical. When the input of * * the weather function can be n number of initations, the output can only be * * a relatively blurry parameter between 0 to 1, whether you should go fishing * * or not. * * * * *** * * * * The computer can be programmed to study mathematics. With the solid axioms * * of algebra and the consistent development of series, the bit monster can * * immerse itself further into geometry and symmetry. In the final solution * * the computer was partly forced to abandon the symbolic concepts which * * include the positive, the negative, the real and the imaginary. The algebra * * doesn't need to share its opinion on in what direction the monitor is put * * on the table. * * * * The algorithms of algebra are constant and its objects can describe * * whatsoever. One of the most beautiful formulae of the algebra is the * * polynomial adaption of the smallest sum of squares: * * * * If the object that is placed in the formula is valid and balanced with * * itself, the algebra will process the substance with rational results, * * otherwise not. A good example is the quaternion. The algebra does not * * editorialise to the inner calculation logic of the quartenion. * * * * *** * * * * i^2 is -1, but what is the object that gives the result of -i when squared? * * There's an interesting connection between the companions of the i, * * |e^(xi+yj+zk+...)| = 1. The multidimensional algebra also connects the pi * * and the number one. pi^z limit on the real axis approaches the value of 1, * * when the z-unit vector is excited further and further from the real axis. * * At the same time, the sum of the absolute values of the axises approaches * * to the pi. * * * * Next up are the simple calculation rules of the recomplex number with the * * C++ examples. The class itself can do almost as such in the MatLab -tool. * * * * ~ recomplex * * ~ order * * ~ specification of class * * ~ addition * * ~ subtraction * * ~ multiplication * * ~ products of vector basis * * ~ division * * ~ abs(recomplex) * * ~ pow(recomplex, int) * * ~ ln(recomplex) * * ~ exp(recomplex) * * ~ pow(recomplex, double) * * ~ pow(recomplex, recomplex) * * ~ sin(recomplex) * * ~ cos(recomplex) * * ~ the port example of the smallest sum of squares * * ~ the connection of the pi and number one * * ~ code attachment * * * * *** * * * * The complex number is a real subset of the recomplex number. Real numbers * * and imaginary numbers for their parts are real subsets of the complex * * number. The prefix "re" points to the feedback, repeating the same basic * * logic in the next scale. * * * * ~~~ order ~~~ * * * * The order goes in power of two, 1, 2, 4, ..., 2^n. The real numbers are * * adjusted with the order of 1. The complex numbers come into effect with the * * order of 2. In the order of 4 the complex numbers get a complex object on * * their side, functioning by the stopper logic. The union of these makes * * simple function maps for the parallel causation phenomena possible, among * * other things. * /*****************************************************************************/ /****************************************************************************** * ~~~ class specification ~~~ * * * * C++ implemented an operator load, when especially the calculation * * operations of the numeric structures on the computer don't differ from the * * regular straightforwardness. * ******************************************************************************/ #include <math.h> #include <stdio.h> #include <conio.h> #include <memory.h> #include <stdlib.h> class recomplex { public: /************************************ * The dimension should be: * * 1, 2, 4, ..., 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(double*); recomplex(int); recomplex(int, int); recomplex(int, int, int, int); recomplex(double); recomplex(double, double); recomplex(double, double, double, double); friend void print(recomplex); friend double abs(recomplex); friend recomplex sqrt(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); }; /****************************************************************************** * ~~~ addition ~~~ * * * * If you're unfamiliar with the C, a few words about it. The basis of C is * * to save sheets. Every excessive and unnecessary rambling is eliminated * * from the syntax. The operators if C are very effective. For example +=, *=, * * /=, ... perform the operation in question and after that the assignment. * * a.e[n]+=b.e[n] means the same that a.e[n]=a.e[n]+b.e[n]. Because the latter * * style consumes more of paper, the shorter version of the same thing * * a.e[n]+=b.e[n] is used in the C. * ******************************************************************************/ recomplex operator+(recomplex a, recomplex b) { for (int n=0; n<DIMENSION; n++) a.e[n]+=b.e[n]; return a; } /****************************************************************************** * 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 value of the difference is -5 - 2i + 2j + 5k * ******************************************************************************/ /****************************************************************************** * ~~~ multiplication ~~~ * * * * The multiplication first requires a product definition of the base vectors. * * Looping the product does not editorialise to the formal positive, negative, * * real, imaginary, etc. definitions. The product of the multiplication is * * returned to the sum form so far only in the last loop. * ******************************************************************************/ recomplex operator*(recomplex a, recomplex b) { int *BasisVectors(void); int *R = BasisVectors(); 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=0; i<DIMENSION; i++, j+=2) t[i]=(double)(t[j] - t[j+1]); return *(recomplex*) t; } /****************************************************************************** * For exsample: * * * * recomplex A(2, 3, 5, 7); * * recomplex B(7, 5, 3, 2); * * print(A * B); * * * * The outcome is -32 + 32i + 87k. The multiplication is commutative. If A and * * B are complex, the outcome is complex. * * * * recomplex A(2, 3, 0, 0); * * recomplex B(7, 5, 0, 0); * * print(A * B); * * * * You'll get the output -1 + 31i * ******************************************************************************/ /****************************************************************************** * ~~~ the products of the base vectors ~~~ * * * * The products of the base vectors are generated by the recursive function. * * All the products of the base vectors associated with the order of 4 are * * assembled in the chart: * * * * # 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 particularly k^2 = -i. Commutativity remains, * * because still: * * * * ikj = jik = jki = kij = kji = -i * ******************************************************************************/ void GenerateTheProductsOfTheBaseVectors(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) { GenerateTheProductsOfTheBaseVectors(R, n+n); } } int* BasisVectors(void) { static int R[DIMENSION*DIMENSION*4]={-1}; if (R[0] == -1) { int FirstThereWasZero=0; R[0x00]=(int)FirstThereWasZero; GenerateTheProductsOfTheBaseVectors(R, 1); } return R; } /****************************************************************************** * ~~~ division ~~~ * * * * In division, a complex conjugate is produced for the divisor, with which * * the divisor and the dividend are multiplied. In the end of every loop step * * there's a half less of axel values of the divisor (the rest are summed up * * to nulls). When the value of the divisor is real, the elements of the * * dividend are divided by the value. For example 2 + 3i + 5j + 7k the mounted * * number is 2 + 3i - 5j - 7k. * ******************************************************************************/ 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]; } /****************************************************************************** * For exsample * * * * recomplex A(2, 3, 5, 7); * * recomplex B(7, 5, 3, 2); * * print(A / B); * * * * The product of division 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); * * * * The output of the value is 0.3918919 + 0.1486486i * ******************************************************************************/ 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) { return recomplex(k)/x; } /****************************************************************************** * ~~~ abs(recomplex) ~~~ * * * * In the absolute value x is multiplied by its complex conjugate repeatedly. * * The value then returns the breaking power collected by j. * ******************************************************************************/ 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); } /****************************************************************************** * For exsample: * * * * recomplex A(2, 3, 5, 7); * * recomplex B(7, 5, 3, 2); * * printf("%25.20f\n", abs(A/B)); * * * * The double of the C is precise, because the absolute value of the result is * * exactly 1.00000000000000000000 * ******************************************************************************/ /****************************************************************************** * ~~~ pow(recomplex, int) ~~~ * * * * The limit of x^0 is 1, when x approaches the null. Calculators have * * variable interpretations, whether the 0^0 is about 1 or is the calculation * * aborted and is the output of the status an error. In the polynomial * * adaption of the smallest sum of squares x^0 has to be 1 also with the x's * * limit null. An exponent n can be a positive or a negative integer. * ******************************************************************************/ 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); } } /****************************************************************************** * ~~~ print(recomplex) ~~~ * * * * Somewhere around 20 element, when the marking of the base vector is bigger * * than 'z', the marking of the base vector can be a symbol differentiated * * from the letter. In the calculations themselves the symbols are not * * editorialised. * ******************************************************************************/ 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"); } /****************************************************************************** * These functions still need to be explored * * * * ~~~ ln(recomplex) ~~~ * * ~~~ exp(recomplex) ~~~ * * ~~~ pow(recomplex, double) ~~~ * * ~~~ pow(recomplex, recomplex) ~~~ * * ~~~ sin(recomplex) ~~~ * * ~~~ cos(recomplex) ~~~ * ******************************************************************************/ recomplex::recomplex(void) { memset(this, 0, sizeof(recomplex)); } recomplex::~recomplex(void) { } recomplex::recomplex(double *a) { memset(this, 0, sizeof(recomplex)); for (int i=0x00; i<DIMENSION; i++) e[i]=a[i]; } recomplex::recomplex(int a) { memset(this, 0, sizeof(recomplex)); e[0]=(double)a; } recomplex::recomplex(double a) { memset(this, 0, sizeof(recomplex)); e[0]=(double)a; } recomplex::recomplex(int a, int b) { memset(this, 0, sizeof(recomplex)); e[0]=(double)a; e[1]=(double)b; } recomplex::recomplex(double a, double b) { memset(this, 0, sizeof(recomplex)); e[0]=(double)a; e[1]=(double)b; } recomplex::recomplex(int a, int b, int c, int d) { memset(this, 0, sizeof(recomplex)); e[0]=(double)a; e[1]=(double)b; e[2]=(double)c; e[3]=(double)d; } recomplex::recomplex(double a, double b, double c, double d) { memset(this, 0, sizeof(recomplex)); e[0]=(double)a; e[1]=(double)b; e[2]=(double)c; e[3]=(double)d; } /*************************************************** * Returns the square root of parameter c. Function * * has been implemented in Newton's processing. * ***************************************************/ recomplex sqrt(recomplex c) { int i; recomplex x; double R[DIMENSION]; for (i=0; i<DIMENSION; i++) { int sgn = rand()%0x02? -1: +1; R[i]=sgn*rand()/(double)32767; } x=recomplex((double*)R); for (i=0; i<1024; i++) x=x-(x*x-c)/(2.0*x); return (recomplex)x; } /********************************************** * the mainfunction tests the income swap law. * **********************************************/ int main(void) { recomplex x(0.12, -0.34, 0.56, -0.78); recomplex y(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"); getch(); return 0; }

I calculated this fractal with 4D complex numbers. (j and k axis fractal zoom)

Zooming Julia's crowd. I programmed this image sometime in the early millennium.

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

That is, you cannot talk about any technology at code level. A new way to generate pseudorandom numbers was in the next- and rnd-functions. But it doesn't hurt if the forum is forbidden to display the code. At least I enjoy reading other people's codes, and at best I try the other person's code myself.

// 64-bit random number generator. // CODE DELETED }

Scale over 20 years ago. I program now the fractal carbon colors. Each pixel contains 256 * 256 mosaic information, resulting in an image resolution of 216 (65 536).

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 ~ addition ~ 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. ~~~ addition ~~~ 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"); }

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.

#include <math.h> #include <stdio.h> typedef unsigned __int64 uint64; #define TRUE 1 #define FALSE 0 #define INC 3 #define NEW 7 #define SEQUEL 9 class rnd64 { public: rnd64(void); ~rnd64(void); uint64 rnd(void); private: int prime_number(int); uint64 next(void); int status; uint64 dx; uint64 dy; uint64 end; uint64 x, y; uint64 R16A; uint64 R16B; uint64 Z[2]; uint64 increaseA; uint64 increaseB; }; rnd64::rnd64(void) { dx=0xfedca201L; dy=0x012357bfL; R16A=(uint64)1; R16B=(uint64)2; Z[0]=Z[1]=0x00; x=5; y=3; end=2; increaseA=0x012357bfL; increaseB=0xfedca201L; } rnd64::~rnd64(void) { } int rnd64::prime_number(int st) { if (st == INC) { x+=2; y=3; if (x>=(1<<16)) x=5; end=unsigned(sqrt(double(x)+0.25)); return SEQUEL; } else { if (!(x%y)) return FALSE; if ((y+=2)>end) return TRUE; return SEQUEL; } } inline uint64 uabs(uint64 &a, uint64 &b) { return a>b? a-b: b-a; } inline void swap(uint64 &a, uint64 &b) { uint64 c=a; a=b; b=c; } uint64 rnd64::next(void) { status=prime_number(NEW); if (status == TRUE) { increaseB-=increaseA; increaseA+=x; prime_number(INC); } else if (status == FALSE) { prime_number(INC); } R16A -= increaseA; increaseA-=dx; R16B += increaseB; increaseB+=dy; if (status==TRUE) swap(R16A, R16B); R16A += (R16A>>32)^(R16B<<32); R16B -= (R16A<<32)^(R16B>>32); return R16A^R16B; } uint64 rnd64::rnd(void) { uint64 p1=next(); if (status==TRUE) { uint64 a[2], b[2]; uint64 p2=next(); a[0]=b[0] = Z[0]; a[1]=b[1] = Z[1]; ++a[unsigned(p1%2)]; ++b[unsigned(p2%2)]; uint64 A=uabs(a[0], a[1]); uint64 B=uabs(b[0], b[1]); if (Z[0] == Z[1]) { if (unsigned(next()%2)) { A=1; B=0; } else { A=0; B=1; } } if (A < B) { ++Z[unsigned(p1%2)]; return p1; } else { ++Z[unsigned(p2%2)]; return p2; } } else { ++Z[unsigned(p1%2)]; return p1; } } void main(void) { rnd64 R; int st=0; uint64 bit[2]; bit[0]=bit[1]=0x00; for (;;) { uint64 P=R.rnd(); ++bit[unsigned(P%2)]; if (st==0 && bit[1]>bit[0]) { printf("%d", bit[0]>bit[1]? 1: 0); st=1; } else if (st==1 && bit[0]>bit[1]) { printf("%d", bit[0]>bit[1]? 1: 0); st=0; } } }

eπi + 1 = 0

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 One of the most beautiful algebra formulas is the least squares polynomial formula.