market.m

仿真人工金融市场Jackson代码

#import "Market.h"
#import "Firm.h"
#import "CFactor.h"

@implementation Market

-createEnd {
oldKappa = 0.0;
lastEqPrice = 0;
return self;
}

-copyModel: (id) mo {
modelswarm = mo;  
return self;
}

-setAlpha: (double) a {
  alpha=a;
  return self;
}

-setBeta: (double) b {
  beta=b;
  return self;
}


-(double) getAlpha {
return alpha;
}

-(double)getBeta {
return beta;
}

-setC1: (double) cOne {
 mktFC = cOne;
return self;
}


-(double)getOldKappa {
return oldKappa;
}


-(double)EquilibriumPrice {
double res;
double parte1;
double parte2;
id obj;
obj =[modelswarm getFirm];
parte1 = ([obj getMonop] + [[modelswarm getCFactor] getCFQ]);
parte2 =  kappa * [obj getValD] * [[modelswarm getCFactor] getLastCF]; 
if (kappa<=-1E9){
  res=0;
} else {
res = alpha - beta *parte1 +parte2;
//if (res<0) res=alpha - beta * [[modelswarm getCFactor] getCFQ];
       } 
eqPrice = res;
return res;
}

-(double)getEquilibriumPrice {
return eqPrice;
}
-(double)getLastEquilibriumPrice {
return lastEqPrice;
}

 
-setKperc: (double) kperc1 {
kperc = kperc1;
//printf ('kperc equal to  %d',kperc);
return self;
}


-step {
double temp;
lastEqPrice = [self getEquilibriumPrice];
temp = [self EquilibriumPrice];
return self;
}


-updateK {
double temp = 0.0;
if (kperc<0) { 
temp = 1 + ((kperc/100) * (1 - [self dymamicKappaCappuccio])); 
	} else
 if (kperc>0) { 
temp = 1 + ((kperc/100) * ([self dymamicKappaStar] -1));
	} else
 if (kperc==0){ 
temp = 1; 
  	  }
if ([modelswarm getTime]==1) kMem = temp;
if ([modelswarm getChoiceK] !=0) {
oldKappa = kappa;
kappa = temp;
//printf ("kappa  %f oldkappa %f var \n", kappa, oldKappa);
//if ((kappa < -1E9) || (kappa >1E9)) kappa = kMem;
   } else // kappa costante
{
oldKappa = kMem;
kappa = kMem;
//printf ("kappa  %f oldkappa %f  const\n", kappa, oldKappa);
}
 return self;
}

-(double)geteffe {
double tm=0.0;
tm =  [[modelswarm getCFactor] getFF];
return tm;
}

-(double)getK {
return kappa;
}

// investimento in reputazione
-setD: (double) di {
  reputationInvestment = di;
  return self;
}

// questo metodo mi calcola il prezzo di equilibrio

-(double)getEqPrice: (double) cost {
  return (alpha+(beta*cost))/(2.0*beta);
}

//estremo inferiore dell'intervallo di stabilita' per il parametro k
-(double)dymamicKappaCappuccio {
double num;
double den;          
num = (mktFC+beta) * (mktFC+ 2* beta);
den = reputationInvestment * beta *  [[modelswarm getCFactor] getFF];
//printf (" kcapp num %f  den %f res %f \n", num, den, (1-num/den));
return (1 - num/den);
}


//estremo superiore dell'intervallo di stabilita' per il parametro k
-(double)dymamicKappaStar {
double num;
double den;
num = (mktFC +beta) * (mktFC + 2* beta) - [[modelswarm getCFactor] getFF]  * beta * beta;
den = reputationInvestment * beta *  [[modelswarm getCFactor] getFF];
//printf (" K starnum %f  den %f res %f \n", num, den, (1+num/den));
return (1 + num/den);
}



@end