1. Limited time only! Sign up for a free 30min personal tutor trial with Chegg Tutors
    Dismiss Notice
Dismiss Notice
Join Physics Forums Today!
The friendliest, high quality science and math community on the planet! Everyone who loves science is here!

Opinion regarding included code

  1. Nov 4, 2011 #1
    Seeking opinion regarding included code.

    //Processing - Processing.org
    Code (Text):

    int _size = 256;
    int _mx, _my;
    Ordinate _x, _y, _one;

    void setup()
    {
      size(this._size, this._size, P2D);
      _x = new Ordinate(this._size);
      _y = new Ordinate(this._size);
      _one = Ordinate.One(this._size);
    }

    void draw()
    {
      Ordinate o = Ordinate.Add(_x, _y);  
      for(int a = 0, x = 0, y = 0; a < o._magnitude.length; a += 3)
      {
        int col = 255 << 24 | o._magnitude[a] << 16 | o._magnitude[a + 1] << 8 | o._magnitude[a + 2];
       
        stroke(col);
        point(x, y);
        x = x + 1 == _size ? 0 : x + 1;
        y = x == 0 ? y + 1 : y;
      }
    }

    void keyPressed()
    {
      if(key == 'w')
      {
        _x = Ordinate.Add(_x, _one);
      }
      else if(key == 's')
      {
         _x = Ordinate.Sub(_x, _one);
      }
      else if(key == 'a')
      {
         _y = Ordinate.Add(_y, _one);
      }
      else if(key == 'd')
      {
         _y = Ordinate.Sub(_y, _one);
      }
    }

    void mousePressed()
    {
      _mx = mouseX;
      _my = mouseY;
    }

    void mouseReleased()
    {
      int dx = mouseX;
      int dy = mouseY;
      int dragLength = (_mx - dx) * (_mx - dx) + (_my - dy) * (_my - dy);  
    }

    static class Ordinate
    {
      public int _size;
      public byte[] _magnitude;
     
      private Ordinate()
      {
        this._size = 0;
        this._magnitude = null;
      }
     
      public Ordinate(int Size)
      {
        this._size = Size;
        this._magnitude = new byte[this._size * this._size * 3];
      }
     
      public static Ordinate One(int Size) {
        Ordinate o = new Ordinate(Size);
        o._magnitude[o._magnitude.length - 1] = 1;
        return o;
      }

      public static Ordinate Add(Ordinate Ord1, Ordinate Ord2)
      {
        Ordinate o = new Ordinate(Ord1._size);
        for (int a = Ord1._magnitude.length - 1, carry = 0; a > -1; a--)
        {
          int v = Ord1._magnitude[a] + Ord2._magnitude[a] + carry;
          carry = v / 256;
          o._magnitude[a] = (byte)(v - carry * 256);
        }
        return o;
      }

      public static Ordinate Sub(Ordinate Ord1, Ordinate Ord2)
      {
        Ordinate o = new Ordinate(Ord1._size);
        for (int a = Ord1._magnitude.length - 1, borrow = 0; a > -1; a--)
        {
          if (Ord1._magnitude[a] >= (Ord2._magnitude[a] + borrow))
          {
            o._magnitude[a] = (byte)(Ord1._magnitude[a] - Ord2._magnitude[a] - borrow);
            borrow = 0;
          }
          else
          {
            o._magnitude[a] = (byte)((Ord1._magnitude[a] + 256) - Ord2._magnitude[a] - borrow);
            borrow = 1;
          }
        }
        return o;
      }
    }

     
    //c# wpf
    Code (Text):

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Data;
    using System.Windows.Documents;
    using System.Windows.Input;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;
    using System.Windows.Navigation;
    using System.Windows.Shapes;

    namespace Ordinate
    {
        public partial class MainWindow : Window
        {
            Ord _x, _y;

            internal class Ord
            {
                private int _size;
                private byte[] _magnitude;
                public byte[] Magnitude { get { return _magnitude; } set { _magnitude = value; } }

                public static Ord One(int Size) { Ord o = new Ord(Size); o._magnitude[o._magnitude.Length - 1] = 1; return o; }

                public Ord(int Size)
                {
                    this._size = Size;
                    this._magnitude = new byte[this._size * this._size * 3];
                }

                public static Ord operator +(Ord Ord1, Ord Ord2)
                {
                    if (Ord1._magnitude.Length != Ord2._magnitude.Length)
                        throw new ArgumentException("Operands must have equal dimensions");

                    Ord o = new Ord(Ord1._size);

                    for (int a = Ord1._magnitude.Length - 1, carry = 0; a > -1; a--)
                    {
                        int v = Ord1._magnitude[a] + Ord2._magnitude[a] + carry;
                        carry = v / 256;
                        o._magnitude[a] = (byte)(v - carry * 256);
                    }

                    return o;
                }

                public static Ord operator -(Ord Ord1, Ord Ord2)
                {
                    if (Ord1._magnitude.Length != Ord2._magnitude.Length)
                        throw new ArgumentException("Operands must have equal dimensions");

                    Ord o = new Ord(Ord1._size);

                    for (int a = Ord1._magnitude.Length - 1, borrow = 0; a > -1; a--)
                    {
                        if (Ord1._magnitude[a] >= (Ord2._magnitude[a] + borrow))
                        {
                            o._magnitude[a] = (byte)(Ord1._magnitude[a] - Ord2._magnitude[a] - borrow);
                            borrow = 0;
                        }
                        else
                        {
                            o._magnitude[a] = (byte)((Ord1._magnitude[a] + 256) - Ord2._magnitude[a] - borrow);
                            borrow = 1;
                        }
                    }

                    return o;
                }

                internal static BitmapSource Render(Ord Ord1, Ord Ord2)
                {
                    if (Ord1._magnitude.Length != Ord2._magnitude.Length)
                        throw new ArgumentException("Operands must have equal dimensions");

                    WriteableBitmap buffer = new WriteableBitmap(Ord1._size, Ord1._size, 96, 96, PixelFormats.Rgb24, null);
                    buffer.Lock();
                    buffer.WritePixels(new Int32Rect(0, 0, Ord1._size, Ord1._size), (Ord1 - Ord2)._magnitude, Ord1._size * 3, 0);
                    buffer.Unlock();
                    return buffer;
                }
            }

            public MainWindow()
            {
                InitializeComponent();
            }        

            private void Window_Loaded(object sender, RoutedEventArgs e)
            {
                _x = new Ord(256);
                _y = new Ord(256);
                renderBuffer.BeginInit();
                renderBuffer.Source = Ord.Render(_x, _y);
                renderBuffer.EndInit();
            }
        }
    }
     
    It seems fairly evident that as we created the system of symbolism we should be able to manipulate it at will and yet it seems a subject little spoken of. This code is simply using addition and subtraction within the base 256, a very basic implementation yet able to convey so much.

    EDIT: I leave it to you to rework the code to suit whatever form of interaction you see fit, i have implemented a simple keypress system within the processing code, the extension of which should be easy for most. One might incorporate a system of gestures or mouse interaction to enable speedy transitions.
     
    Last edited: Nov 4, 2011
  2. jcsd
  3. Nov 4, 2011 #2

    phinds

    User Avatar
    Gold Member
    2016 Award

    Re: Symbolism

    what is your question?
     
Know someone interested in this topic? Share this thread via Reddit, Google+, Twitter, or Facebook




Similar Discussions: Opinion regarding included code
  1. Just an opinion (Replies: 6)

  2. Opinions on this ? (Replies: 7)

  3. Code Cracking (Replies: 5)

  4. Cyclic codes (Replies: 4)

  5. An Unbreakable Code? (Replies: 10)

Loading...