1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.

Fractals and spiritual programming

Discussion in 'C#' started by Droppen, Feb 15, 2010.

  1. Droppen

    Droppen New Member

    Joined:
    Feb 15, 2010
    Messages:
    1
    Likes Received:
    0
    Trophy Points:
    0
    PHP:
    // When we get born into this world, we boot up our
    // brain, heart and other systems to form a picture of this reality.
    using System;
    // atral blueprint of this reality
    using System.Collections.Generic;
    // personality structure fingerprint
    using System.ComponentModel;
    // other people's belief structure
    using System.Data;
    // color pens, and artistic impressions
    using System.Drawing;
    // and some other stuff we dont even know about yet.
    using System.Linq;
    // This we didn't learn until we were 7
    using System.Text;
    // And this is something we bought into when we got older.
    using System.Windows.Forms;

    // Address: Multiverse, Universe, Galactic coordinates 34-24-36 Planet earth.
    namespace Multiverse
    {
    /* Let's establish something we want to do now, I would like to see
       how thoughts relate to fractals, how words can be programming and
       what does thoutghts look like, when forming a fractal. */
        
    public partial class Fractal Form
        
    {
            public 
    Fractal()
            {
    /* fractals are actually components to reality */
                
    InitializeComponent();
            }
    /* As Terrence McKenna said, culture is my operating system, and that my 
       Culture ACTUALLY has BUG's in it.
       I was right! Number 0 is actually a bug in our culture. Because
       0 is not a number, it doesn't exist. 0 is false, false is a statement of a quality of existance
       if false were to be represented as a number, false would be negative infinity.
       0 is 0 no matter how many times you have it, and it leaks the energy. 
       Its a thought energy leak. Because 0 times anything is a stupid thought, my energy is wasted
       counting if any of the numbers I divide with or substract with has 0.
       What this bug does to my thoughts, I think that something can be 0% true, we get alot
       of Division By Zero errors in our mind.
       If something is even 10% true, we think it can be defined as true, witch makes it
       opposite to false, allthough its many more times closer to false than true..
       the trick is that i need to define everything as true, or false, and I just have to figure 
       out how they relate. 0 is 0 no matter how many times I have it.
       I can't percieve negative infinity, just like i can't percive infinity. If I were to percive
       either, there would be no division, or infinite division, same thing, I would be concious of all that is.
     
       Okay now, 
       IMagicne a 2d map, where
       X is linear progression of how much money you have
       Y is not the time axis, is is a copy of X, so you can see it in 2d. 
       Z is the progression of time, or, the SEPERATION of a money making EVENT
       from every OTHER money making EVENT of the same kind,
       It is seen as changes of colors. From white to black.

       Infinity is everything that is infinite, is is the base of our reality.
       Infinity is all that is, infinity is infinite potential for anything.
       Infinity is the flow of energy, electricity. Infinity is conciousness.
       Infinity of time space is the universe, because the universe is infinite time space.
       Infinity is the number 1 in mathematics. Infinity divided in to 2 makes
       1 and 1 infinity, that equals 2, if you divide that again it equals 4. 
       4 cells, 4 divisions of the infinite. That way it is logical that when you divide
       1 into 1 it equals 1. 
       So, I need a de infinition for finity, so that THE computer will not be infused with an infinite loop. */
       
    double DeFinite 200.0;

    /*   Lets begin painting the picture.*/
            
    protected override void OnPaint(PaintEventArgs paintEvnt)
            {
    /* Even in virtual reality w e try to own stuff.
       Lets get a virtual peace of paper! */
                
    Graphics gfx paintEvnt.Graphics;

    /* Bitmap standard is very old, and simple. Simple facts prevail.
       And because we are going to demonstrate infinity in finite space
       1 pixel is the same as 1/200th division of infinity */
                
    Bitmap FractalBmp = new Bitmap((int)DeFinite, (int)DeFinitegfx);

    /* Lets think a thought, lets say that everytime I have a dollar, I get
       as many dollars as I allredy have, as many times as I have them
       so, money = money * money
       so, everytime I calculate that, is how I can calculate the Z axis.
       If you had 1.1 dollars, you would get 1.21 and that's where you
       put number 1, number 2 is 1.21*1.21 = 1.4641 etc, to infinity.*/
                
    for (double X 0DeFinite+= 1.0)
                    for (
    double Y 0DeFinite+= 1.0)
                {
                    
    double Z Fracture(DeFiniteDeFinite);
    /* I get the color from Z coordinate */
                    
    int color = (int)(255 DeFinite);

    /* IMagicne a 2d map, where
       X is linear progression of how much money you have
       Y is not the time axis, is is a copy of X, so you can see it in 2d. 
       Z is the progression of time, or, the SEPERATION of a money making EVENT
       from every OTHER money making EVENT of the same kind,
       It is seen as changes of colors. From white to black. */
                    
    FractalBmp.SetPixel((int)X, (int)YColor.FromArgb(colorcolorcolor));
                }
    /* Draw the picture from memory to the paper now. */
                
    gfx.DrawImage(FractalBmp00);
            }

            
    double Fracture(double Xdouble Y)
            {
                
    double Zx XZy Y;

    /* < and > are bugs too, that come with the thinking that there is a 0
       <= and >= is what should ALLWAYS be used. Because even the last 1 is worth an infinity.
       <= and not < because, <= is a judgement, a division
       in dumb < smart is a division, you are dividing wisdom into 2, dumb and smart.
       so, in x < 2 if x is ++; there is 1 possibility, 
       In x <= 2 there is 2 possibilities, wich is more logical, because when you divide
       infinity into 2, you get 1 + 1, so you get 2. */

                
    for /* from */(int XthDivision 1/* first */;
                    
    /* to */ XthDivision <= DeFinite/* DEfinite number */
                    /* do */ 
    XthDivision++)
    /* DEfinition, syncronisticly translates to de finiting something, infinite, is the
       opposition of definite. So, defining something is putting a limitation to it.
       and, defining it as infinite, is infining it. Making it the base of my reality,
       from witch to divide, define. 
       Indefinitie means infinite, and is often an expression of uncertainty,
       something that is finite, that needs to be definied. */
                
    {

    /* C# has its own definitions for infinity, but they work only on double numbers
       So, the limitations of the programming language is allredy coming in the way
       of the fractality of the code, allthough the code is this simple. */
                    
    if (Zx == double.PositiveInfinity || Zy == double.PositiveInfinity)
                    {
                        return 
    XthDivision;
                    }
                    if (
    Zx == double.NegativeInfinity || Zy == double.NegativeInfinity)
                    {
                        return 
    XthDivision;
                    }

    /* MandelBrot Set, F = F ^ 2 + C */
                    
    double ZyTemp Math.Pow(Zy2);
                    
    Zy Zx Zy Y;
                    
    Zx Math.Pow(Zx2) - ZyTemp X;


    /* So, the (idea/infinity) is to know how many times
       you need to count Z = Z ^ 2 until you shoot off to infinity 
       for the given coordinate */

                
    }
    /* if the number goes off to infinity, we return the DeFinite number if it. */
                
    return DeFinite;
            }

        }
    }

    /* Programming is like DNA, DNA has */ /*  signs everywhere too, and if
    you remove the */
    /* the code between them gets executed. 
    evo-lution.net/blog/posts/program-your-dna/
    So, why can't we speak the language of DNA witch
    is all mathematics? we can, and that language is hebrew. 
    It has no 0, and 1, all so means infinite.
    youtube.com/watch?v=dk_m5z0mKzo&feature=related
    */
     

Share This Page