v1.71 iPhone Creature Feature

Just finished porting the trend shifts platform over to the iPhone. I've also compiled a quick features usage video to help demonstrate how to use the software.



Music provided by AndyT - Creature Feature.

iGrapher

v1.7 Trend Shifts Implemented

We just released the intial implementation of the trend shifts analysis and prediction tools, it works pretty well. I've quickly mocked up a video demonstration on how to use the new tools, just in case it's not so obvious.



Next up, we have to port it over for use on the iPhone, enable it to work off forex data (only minor tweaks required), and then go ahead and put in some more complicated trend analysis, for example as discussed before, differentiating between major/minor trends.

iGrapher

Prediciton platform coming soon in v1.7

We have finally reached a stage where we can now work towards a providing various analysis and prediction algorithms. The first batch of tasks have been designed and are now in development.

So, in the next release you'll have the ability to:

• Draw graphs based on the shifts in price momentum.
• Get statistics on how often the price momentum shifts weekly, monthly, yearly breakdowns.
• Distinguish between the types of shifts occurring (major/minor).
• Estimate the type of the current shift currently occurring and how long it's expected to last.

It's basic analysis, however it'll be a great first step towards a more dynamic analysis tool.

iGrapher

Hacking the Heart

"If open bracket love equal equals true, my heart's pointer is forever assigned to you".

The only way to be forever assigned to someone, is by using a const pointer.
So say we had a heart inside of us..

 class Heart  
 {  
 }; 

 class Us  
 {  
 public:  
      Us()  
      {  
           myHeart = new Heart();  
      }  
      ~Us()  
      {  
           delete myHeart;  
      }  
      const Heart* GetConstHeartPtr()  
      {  
           return myHeart;  
      }  
 private:  
      Heart* myHeart;  
 };  

In our main function, since our hearts are constant, there would be no legal way to fill them. With the only solution being to hack our hearts with memcpy, and write over our heart with their heart.

 int _tmain(int argc, _TCHAR* argv[])  
 {  
      Us *me = new Us();  
      Us *you = new Us();  
      if( me != NULL && you != NULL )  
      {  
           memcpy( me, you, sizeof( Heart ) );  
           if( me->GetConstHeartPtr() == you->GetConstHeartPtr() )  
           {  
                printf( "Love" );  
           }  
      }  
 }  

Hacky but, it still doesn't work. Why? Because our hearts are empty to start with.
Now, if we go back to the start and fill our hearts with something.

 class Heart  
 {  
 public:  
      Heart(const char *name) : name( name )  
      {}  
 private:  
      const char *name;  
 }; 

 class Us  
 {  
 public:  
      Us(const char *name)  
      {  
           myHeart = new Heart( name );  
      }  
      ~Us()  
      {  
           delete myHeart;  
      }  
      const Heart* GetConstHeartPtr()  
      {  
      return myHeart;  
      }  
 private:  
      Heart* myHeart;  
 };  

We'd have something to allocate, because our heart would point to a memory location which contains a name, which can be created with malloc and filled.

 int _tmain(int argc, _TCHAR* argv[])  
 {  
      Us *me = new Us( "me" );  
      Us *you = new Us( "you" );  
      if( me != NULL && you != NULL )  
      {  
           memcpy( me, you, sizeof( Heart ) );  
           if( me->GetConstHeartPtr() == you->GetConstHeartPtr() )  
           {  
                printf( "Love" );  
           }  
      }  
 }  

So what's the lesson to be learned?
Don't try to love a girl that's heartless.