mktstats.m

仿真人工金融市场Jackson代码

//  MktStats.m
//  This file defines the methods for the stock market statistician.
//



#import "MktStats.h"

// Implementation of a Market Statistician ..

@implementation MktStats

-initHistory {

   if (diagLevel & METHOD_ENTRY) 
     printf("*** initHistory (MktStats) entry\n");

  // Establish mkt data collection. We will use this class and
  // the EZBin class to generate a histogram, if necessary,
  // and price statistics.
  mktDataList = [List create: [self getZone]];

/*
  // Set up EZBin
  priceBin = [EZBin createBegin: globalZone];
  [priceBin setTitle: "Risky Price Distribution"];
  [priceBin setAxisLabelsX: "Bins" Y: "Count"];
  [priceBin setBinCount: 10];
  [priceBin setLowerBound: 0];
  [priceBin setUpperBound: 1000];
  [priceBin setCollection: mktDataList];
  [priceBin setProbedSelector: M(getRiskyPrice)];
  priceBin = [priceBin createEnd];
*/
  // Set up EZBin
  riskyVolBin = [EZBin createBegin: globalZone];
  [riskyVolBin setGraphics: 0];
  [riskyVolBin setTitle: "Risky Volume Distribution"];
  [riskyVolBin setAxisLabelsX: "Bins" Y: "Count"];
  [riskyVolBin setBinCount: 10];
  [riskyVolBin setLowerBound: 0];
  // top volume of 1 billion?
  [riskyVolBin setUpperBound: 1000000000];
  [riskyVolBin setCollection: mktDataList];
  [riskyVolBin setProbedSelector: M(getRiskyVolume)];
  riskyVolBin = [riskyVolBin createEnd];


  // Set up EZBin
  riskyRetBin = [EZBin createBegin: globalZone];
  [riskyRetBin setGraphics: 0];
  [riskyRetBin setTitle: "Risky Return Distribution"];
  [riskyRetBin setAxisLabelsX: "Bins" Y: "Count"];
  [riskyRetBin setBinCount: 10];
  [riskyRetBin setLowerBound: -1];
  [riskyRetBin setUpperBound: 10];
  [riskyRetBin setCollection: mktDataList];
  [riskyRetBin setProbedSelector: M(getRiskyRet)];
  riskyRetBin = [riskyRetBin createEnd];

  // Add 10 period price history for risky and riskless
  //  assets.  Later can read from a file ...

// Use Gordon model with r=0.10 and g=0.03
  [self addPrices: 28.51: 1];
  [self addRiskLessCF: 0.0000833 : 0.50];
  [self addEarnings: 0.50];
  [self addFundPrice: 28.5714];
// don't step on first one, because this will generate
//  an infinite return since no previous price exists
//  [self step];
  [self addPrices: 28.66 : 1 ];
  [self addRiskLessCF: 0.0000833 : 0];
  [self addFundPrice: 28.5794];
  [self step];
  [self addPrices: 29.01 : 1];
  [self addRiskLessCF: 0.0000833 : 0];
  [self addFundPrice: 28.5873];
  [self step];
  [self addPrices: 28.59 : 1];
  [self addRiskLessCF: 0.0000833 : 0];
  [self addFundPrice: 28.595 ];
  [self step];


  return self;
}

-setDiagLevel: (int) l
{
   if (diagLevel & METHOD_ENTRY) 
     printf("*** setDiagLevel (MktStats) entry\n");

   diagLevel = l;
   return self;
}

-addEarnings: (double) e {
   
   int i;

   if (diagLevel & METHOD_ENTRY) 
     printf("*** addEarnings (MktStats) entry\n");

   // move old entries back and add new
   //  -- this is pretty inefficient, but ...
   for (i = (HISTORYMAX-1); i > 0; i--) {
     earnings[i] = earnings[i-1];
   }
   earnings[0] = e;

   // Update averages and totals
   numEarningsRpts++;
   earningsTotal = earningsTotal + e;
   avgEarnings = earningsTotal/numEarningsRpts;

   if (diagLevel & MKTSTATS_TSERIES) {
     printf ("MKTSTATS(%d) earnings <%f> \n",
	numEarningsRpts, e);
   }

   return self;
}

-addRiskLessCF: (double) riskLessCF : (double) riskyCF{
   
   int i;

   if (diagLevel & METHOD_ENTRY) 
     printf("*** addRiskLessCF (MktStats) entry\n");

   // move old entries back and add new
   //  -- this is pretty inefficient, but ...
   for (i = (HISTORYMAX-1); i > 0; i--) {
     riskLessCFs[i] = riskLessCFs[i-1];
     riskyCFs[i] = riskyCFs[i-1];
   }
   riskyCFs[0] = riskyCF;
   riskLessCFs[0] = riskLessCF;

   // Update averages and totals
   numRiskLessCFs++;
   riskLessCFTotal = riskLessCFTotal + riskLessCF;
   avgRiskLessCF = riskLessCFTotal/numRiskLessCFs;
   riskyCFTotal = riskyCFTotal + riskyCF;
   avgRiskyCF = riskyCFTotal/numRiskLessCFs;

   if (diagLevel & MKTSTATS_TSERIES) {
     printf ("\nMKTSTATS(%d) RL <%f> RiskyCF <%f>\n",
	numRiskLessCFs, riskLessCF, riskyCF);
   }

   return self;
}

-addPrices: (double) riskyP : (double) riskLessP  {
   
   int i;

   if (diagLevel & METHOD_ENTRY) 
     printf("*** addPrices (MktStats) entry\n");

   // move old entries back and add new
   //  -- this is pretty inefficient, but ...
   for (i = (HISTORYMAX-1); i > 0; i--) {
     riskyPrices[i] = riskyPrices[i-1];
     riskLessPrices[i] = riskLessPrices[i-1];
   }
   riskyPrices[0] = riskyP;
   riskLessPrices[0] = riskLessP;

   // Update averages and totals
   periods++;
   riskyPTotal = riskyPTotal + riskyP;
   riskLessPTotal = riskLessPTotal + riskLessP;
   avgRiskyPrice = riskyPTotal/periods;
   avgRiskLessPrice = riskLessPTotal/periods;


   if (diagLevel & MKTSTATS_TSERIES) {
     printf ("MKTSTATS(%d) Risky <%f> \n",
	periods, riskyP );
   }

   return self;
}

-addFundPrice: (double) p {
   
   int i;

   if (diagLevel & METHOD_ENTRY) 
     printf("*** addFundPrice (MktStats) entry\n");

   // move old entries back and add new
   //  -- this is pretty inefficient, but ...
   for (i = (HISTORYMAX-1); i > 0; i--) {
     fundPrices[i] = fundPrices[i-1];
   }
   fundPrices[0] = p;


   if (diagLevel & MKTSTATS_TSERIES) {
     printf ("MKTSTATS(%d) Fundamental <%f>\n",
	periods, p);
   }

   return self;
}

-addVol: (double) v {
   
   int i;

   if (diagLevel & METHOD_ENTRY) 
     printf("*** addVol (MktStats) entry\n");

   // move old entries back and add new
   //  -- this is pretty inefficient, but ...
   for (i = (HISTORYMAX-1); i > 0; i--) {
     riskyVol[i] = riskyVol[i-1];
   }
   riskyVol[0] = v;


   if (diagLevel & MKTSTATS_TSERIES) {
     printf ("MKTSTATS(%d) Volume <%f>\n",
	periods, v);
   }

   return self;
}

-(double) getRiskyMovingAvg: (int) p {
   double movingAvg;
   double total;
   int i;

   if (diagLevel & METHOD_ENTRY) 
     printf("*** getRiskyMovingAvg (MktStats) entry\n");

   if (p > HISTORYMAX)
     p = HISTORYMAX;
 
   total = 0;
   for (i = 0; i < p; i++) 
     total = total + riskyPrices[i]; 

   movingAvg = total/p;

   return movingAvg;
}

-(double) getRiskLessMovingAvg: (int) p {
   double movingAvg;
   double total;
   int i;

   if (diagLevel & METHOD_ENTRY) 
     printf("*** getRiskLessMovingAvg (MktStats) entry\n");

   if (p > HISTORYMAX)
     p = HISTORYMAX;
 
   total = 0;
   for (i = 0; i < p; i++) 
     total = total + riskLessPrices[i]; 

   movingAvg = total/p;

   return movingAvg;
}

-(double) getRiskyLagPrice: (int) lags {
   if (diagLevel & METHOD_ENTRY) 
     printf("*** getRiskLagPrice (MktStats) entry\n");

   return riskyPrices[lags];
}

-(double) getEarningsLag: (int) lags {
   if (diagLevel & METHOD_ENTRY) 
     printf("*** getEarningsLag (MktStats) entry\n");

   return earnings[lags];
}

-(double) getRiskyRetVar {
   double rstd;

   if (diagLevel & METHOD_ENTRY) 
     printf("*** getRiskyRetVar (MktStats) entry\n");
   rstd = [riskyRetBin getStd];

   return (rstd*rstd);
}

-(double) getRiskyLagCF: (int) lags {
   if (diagLevel & METHOD_ENTRY) 
     printf("*** getRiskyLagCF (MktStats) entry\n");

   return riskyCFs[lags];
}

-(double) getRiskyPrice{
   if (diagLevel & METHOD_ENTRY) 
     printf("*** getRiskyPrice (MktStats) entry\n");

   return riskyPrices[0];
}

-(double) getRiskyVol{
   if (diagLevel & METHOD_ENTRY) 
     printf("*** getRiskyVol (MktStats) entry\n");

   return riskyVol[0];
}

-(double) getRiskyCF{
   if (diagLevel & METHOD_ENTRY) 
     printf("*** getRiskyCF (MktStats) entry\n");

   return riskyCFs[0];
}

-(double) getFundPrice{
   if (diagLevel & METHOD_ENTRY) 
     printf("*** getFundPrice (MktStats) entry\n");

   return fundPrices[0];
}

-(double) getRiskLessLagPrice: (int) lags {
   if (diagLevel & METHOD_ENTRY) 
     printf("*** getRiskLessLagPrice (MktStats) entry\n");

   return riskLessPrices[lags];
}

-(double) getRiskLessLagCF: (int) lags {
   if (diagLevel & METHOD_ENTRY) 
     printf("*** getRiskLessLagCF (MktStats) entry\n");

   return riskLessCFs[lags];
}

-(int) getPeriod {
  return periods;
}

-print {
  printf("MKTSTATS TEST\n");
  return self;
}

- collectRiskyVolStats {

   // Update all volume statistics
   [riskyVolBin reset];
   [riskyVolBin update];
   [riskyVolBin output];

  return self;
}

- (double) getRiskyVolAvg {
  return ([riskyVolBin getAverage]);
}

- (double) getRiskyVolStd {
  return ([riskyVolBin getStd]);
}

- collectRiskyRetStats {

   // Update all return statistics
   [riskyRetBin reset];
   [riskyRetBin update];
   [riskyRetBin output];

  return self;
}

- (double) getRiskyRetAvg {
  return ([riskyRetBin getAverage]);
}

- (double) getRiskyRetStd {
  return ([riskyRetBin getStd]);
}

-step {
  
   double riskyRet;
   double p0, p1, d;

   id mktData;

   if ((diagLevel & METHOD_ENTRY)  ||
       (diagLevel & METHOD_SCHED))
     printf("*** step (MktStats) entry\n");

  
   // Only have a collection for risky prices at this point, so
   // I am actually keeping track of them twice for the time being.
   mktData = [MktData create: [self getZone]];
   // Fundamental price will be calculated for this period
   //   since reporter gets his step message first.
   [mktData setRiskyFPrice: [self getFundPrice]];
   [mktData setRiskyPrice: [self getRiskyPrice] CF: [self getRiskyCF] ];
   p0 = [self getRiskyLagPrice: 1];
   p1 = [self getRiskyLagPrice: 0];
   d = [self getRiskyCF];
   riskyRet = ([self getRiskyCF] + [self getRiskyLagPrice: 0] -
		[self getRiskyLagPrice: 1]) / 
		[self getRiskyLagPrice: 1];
//   [mktData setRiskyCFLag: [mktMaker getRiskyCFLag]];
   [mktData setRiskyRet: riskyRet]; 
   [mktData setRiskyVolume: riskyVol[0]]; 
   [mktDataList addLast: mktData]; 

   if (diagLevel & MKTSTATS_TSERIES) {
     printf ("MKTSTATS(%d) riskyRet <%f>\n",
	periods, riskyRet);
   }
  
/*
   [priceBin reset];
   [priceBin update];
   [priceBin output];
*/

   [riskyRetBin reset];
   [riskyRetBin update];
   [riskyRetBin output];

  return self;
}

@end