mikko_painmeter2





//+------------------------------------------------------------------+
//|                                             MinMax indicator     |
//|                                                            Mikko |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Mikko"
#property link      "noneOfYOurBusiness"

#property indicator_separate_window
//#property indicator_chart_window
#property indicator_buffers 7
#property indicator_color1 Green
#property indicator_color2 Red
#property indicator_color3 Gray
#property indicator_color4 White
#property indicator_color5 Yellow
#property indicator_color6 Orange
#property indicator_color7 YellowGreen

double bullPain[];
double bearPain[];
double painDiff[];
double painMA[];
double buy[];
double sell[];
double symmetry[];

extern int ma = 30;
extern int count = 60; 
extern int arrowPeak = 150;
extern int step = 1;
extern int mamode = MODE_LWMA;
extern int symmetryCount = 5;

/*
extern int count2 = 50; 
extern int step2 = 1; 
extern double multiplier2 = 2;

extern int count3 = 100; 
extern int step3 = 1; 
extern int multiplier3 = 3;
*/

int init() {

   IndicatorBuffers(7);

   SetIndexBuffer(0, bullPain);     
   SetIndexStyle(0, DRAW_LINE, EMPTY, 1);

   SetIndexBuffer(1, bearPain);     
   SetIndexStyle(1, DRAW_LINE, EMPTY, 1);
   
   SetIndexBuffer(2, painDiff);     
   SetIndexStyle(2, DRAW_LINE, EMPTY, 1);
   
   SetIndexBuffer(3, painMA);     
   SetIndexStyle(3, DRAW_LINE, EMPTY, 1);

   SetIndexBuffer(4, buy);
   SetIndexStyle(4, DRAW_ARROW, EMPTY, 1); 
   SetIndexArrow(4, SYMBOL_ARROWUP);
   
   SetIndexBuffer(5, sell);
   SetIndexStyle(5, DRAW_ARROW, EMPTY, 1);
   SetIndexArrow(5, SYMBOL_ARROWDOWN);
   
   SetIndexBuffer(6, symmetry);
   SetIndexStyle(6, DRAW_HISTOGRAM, EMPTY, 1);
      
   IndicatorShortName("Mikko PainMeter "+count+"/"+ma);
   
   //SetIndexDrawBegin(0, 0);  
   
   return(0);
}
  
int deinit() {
   return(0);
}
     
int start() {
       
   int counted_bars=IndicatorCounted();
  
   if(counted_bars < 0) 
       return(-1);
   if(counted_bars > 0)  
       counted_bars--;
       
   int limit = Bars - counted_bars;
   double move;
   int j;
   
   for(int i = limit; i >= 0; i--) {
       move = 0;
       bullPain[i] = 0;
       bearPain[i] = 0;
       painMA[i] = 0;
       
       
       int k;
       for(k=0; k<count; k+=step) {
            j = i+k;
              double jval = (High[j]+Low[j]+Close[j]*2)/4;
              double nowval = (High[i]+Low[i]+Close[i]*2)/4;
              
              // volume does not represent deal count!
              double multiplier = 1; 
              
              /** Pain/ecstacy of loss for each step **/
              bullPain[i] += (jval-nowval)*multiplier;              
              bearPain[i] += (nowval-jval)*multiplier;

              /** Pain of gaining something and not cashing at the high point or
                  perfect entry ecstacy **/

               /*   
              int highPos = iHighest(Symbol(),0,MODE_HIGH,k,i);
              int lowPos = iLowest(Symbol(),0,MODE_LOW,k,i);
                                 
              if(High[highPos] > nowval)                            
                  bullPain[i] += High[highPos]-nowval;
                  
              if(Low[lowPos] < nowval)
                  bearPain[i] += nowval-Low[lowPos];
               */
             
           painDiff[i] = bearPain[i]-bullPain[i];

       }         
   }    
   
   for(i=limit; i>=0; i--) {
       painMA[i] = iMAOnArray(painDiff, 0, ma, 0, mamode, i);              

       //Print(painMA[i+1]+"["+i+"]("+arrowPeak+") < "+painMA[ArrayMinimum(painMA, arrowPeak, i+2)]+"["+ArrayMinimum(painMA, arrowPeak, i+2)+"]");

/*
       if(bearPain[i] > bullPain[i] &&
          bearPain[i] < bearPain[i+1] && bearPain[i+1] > bearPain[i+2]) {
          if(bearPain[i+1] > bearPain[ArrayMinimum(bearPain, arrowPeak, i+2)]) 
         {
           buy[i] = bearPain[i];
         }
       }
       if(bearPain[i] < bullPain[i] &&
          bullPain[i] < bullPain[i+1] && bullPain[i+1] > bullPain[i+2]) {
          if(bullPain[i+1] > bullPain[ArrayMaximum(bullPain, arrowPeak, i+2)]) 
         {
           sell[i] = bullPain[i];
         }
       }
*/
    
       
       if(painMA[i] > painMA[i+1] && painMA[i+1] < painMA[i+2]) {
         if(painMA[i+1] < painMA[ArrayMinimum(painMA, arrowPeak, i+2)]) {
           buy[i] = painMA[i];
         }
       }
       if(painMA[i] < painMA[i+1] && painMA[i+1] > painMA[i+2]) {
         if(painMA[i+1] > painMA[ArrayMaximum(painMA, arrowPeak, i+2)]) {
           sell[i] = painMA[i];
         }
       }
      // calculate symmetry for this Point
      symmetry[i] = (painMA[i]-painMA[i+1])*3;
   }

   
   return(0);
}

double dist(double a, double b) {
   if(a > b)
      return(a-b);
   else
      return(b-a);
}



Sample





Analysis



Market Information Used:

Series array that contains close prices for each bar
Series array that contains the highest prices of each bar
Series array that contains the lowest prices of each bar


Indicator Curves created:


Implements a curve of type DRAW_LINE
Implements a curve of type DRAW_ARROW
Implements a curve of type DRAW_HISTOGRAM

Indicators Used:

Moving average indicator


Custom Indicators Used:

Order Management characteristics:

Other Features: