mktmodelswarm.m

仿真人工金融市场Jackson代码

    UEMHFGrapher = [ActiveGraph createBegin: [self getZone]];
    [UEMHFGrapher setElement: UEMHFElement];
    [UEMHFGrapher setDataFeed: self];
    [UEMHFGrapher setProbedSelector: M(getUEMHFWealth)];
    UEMHFGrapher = [UEMHFGrapher createEnd];

    // create elements to draw on the graph
    BullElement = [wealthGraph createElement];
    [[[BullElement setLabel: "BullTrader"] setColor: "red"] setWidth: 3];
    BullGrapher = [ActiveGraph createBegin: [self getZone]];
    [BullGrapher setElement: BullElement];
    [BullGrapher setDataFeed: self];
    [BullGrapher setProbedSelector: M(getBullWealth)];
    BullGrapher = [BullGrapher createEnd];

    // create elements to draw on the graph
    BearElement = [wealthGraph createElement];
    [[[BearElement setLabel: "BearTrader"] setColor: "brown"] setWidth: 3];
    BearGrapher = [ActiveGraph createBegin: [self getZone]];
    [BearGrapher setElement: BearElement];
    [BearGrapher setDataFeed: self];
    [BearGrapher setProbedSelector: M(getBearWealth)];
    BearGrapher = [BearGrapher createEnd];

    // create elements to draw on the graph
    TChaserElement = [wealthGraph createElement];
    [[[TChaserElement setLabel: "TChaserTrader"] setColor: "purple"] setWidth: 3];
    TChaserGrapher = [ActiveGraph createBegin: [self getZone]];
    [TChaserGrapher setElement: TChaserElement];
    [TChaserGrapher setDataFeed: self];
    [TChaserGrapher setProbedSelector: M(getTChaserWealth)];
    TChaserGrapher = [TChaserGrapher createEnd];
//  #endif


  }

  return self;
}

-buildActions {
  int i;

  [super buildActions];

  // MODIFY: schedule your own agents as appropriate.
  //
  // For now, it should be sufficient to send a step message to each
  //   trader, each time step
  modelActions = [ActionGroup create: [self getZone]];
  [modelActions createActionTo:      mktMaker   message: M(checkBankruptcies)];
  [modelActions createActionForEach: traderList message: M(step)];
  [modelActions createActionTo:      mktMaker   message: M(step)];
  [modelActions createActionTo:      mktStats   message: M(step)];
  [modelActions createActionTo:      reporter   message: M(step)];
  [modelActions createActionTo:      mktMaker   message: M(countShares)];
// #if 0

/*  Comment or if-def these out while running the batch stuff.  Their not
    needed for batch execution and may add some overhead.

    NOTE:  must do the  same for the object creation stuff.
*/

  [modelActions createActionTo:      traderGrapher   message: M(step)];
  [modelActions createActionTo:      BHGrapher   message: M(step)];
  [modelActions createActionTo:      EMHFGrapher   message: M(step)];
  [modelActions createActionTo:      UEMHFGrapher   message: M(step)];
  [modelActions createActionTo:      BullGrapher   message: M(step)];
  [modelActions createActionTo:      BearGrapher   message: M(step)];
  [modelActions createActionTo:      TChaserGrapher   message: M(step)];
// #endif
  //  [modelActions createActionTo:      self       message: M(updateHisto)];

  modelSchedule = [Schedule createBegin: [self getZone]];
  [modelSchedule setRepeatInterval: 90];
  modelSchedule = [modelSchedule createEnd];
  for (i=0; i<89; i++) {
    [modelSchedule at: i createActionTo: mktMaker message:  M(payInterest)];
    [modelSchedule at: i createAction: modelActions];
  }

  [modelSchedule at: 89 createActionTo: mktMaker message:  M(payEarnings)];
  [modelSchedule at: 89 createActionTo: mktMaker message:  M(payInterest)];
  [modelSchedule at: 89 createAction: modelActions];

  return self;
}

-activateIn: (id) swarmContext {
  [super activateIn: swarmContext];

  [modelSchedule activateIn: self];

  return [self getActivity];
}


-(double) getRiskyPrice{
   return  [mktStats getRiskyPrice];
}

-(double) getRiskyVol{
   return  [mktStats getRiskyVol];
}

-(double) getRiskyCF{
   return  [mktStats getRiskyCF];
}

-(double) getRiskyCFNoiseLag{
   return  [mktMaker getRiskyCFNoiseLag];
}

-(double) getFundPrice{
   return  [mktStats getFundPrice];
}

-dumpStatistics {
  Trader * aTrader;
  id index;

  int	numBankruptTraders, totPeriodsToBank;

  // lists for compiling post-run statistics
  bankruptList = [List create: [self getZone]];
  nvrBankruptList = [List create: [self getZone]];


  
  numBankruptTraders = totPeriodsToBank = 0;

  printf ("\n STATISTICS \n");

  // loop through traderList and get wealth/bankruptcy stats
  index = [(id) traderList begin: scratchZone];
  while ((aTrader = [index next])) {
  
    printf ("%s w %f r %f rl %f b %d\n",
      [aTrader getName],
      [aTrader getWealth],
      aTrader->riskyUnits,
      aTrader->riskLessUnits,
      [aTrader getBRPeriod]);

    // I want to compile stats for traders that have never and
    //  have, at some time, been bankrupt.  So simply add to
    //  appropriate lists here.


    if ([aTrader getBRPeriod] != 0) {
      numBankruptTraders = numBankruptTraders + 1;
      totPeriodsToBank = totPeriodsToBank + 
			 [aTrader getBRPeriod];
      [bankruptList addLast: aTrader];
    
    } else { // if never went bankrupt, just add number of 
            //    simulated periods
      totPeriodsToBank = totPeriodsToBank + [mktStats getPeriod];
      [nvrBankruptList addLast: aTrader];
    }

  }
  [index drop];

  [mktStats collectRiskyVolStats];
  printf ("\nRisky Volume Avg (%f) and Std (%f)\n",
	[mktStats getRiskyVolAvg],
        [mktStats getRiskyVolStd]);

  [mktStats collectRiskyRetStats];
  printf ("Risky Return Avg (%f) and Std (%f)\n",
	[mktStats getRiskyRetAvg],
        [mktStats getRiskyRetStd]);

  printf ("Bankrupt traders (%d) out of (%d) \n", 
		numBankruptTraders, numTraders);
  printf ("Avg time to bankruptcy (%f) \n",
		(double) totPeriodsToBank/ (double) numTraders);

  wealthAvg = [Averager createBegin: [self getZone]];
  [wealthAvg setCollection: traderList];
  [wealthAvg setProbedSelector: M(getWealth)];
  wealthAvg = [wealthAvg createEnd];
  [wealthAvg update];

  printf ("Wealth Avg (%f) Min (%f) Max (%f) Total (%f) Count (%d)\n",
	[wealthAvg getAverage],
	[wealthAvg getMin],
	[wealthAvg getMax],
	[wealthAvg getTotal],
        [wealthAvg getCount]);

  bRWealthAvg = [Averager createBegin: [self getZone]];
  [bRWealthAvg setCollection: bankruptList];
  [bRWealthAvg setProbedSelector: M(getWealth)];
  bRWealthAvg = [bRWealthAvg createEnd];
  [bRWealthAvg update];
  
  printf ("BR Wealth Avg (%f) Min (%f) Max (%f) Total (%f) Count (%d)\n",
	[bRWealthAvg getAverage],
	[bRWealthAvg getMin],
	[bRWealthAvg getMax],
	[bRWealthAvg getTotal],
        [bRWealthAvg getCount]);

  nvrBRWealthAvg = [Averager createBegin: [self getZone]];
  [nvrBRWealthAvg setCollection: nvrBankruptList];
  [nvrBRWealthAvg setProbedSelector: M(getWealth)];
  nvrBRWealthAvg = [nvrBRWealthAvg createEnd];
  [nvrBRWealthAvg update];
  
  printf ("NVRBR Wealth Avg (%f) Min (%f) Max (%f) Total (%f) Count (%d)\n",
	[nvrBRWealthAvg getAverage],
	[nvrBRWealthAvg getMin],
	[nvrBRWealthAvg getMax],
	[nvrBRWealthAvg getTotal],
        [nvrBRWealthAvg getCount]);

  printf ("\n RANDOM NUM SEED = (%ld)\n", [mktMaker getRNGSeed]);

  printf ("DATA %f %f %f %f %d %d %f %f %f %f %f %d %f %f %f %f %d %f %f %f %f %d\n",
	[mktStats getRiskyVolAvg],
        [mktStats getRiskyVolStd],
	[mktStats getRiskyRetAvg],
        [mktStats getRiskyRetStd],
	numBankruptTraders, 
	numTraders,
	((double) totPeriodsToBank/ (double) numTraders),
	[wealthAvg getAverage],
	[wealthAvg getTotal],
	[wealthAvg getMax],
	[wealthAvg getMin],
        [wealthAvg getCount],
	[bRWealthAvg getAverage],
	[bRWealthAvg getTotal],
	[bRWealthAvg getMax],
	[bRWealthAvg getMin],
        [bRWealthAvg getCount],
	[nvrBRWealthAvg getAverage],
	[nvrBRWealthAvg getTotal],
	[nvrBRWealthAvg getMax],
	[nvrBRWealthAvg getMin],
        [nvrBRWealthAvg getCount]);


  return self;
}

-(long int) getRNGSeed {
 return  ([mktMaker getRNGSeed]);
}

-updateHisto {
  id 	index;
  int 	i;
  double * traderWealth;
  Trader	* aTrader;
  void  *calloc(), free();
  if (diagLevel & MKTMODELSWARM) {
    printf ("IN HISTO (%d) \n", numTraders);
  }

  traderWealth = (double *) calloc (numTraders, sizeof(double));
  index = [(id) traderList begin: scratchZone];
  for (i=0; i<numTraders; i++) {
    aTrader = [index next];
    traderWealth[i] = [aTrader getWealth];
  }

  [useHisto drawHistogramWithDouble: traderWealth];

  [index drop];
  free (traderWealth);

  return self;
}

-(double) getTotalWealthPercent {
  return ([self getTotalWealth]/[self getTotalWealth]);
}

-(double) getTotalWealth {
  id 	index;
  double  traderWealth;
  Trader	* aTrader;
  if (diagLevel & MKTMODELSWARM) {
    printf ("IN getTotalWealth (%d) \n", numTraders);
  }

  traderWealth = 0;

  index = [(id) traderList begin: scratchZone];
  while ((aTrader = [index next])) {
    traderWealth = traderWealth + [aTrader getWealth];
  }

  [index drop];

  return (traderWealth);
}

-(double) getBHWealth {
  return ([self getIndClassWealth: "BuyHold"]);
}

-(double) getEMHFWealth {
  return ([self getIndClassWealth: "EMHFTrader"]);
}

-(double) getUEMHFWealth {
  return ([self getIndClassWealth: "UEMHFTrader"]);
}

-(double) getBullWealth {
  return ([self getIndClassWealth: "BullEMHFTrader"]);
}

-(double) getBearWealth {
  return ([self getIndClassWealth: "BearEMHFTrader"]);
}

-(double) getTChaserWealth {
  return ([self getIndClassWealth: "TrendChaser"]);
}

-(double) getIndClassWealth: (char *) classStr {
  id 	index;
  double  traderWealth;
  Trader	* aTrader;
  char     traderClass[40];

  if (diagLevel & MKTMODELSWARM) {
    printf ("IN getIndClassWealth (%d) \n", numTraders);
  }


  traderWealth = 0;

  index = [(id) traderList begin: scratchZone];
  while ((aTrader = [index next])) {
  
    strcpy (traderClass, [[aTrader getClass] getName]);
    //  If this is correct class ...
    if ( !(strcmp (traderClass, classStr))) {
      traderWealth = traderWealth + [aTrader getWealth];
    } 

  }

  [index drop];

  return (traderWealth/[self getTotalWealth]);
}

@end