asmmodel.java

这是个java版的人工模拟股市。

package asm;
import java.util.Vector;
/**
 * Title:        Artificial Stock Market
 * Description:  人工模拟股市（来源：SFI的Swarm版本）的Java版本
 * Copyright:    Copyright (c) 2003
 * Company:      http://agents.yeah.net
 * @author jake
 * @version 1.0
 */

//该类主要负责股市的整体运行仿真
public class AsmModel {
  int modelTime;    /*股市的当前的仿真周期*/

  Vector agentList;       /*Agents的一个集合*/
  Specialist specialist=new Specialist();      /*市场专家，负责市场的出清*/
  Dividend dividendProcess; /*一个随机过程模型，产生股息流*/
  World world;          /*世界模型，包括对当前股市状态的编码信息、价格、股息等参数的存储*/
  static asm localasm;  //指向主程序的指针
  AgentParam bfParams;  /*Agent的参数集合*/
  ASMParam asmModelParams;  //股市的参数集合
  public AsmModel(asm local) {
    //初始化人工股市
    modelTime=0;
    asmModelParams=local.ASMParams;
    bfParams=local.AgentParams;
    agentList=new Vector();
    localasm=local;
  }
int getNumBFagents(){
  //得到agent的数目
  return asmModelParams.numBFagents;
}

/*" Returns the initialcash value, which is held in asmModelParams"*/
double getInitialCash()
{
  return asmModelParams.initialcash;
}
public void OneStep(){
  //股市的一步仿真

  //从随机过程股息流里面产生一期的股息
  periodStepDividend();

  //让每个agent进行赋税
  for(int i=0;i<asmModelParams.numBFagents;i++){
    Agent ag=(Agent)agentList.elementAt(i);
    ag.creditEarningsAndPayTaxes();
  }

  //更新世界的编码
  world.updateWorld();

  //让每个agent准备开始进行交易
  for(int i=0;i<asmModelParams.numBFagents;i++){
    Agent ag=(Agent)agentList.elementAt(i);
    //每个agent对股市进行预测，也包括遗传算法的运行
    ag.prepareForTrading();
  }

  // 根据每个agent的预测得到总的股票的需求量和供给量，并最后绝对价格。
  periodStepPrice();

  //完成交易，更新agent的财富、现金、持股量
  specialist.completeTrades(agentList,world);

  //对每个agent的预测进行评估，让他们进行学习
  for(int i=0;i<asmModelParams.numBFagents;i++){
    Agent ag=(Agent)agentList.elementAt(i);
    ag.updatePerformance();
    //纪录agent的当前状态
    ag.RecordHistory(modelTime);
  }

  //纪录世界的当前状态
  world.RecordHistory(modelTime);

  //在主程序的状态文本中显示当前的状态和运行周期
  localasm.setStatus("仿真周期："+String.valueOf(modelTime)+",正在运行..");
}
/*"返回当前的方针周期数值"*/
long getModelTime(){
  return modelTime;
}

/*创建初始化的对象的模型*/
void buildObjects(){

  int i;
  localasm.setStatus("正在初始化股息流随机模型...");

  /* 初始化随机过程 */
  dividendProcess = new Dividend();
  dividendProcess.initNormal();
  dividendProcess.baseline=asmModelParams.baseline;
  dividendProcess.mindividend=asmModelParams.mindividend;
  dividendProcess.maxdividend=asmModelParams.maxdividend;
  dividendProcess.amplitude=asmModelParams.amplitude;
  dividendProcess.setPeriod(asmModelParams.period);
  dividendProcess.setDerivedParams();
  localasm.setStatus("正在初始化虚拟股市世界模型...");

  //初始化虚拟股市世界
  world = new World();
  world.setintrate(asmModelParams.intrate);
  //决定采用那种方法计算移动平均值
  if(asmModelParams.exponentialMAs==1) world.setExponentialMAs(true);
  else world.setExponentialMAs(false);
  //用设定好的数值确定世界的一些初始参数（包括股票初期的价格等等）
  world.initWithBaseline(asmModelParams.baseline);

  localasm.setStatus("正在初始化市场分析专家...");

  //初始化市场分析专家
  specialist =new Specialist();
  specialist.maxprice=asmModelParams.maxprice;
  specialist.minprice=asmModelParams.minprice;
  specialist.setTaup(asmModelParams.taup);
  specialist.setSPtype(asmModelParams.sptype);
  specialist.maxiterations=asmModelParams.maxiterations;
  specialist.minexcess=asmModelParams.minexcess;
  specialist.eta=asmModelParams.eta;
  specialist.rea=asmModelParams.rea;
  specialist.reb=asmModelParams.reb;

  //初始化每个agent
  agentList.removeAllElements();
  for (i = 0; i < asmModelParams.numBFagents; i++)
    {
      Agent agent;
      agent = new Agent(this);
      agent.setBFParameterObject(bfParams);
      agent.setWorld(world);
      agent.myID=i;
      agent.setintrate(asmModelParams.intrate);
      agent.setminHolding(asmModelParams.minholding,asmModelParams.mincash);
      agent.initialcash=asmModelParams.initialcash;
      agent.setInitialHoldings();
      agent.position=asmModelParams.initholding;
      agent.initForecasts();

      agentList.addElement(agent);
      localasm.setStatus("正在初始化Agent："+String.valueOf(i+1)+"/"+String.valueOf(asmModelParams.numBFagents));
    }
    localasm.setStatus("初始化完毕！");
}

/*让随机过程产生一个随机的股息流，然后让世界进行初始的编码*/
public void doWarmupStep(){
  //modelTime++;
  double div = dividendProcess.dividend();
  world.setDividend(div);
  world.updateWorld();
  world.setPrice(div/(double)asmModelParams.intrate);
}

/*随机过程产生一个股息数值，并把这个数值传递给world，然后让仿真周期+1*/
void periodStepDividend(){
  modelTime++;
  world.setDividend(dividendProcess.dividend());
}

/*与分析专家产生出价格并告诉world*/
void periodStepPrice()
{
  world.setPrice(specialist.performTrading(agentList,world));
}
public void terminate(){
    //结束该类
    agentList.removeAllElements();
}
}

//股息流类，主要是一个随机AR(p)过程
class Dividend{
  public double baseline; /*股息随机过程的基线
		     //			This is equal to the mean for a symmetric process
		     //			(i.e., if asymmetry = 0).  "baseline" is set only
		     //			from the parameter file, and should NOT normally
		     //			be changed from the default value (10.0)."*/

  public double amplitude; /*随机振幅
		      //			Measured in units of "baseline".  The standard
		      //			deviation of the process is proportional to this."*/

  public int period;  /*自回归的时间周期*/

  public double mindividend;  /*股息的底线*/
  public double maxdividend; /*股息的上限*/
  public double deviation;
  public double rho;
  public double gauss;
  public double dvdnd;
  //id normal; /*"A Swarm Normal Generator object"*/
void initNormal(){
}

/*设置振幅放大的比例*/
double setAmplitude(double theAmplitude){
  amplitude = theAmplitude;
  if (amplitude < 0.0)
    amplitude = 0.0;
  if (amplitude > 1.0)
    amplitude = 1.0;
  amplitude = 0.0001*(int)(10000.0*amplitude);
  return amplitude;
}

/*设置周期参数，最小不能小于2*/
int setPeriod(int thePeriod){
  period = thePeriod;
  if (period < 2)
    period = 2;
  return period;
}


void setDerivedParams()
/*设置各种参数*/
{
  //deviation是偏离度，没有用到这个参数
  deviation = baseline*amplitude;

  //rho是运行周期的倒数
  rho =Math.exp(-1.0/((double)period));
  rho = 0.0001*(int)(10000.0*rho);
  gauss = deviation*Math.sqrt(1.0-rho*rho);
  //产生股息
  dvdnd = baseline + gauss*normal(1000);
}

/*" 返回股息的数值.  这是核心的方法
  It does NOT use
  the global time, but simply assumes that one period passes between
  each call.  Note that "time" may not be the same as the global
  variable "t" because shifts are introduced to maintain phase when
  certain parameters are changed."*/

double dividend(){
  //pj:
  // dvdnd = baseline + rho*(dvdnd - baseline) + gauss*normal();
  //产生一个AR(1)过程
    dvdnd = baseline + rho*(dvdnd - baseline) + gauss*normal(1000);