Jump to content

ahmet

Senior Members
  • Posts

    380
  • Joined

  • Last visited

  • Days Won

    1

Posts posted by ahmet

  1. On 5/17/2021 at 2:18 PM, dimreepr said:

    How is that relevant to the topic?

    you succintly discuss the worth of money.

    money is in fact an object inside of the exchnage process.

    but the process I mention above (exchange),I think, rather generalised. 

    1 minute ago, dimreepr said:

    Was that something Mohammed taught?

    apart from the reality or the type of reality, we all responsible what we do and believe. 

    Thus , both yes and no. 

    yes, because you could find many advices by him like that.

    no, because you should find the realities by yourself. And none will be responsible by someone else's acts. 

  2. 39 minutes ago, dimreepr said:

    I'm suggesting that, the more people who have what they need to be content, the more people who see it's true value and thus reducing the need to protect the money they have; fraud only occurs when both parties think/feel they need more than they have.

    Of course there's no perfect system, some people will allways want more than they have/need; the problem we have is, those people are in charge, and doing everthing they can to make sure fraud is viable.

     

    don't bother yourself, as soon as  you die (and thus you leave from this world), some wordings will be expressed after your movement:

     

    get past sir , 

    the game is over. Any amount of money you collected will remain at your back. 

    :) 

     

     

    On 5/16/2021 at 12:29 PM, dimreepr said:

    Gold is no more valuable than paper, if what you need to buy is a loaf and there's none on the shelves.

    this is narrowed "paradigm "...

    but gold is almost or already universal "acceptance". 

  3. 2 hours ago, iNow said:

    Then your existing knowledge completely ignores how the vast majority of the world actually functions and can be dismissed as not being relevant to the discussion here. 

    when I need to make a decision objectively dependent to some criteria,I only refer to the source and pay attention what the criteria were. But not the actions and people.

    So, here, I do not rely on what other people do. the important thing, in fact , here is that what the source states.

    Thus, that is not my core focal point what other muslims pay attention (with the condition that I am suficiently  knowledgeable about the source). The external people are also not important. 

    The topic

    4 hours ago, dimreepr said:

    I'm not trying to define money, we all know what it is, I'm trying to explore it's value; and why we tend to place that value as an absolute; rather than it's pupose, which is to make it easier to exchange a pig for some egg's.

    then could you define what the "value" was?

    isn't it eventually personalized?

     

    corollary: almost every change is the result of exchange.  

     

    a notation: "almost" here is not an objective particle. But we needed to include indefinite things too. Indefinite things also include the contexts we cannot interfere them wholly as of the current time. 

  4. well ,to my existing knowledge, by islamic approach; only gold and silver can be accepted as money. in fact, I am not sure even about silver because just gold  is being accepted or calculated as entity to be responsible for something.you may consider to think that bancnotes, credit card's credits , bank accounts' amount were money 

    but as the definition is changing to one by one and by other entities, 

    what is the measurement of wealth?

    I think here, we may have to wait for some time, somethings will be more complicated in near future, however, I am hopeful to expect the clearer air/environment.

    cheers :) 

     

  5. 10 hours ago, dimreepr said:

    Money is not a tool it's a concept, so when we make our money work for us; it asset strip's the future.

    if you have not confused the description with blockchain,then ,no it is not a concept. 

    by definition, money has embodiment, you can handle ,see and use it. so it is not an abstract idea. 

    by the same properties, it is not an intention and a plan. rather, it is a content of intention and / or plan. (i.e. a tool)

     

  6. 1 hour ago, dimreepr said:

    The Life of brian???

    The Life of brian?

    mmm, no. 

    I prefer listening to music instead watching film .

    but succintly

    1) our religion has real values. (Do not dstract your attention with wrong/fake applications/appearances (e.g. isis))

    2)nowadays , arabs' money is the most valuable units as I know. 

    3) in spite of everything,I think english society (e.g. in universities) applies special forms in laboratories.I mean if not the something,but the bulk of everything was incorrect,why special forms are being implemented /applied?

    *** * *** 

    (Crypted: VE-RI-TAS)

    *** * ***    

     

     

    summary: 

    money and materials ..are not the aim , just tools.

  7. On 5/10/2021 at 5:14 PM, swansont said:
    The best things in life are free
    But you can give them to the birds and bees

    Just give me money. That's what I want.

    ahahhaha :) :) :) :) :) 

    :) :) :) :) :) 

    On 5/10/2021 at 5:07 PM, dimreepr said:

    What is it you want?

    really, what I want might be different. 

    formerly, my aim was to develop something to help humanity

    but now, I aim someting which you may consider that things religious ,at least I think I should.

    in fact, I shall again want to develop somethings to help humanity, but the aim is not that thing. that is just a content.

  8. On 5/10/2021 at 6:04 AM, neonwarrior said:

    Hello everyone,

    Why  -2 .(-3) = 6 

    Why is it positive? 

    Why we accept that (minus sign) times (minus sign) is positive ? What is its origin?

     

    Thanks in advance

     

     

    I might have not remember well, but preferably you may check some very basic notations from group teory & algebra such as : product (relevant) theorems and prime product separation/differentiation region (relevant theorems).

     

  9. hi,

    could someone help me on the qualitative properties of education in these specific countries:

    (specific issues: in which cases do teachers come across with problems ,the types of problems (general speaking: risks) and how are such problems being resolved or results)

    * china (specific states: hong kong,peking)

    * russia

    * dubai (uae)

    * finland

    * oman

     

     

     

  10. hi,

    I have several queries about this certification and need help.

    1) which authority / association carry out this exam?

    2) what are the prerequisites (for instance whether I have had to have a defined range of toefl exam score) for this exam?

    3) how does this exam is being carried out (e.g.: whether an active application ,for instance, telling lessons would be made)

    I am currently official teacher here in turkey but may consider to work abroad. 

    thanks

  11. On 12/16/2020 at 6:17 AM, Endy0816 said:

    Yes, something like wordpress

    hi,once again,

    assume please I buy some permissions (i.e. license/copyright by payment to wordpress as they define across all the folks/users)

    then ,could you further help me please (if you have that piece of the information) on whether I would be able to develop that webpages as (if it is) my own?

    (I will interfere the codes via making changes on it)

    one external query: do you know (if yes) could you explain whether I would make changes on same website after publishing something (after making payment to host and when the design of that webpage is already ready under assumption )

    many thanks.

     

  12. 23 minutes ago, Passenger said:
    
    /******************************************************************************
    * 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;
    }

     

    could you summarize what you have found and what you ask here please?

    maybe someone from computer sciences better help you.

  13. My conclusion:

    I do not believe that I would be able to contribute the material when I consider this sentence (which is my target/focal point of aim)

    "I need usefulness/efficacious results"

    so,moving away for now. :)

  14. 10 minutes ago, swansont said:

    So they say scientists don't know what the force is, exactly, but imply it will explain dark matter, these muon issues, matter/antimatter asymmetry, etc. Also, they imply this is a revelation, when we know the standard model is incomplete.

     

    I saw on twitter where it was stated the g-2 results from today used the same storage ring as the previous results (which showed a similar disagreement with the standard model), meaning you can't rule out some systematic errors. 

    could you provide a bit more details please?

    I could not judge these keywords or what had been implied by these keywords does not seem to me clear:

    1) revelation   2) asymmetry 3)g-2 

    I shall be thankful for explanation.

    (or I might need a bit google search)

  15. yeah,sure!

    Although I can't dominate all the relevancies or not willing to concentrate on the issue,I was already sure that something which are new would be found.

    I hope these for future of humanity: currently I am way frightened by the a-bombing potentiality and I hope that something new will eliminate this.

    but currently I do not imply the thing you cite above. 

    something that might really ensure us feel opening of the pandorra's box. :) 

  16. 1 minute ago, dimreepr said:

    As the dark side of "good". 😉

    actually , yes , this is again a subqestion of that core/key question.

    in this case,I would also like to ask a question

    what do you do when science does not respond anything on a case?

    the living event shows that you should eventually perform an action. 

    but the interesting thing is that science is really not explaining everything in the current case or we still do not know everything. 

    and this evolute onto qualitative thing ,like entropy. 

    ....

×
×
  • Create New...

Important Information

We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.