return Kou_Ap_Fixed((ptOpt->PathDep.Val.V_NUMFUNC_2)->Par[4].Val.V_PDOUBLE,ptOpt->PayOff.Val.V_NUMFUNC_2,ptMod->S0.Val.V_PDOUBLE,ptOpt->Maturity.Val.V_DATE-ptMod->T.Val.V_DATE,r,divid,ptMod->Sigma.Val.V_PDOUBLE,ptMod->Lambda.Val.V_PDOUBLE,ptMod->LambdaPlus.Val.V_PDOUBLE,ptMod->LambdaMinus.Val.V_PDOUBLE,ptMod->P.Val.V_PDOUBLE,&(Met->Res[0].Val.V_DOUBLE),&(Met->Res[1].Val.V_DOUBLE));
}
static int CHK_OPT(AP_Kou_Fixed)(void *Opt, void *Mod)
{
if ((strcmp(((Option*)Opt)->Name,"LookBackCallFixedEuro")==0) || (strcmp( ((Option*)Opt)->Name,"LookBackPutFixedEuro")==0) )
return OK;
return WRONG;
}
static int MET(Init)(PricingMethod *Met,Option *Mod)
{
return OK;
}
PricingMethod MET(AP_Kou_Fixed)=
{
"AP_Kou_LookbackFixed",
{{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(AP_Kou_Fixed),
{{"Price",DOUBLE,{100},FORBID},{"Delta",DOUBLE,{100},FORBID},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(AP_Kou_Fixed),
CHK_ok,
MET(Init)
} ;
}
Met->Par[1].Val.V_LONG=50000;
Met->Par[2].Val.V_INT=1;
Met->Par[3].Val.V_ENUM.value=0;
Met->Par[3].Val.V_ENUM.members=&PremiaEnumRNGs;
Met->Par[4].Val.V_ENUM.value=0;
Met->Par[4].Val.V_ENUM.members=&PremiaEnumAfd;
Met->Par[5].Val.V_INT=3;
}
return OK;
}
PricingMethod MET(MC_Andersen_BermudanSwaption)=
{
"MC_Andersen_BermudanSwaption",
{
{"N Simulations Parms",LONG,{100},ALLOW},
{"N Simulations",LONG,{100},ALLOW},
{"N Steps per Period",INT,{100},ALLOW},
{"RandomGenerator",ENUM,{100},ALLOW},
{"Martingale Measure",ENUM,{100},ALLOW},
{"N Kink-Points",INT,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(MC_Andersen_BermudanSwaption),
{{"Price",DOUBLE,{100},FORBID},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(MC_Andersen_BermudanSwaption),
CHK_ok,
MET(Init)
};
if ((strcmp(((Option*)Opt)->Name,"ZeroCouponCallBondEuro")==0) || (strcmp(((Option*)Opt)->Name,"ZeroCouponCallBondAmer")==0) || (strcmp(((Option*)Opt)->Name,"ZeroCouponPutBondEuro")==0) || (strcmp(((Option*)Opt)->Name,"ZeroCouponPutBondAmer")==0) )
return OK;
else
return WRONG;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->Par[0].Val.V_LONG=200;
}
return OK;
}
PricingMethod MET(TR_ZBOBK1D)=
{
"TR_BlackKarasinski1d_ZBO",
{{"TimeStepNumber",LONG,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(TR_ZBOBK1D),
{{"Price",DOUBLE,{100},FORBID},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(TR_ZBOBK1D),
CHK_ok,
MET(Init)
} ;
static int CHK_OPT(TR_SingularPoints_Up)(void *Opt, void *Mod)
{
if ( (strcmp( ((Option*)Opt)->Name,"PutAmer")==0) || (strcmp( ((Option*)Opt)->Name,"CallAmer")==0) || (strcmp( ((Option*)Opt)->Name,"PutEuro")==0) || (strcmp( ((Option*)Opt)->Name,"CallEuro")==0))
return OK;
return WRONG;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->Par[0].Val.V_INT2=100;
Met->Par[1].Val.V_PDOUBLE=0.0001;
}
return OK;
}
PricingMethod MET(TR_SingularPoints_Up)=
{
"TR_SingularPointsUp",
{{"StepNumbers between dividends dates",INT2,{100},ALLOW},{"Tollerance Error",PDOUBLE,{100},ALLOW},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(TR_SingularPoints_Up),
{{"Price",DOUBLE,{100},FORBID},{"Delta",DOUBLE,{100},FORBID} ,{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(TR_SingularPoints_Up),
CHK_tree,
MET(Init)
};
{"Upper Bound",1},
{ "Shifted Log Normal Quad",2},
{ NULL, NULLINT }
};
static DEFINE_ENUM(ComputationMethodUp,ComputationMethodUpMembers);
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->Par[0].Val.V_ENUM.value=1;
Met->Par[0].Val.V_ENUM.members=&ComputationMethodUp;
}
return OK;
}
PricingMethod MET(AP_FixedAsian_LordUp)=
{
"AP_FixedAsian_LordUp",
{ {"Conditioning Method",ENUM,{100},ALLOW},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(AP_FixedAsian_LordUp),
{{"Price",DOUBLE,{100},FORBID},{"Delta",DOUBLE,{100},FORBID} ,{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(AP_FixedAsian_LordUp),
CHK_ok,
MET(Init)
};
int
each_file(char *cur_file, Cmd_Info *cmd_info)
{
Elf *elf = 0;
Elf_Cmd cmd;
Elf *arf = 0;
Elf_Arhdr *mem_header;
char *cur_filenm = NULL;
int code = 0;
int error = 0, err = 0;
int ar_file = 0;
int fdartmp;
int fd;
int oflag;
if (cmd_info->flags & MIGHT_CHG)
oflag = O_RDWR;
else
oflag = O_RDONLY;
if ((fd = open(cur_file, oflag)) == -1) {
error_message(OPEN_ERROR,
SYSTEM_ERROR, strerror(errno), prog, cur_file);
return (FAILURE);
}
/*
* Note, elf_begin requires ELF_C_READ even if MIGHT_CHK is in effect.
* libelf does not allow elf_begin() with ELF_C_RDWR when processing
* archive file members. Because we are limited to ELF_C_READ use, any
* ELF data modification must be provided by updating a copy of
* the data, rather than updating the original file data.
*/
cmd = ELF_C_READ;
if ((arf = elf_begin(fd, cmd, (Elf *)0)) == 0) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
(void) elf_end(arf);
(void) close(fd); /* done processing this file */
return (FAILURE);
}
if ((elf_kind(arf) == ELF_K_AR)) {
ar_file = 1;
if (CHK_OPT(cmd_info, MIGHT_CHG)) {
artmpfile = tempnam(TMPDIR, "mcs2");
if ((fdartmp = open(artmpfile,
O_WRONLY | O_APPEND | O_CREAT,
(mode_t)0666)) == NULL) {
error_message(OPEN_TEMP_ERROR,
SYSTEM_ERROR, strerror(errno),
prog, artmpfile);
(void) elf_end(arf);
(void) close(fd);
exit(FAILURE);
}
/* write magic string to artmpfile */
if ((write(fdartmp, ARMAG, SARMAG)) != SARMAG) {
error_message(WRITE_ERROR,
SYSTEM_ERROR, strerror(errno),
prog, artmpfile, cur_file);
mcs_exit(FAILURE);
}
}
} else {
ar_file = 0;
cur_filenm = cur_file;
}
/*
* Holds temporary file;
* if archive, holds the current member file if it has an ehdr,
* and there were no errors in
* processing the object file.
*/
elftmpfile = tempnam(TMPDIR, "mcs1");
while ((elf = elf_begin(fd, cmd, arf)) != 0) {
if (ar_file) /* get header info */ {
size_t len;
if ((mem_header = elf_getarhdr(elf)) == NULL) {
error_message(GETARHDR_ERROR,
LIBelf_ERROR, elf_errmsg(-1),
prog, cur_file, elf_getbase(elf));
(void) elf_end(elf);
(void) elf_end(arf);
(void) close(fd);
(void) unlink(artmpfile);
return (FAILURE);
}
if (cur_filenm != NULL)
free(cur_filenm);
len = (strlen(cur_file) + 3 +
strlen(mem_header->ar_name));
if ((cur_filenm = malloc(len)) == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0,
prog);
mcs_exit(FAILURE);
}
(void) snprintf(cur_filenm, len, "%s[%s]",
cur_file, mem_header->ar_name);
}
if (elf_kind(elf) == ELF_K_ELF) {
if ((code = process_file(elf, cur_filenm, cmd_info)) ==
FAILURE) {
if (!ar_file) {
(void) elf_end(arf);
(void) elf_end(elf);
(void) close(fd);
return (FAILURE);
} else {
copy_non_elf_to_temp_ar(
fd, elf, fdartmp, mem_header,
cur_file, cmd_info);
error++;
}
} else if (ar_file && CHK_OPT(cmd_info, MIGHT_CHG)) {
if (code == DONT_BUILD)
copy_non_elf_to_temp_ar(
fd, elf, fdartmp, mem_header,
cur_file, cmd_info);
else
copy_elf_file_to_temp_ar_file(
fdartmp, mem_header, cur_file);
}
} else {
/*
* decide what to do with non-ELF file
*/
if (!ar_file) {
error_message(FILE_TYPE_ERROR,
PLAIN_ERROR, (char *)0,
prog, cur_filenm);
(void) close(fd);
return (FAILURE);
} else {
if (CHK_OPT(cmd_info, MIGHT_CHG))
copy_non_elf_to_temp_ar(
fd, elf, fdartmp, mem_header,
cur_file, cmd_info);
}
}
cmd = elf_next(elf);
(void) elf_end(elf);
}
err = elf_errno();
if (err != 0) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(err), prog);
error_message(NOT_MANIPULATED_ERROR,
PLAIN_ERROR, (char *)0,
prog, cur_file);
return (FAILURE);
}
(void) elf_end(arf);
if (ar_file && CHK_OPT(cmd_info, MIGHT_CHG)) {
(void) close(fdartmp); /* done writing to ar_temp_file */
/* copy ar_temp_file to FILE */
copy_file(fd, cur_file, artmpfile);
} else if (code != DONT_BUILD && CHK_OPT(cmd_info, MIGHT_CHG))
copy_file(fd, cur_file, elftmpfile);
(void) close(fd); /* done processing this file */
return (error);
}
{
return strcmp( ((Option*)Opt)->Name,"PutEuro");
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
}
return OK;
}
PricingMethod MET(CF_PutHeston)=
{
"CF_Put_Heston",
{{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(CF_PutHeston),
{{"Price",DOUBLE,{100},FORBID},
{"Delta",DOUBLE,{100},FORBID} ,
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(CF_PutHeston),
CHK_ok,
MET(Init)
};
}
return OK;
else
return WRONG;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->Par[0].Val.V_LONG=400;
}
return OK;
}
PricingMethod MET(FD_ZCBond)=
{
"FD_Explicit_Cir1d_ZCBond",
{{"TimeStepNumber",LONG,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(FD_ZCBOND),
{{"Price",DOUBLE,{100},FORBID},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(FD_ZCBond),
CHK_ok,
MET(Init)
} ;
{
if ((strcmp(((Option*)Opt)->Name,"PayerBermudanSwaption")==0) || (strcmp(((Option*)Opt)->Name,"ReceiverBermudanSwaption")==0))
return OK;
else
return WRONG;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->HelpFilenameHint = "tr_hullwhite1dgeneralized_bermudianswaption";
Met->Par[0].Val.V_INT=50;
}
return OK;
}
PricingMethod MET(TR_BermudianSwaptionHW1DG)=
{
"TR_HullWhite1dG_BermudianSwaption",
{{"TimeStepNumber per Period",INT,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(TR_BermudianSwaptionHW1DG),
{{"Price",DOUBLE,{100},FORBID}/*,{"Delta",DOUBLE,{100},FORBID}*/ ,{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(TR_BermudianSwaptionHW1DG),
CHK_ok,
MET(Init)
} ;
{
return NONACTIVE;
}
int CALC(FD_GreedySvd)(void *Opt,void *Mod,PricingMethod *Met)
{
return AVAILABLE_IN_FULL_PREMIA;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->HelpFilenameHint = "FD_svd_bs";
}
return OK;
}
PricingMethod MET(FD_GreedySvd)=
{
"FD_Greedy",
{{"Discretization points per dimension",PINT,{51},ALLOW}, {" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(FD_GreedySvd),
{{"Price",DOUBLE,{100},FORBID},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(FD_GreedySvd),
CHK_split,
MET(Init)
};
}
{
return NONACTIVE;
}
int CALC(CF_Carr_DoubleHeston)(void*Opt,void *Mod,PricingMethod *Met)
{
return AVAILABLE_IN_FULL_PREMIA;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
}
return OK;
}
PricingMethod MET(CF_Carr_DoubleHeston)=
{
"CF_Carr_DoubleHeston",
{{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(CF_Carr_DoubleHeston),
{{"Price",DOUBLE,{100},FORBID},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(CF_Carr_DoubleHeston),
CHK_ok,
MET(Init)
};
{
Met->Res[1].Viter=IRRELEVANT;
Met->Res[2].Viter=IRRELEVANT;
Met->Res[3].Viter=IRRELEVANT;
}
else
{
Met->Res[1].Viter=ALLOW;
Met->Res[2].Viter=ALLOW;
Met->Res[3].Viter=ALLOW;
}
return OK;
}
PricingMethod MET(MC_SWAPTION)=
{
"MC_Cir2d_Swaption",
{{"N iterations",LONG,{100},ALLOW},{"TimeStepNumber",INT2,{100},ALLOW},
{"RandomGenerator",ENUM,{100},ALLOW},
{"Confidence Value",DOUBLE,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(MC_SWAPTION),
{{"Price",DOUBLE,{100},FORBID},{"Error Price",DOUBLE,{100},FORBID},
{"Inf Price",DOUBLE,{100},FORBID},
{"Sup Price",DOUBLE,{100},FORBID} ,{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(MC_SWAPTION),
CHK_ok,
MET(Init)
} ;
static int CHK_OPT(CF_LibAffCir1d_Direct_Swaption)(void *Opt, void *Mod)
{
if ((strcmp(((Option*)Opt)->Name,"PayerSwaption")==0) || (strcmp(((Option*)Opt)->Name,"ReceiverSwaption")==0))
return OK;
else
return WRONG;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->HelpFilenameHint = "cf_libor_affine_cir1d_swaption_direct";
}
return OK;
}
PricingMethod MET(CF_LibAffCir1d_Direct_Swaption)=
{
"CF_LibAffCir1d_Direct_Swaption",
{{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(CF_LibAffCir1d_Direct_Swaption),
{{"Price",DOUBLE,{100},FORBID},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(CF_LibAffCir1d_Direct_Swaption),
CHK_ok,
MET(Init)
} ;
}
static int CHK_OPT(CF_Cap)(void *Opt, void *Mod)
{
return strcmp( ((Option*)Opt)->Name,"Cap");
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
}
return OK;
}
PricingMethod MET(CF_Cap)=
{
"CF_Cirpp1d_Cap",
{{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(CF_Cap),
{{"Price",DOUBLE,{100},FORBID}/*,{"Delta",DOUBLE,{100},FORBID} */,{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(CF_Cap),
CHK_ok,
MET(Init)
} ;
static void
copy_non_elf_to_temp_ar(
int fd,
Elf *elf,
int fdartmp,
Elf_Arhdr *mem_header,
char *cur_file,
Cmd_Info *cmd_info)
{
char mem_header_buf[sizeof (struct ar_hdr) + 1];
char *file_buf;
if (strcmp(mem_header->ar_name, "/") != 0) {
(void) sprintf(mem_header_buf, FORMAT,
mem_header->ar_rawname,
mem_header->ar_date,
(unsigned)mem_header->ar_uid,
(unsigned)mem_header->ar_gid,
(unsigned)mem_header->ar_mode,
mem_header->ar_size, ARFMAG);
if (write(fdartmp, mem_header_buf, sizeof (struct ar_hdr)) !=
sizeof (struct ar_hdr)) {
error_message(WRITE_MANI_ERROR,
SYSTEM_ERROR, strerror(errno),
prog, cur_file);
mcs_exit(FAILURE);
}
if ((file_buf =
malloc(ROUNDUP(mem_header->ar_size))) == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0,
prog);
mcs_exit(FAILURE);
}
if (lseek(fd, elf_getbase(elf), 0) != elf_getbase(elf)) {
error_message(WRITE_MANI_ERROR,
prog, cur_file);
mcs_exit(FAILURE);
}
if (read(fd, file_buf,
(size_t)ROUNDUP(mem_header->ar_size)) !=
(size_t)ROUNDUP(mem_header->ar_size)) {
error_message(READ_MANI_ERROR,
SYSTEM_ERROR, strerror(errno),
prog, cur_file);
mcs_exit(FAILURE);
}
if (write(fdartmp,
file_buf,
(size_t)ROUNDUP(mem_header->ar_size)) !=
(size_t)ROUNDUP(mem_header->ar_size)) {
error_message(WRITE_MANI_ERROR,
SYSTEM_ERROR, strerror(errno),
prog, cur_file);
mcs_exit(FAILURE);
}
free(file_buf);
} else if (CHK_OPT(cmd_info, MIGHT_CHG)) {
error_message(SYM_TAB_AR_ERROR,
PLAIN_ERROR, (char *)0,
prog, cur_file);
error_message(EXEC_AR_ERROR,
PLAIN_ERROR, (char *)0,
cur_file);
}
}
return WRONG;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->HelpFilenameHint = "fd_fem_updownout_bs";
Met->Par[0].Val.V_INT2=100;
Met->Par[1].Val.V_INT2=100;
Met->Par[2].Val.V_RGDOUBLE=0.5;
Met->Par[3].Val.V_DOUBLE=1.5;
}
return OK;
}
PricingMethod MET(FD_Fem_Out)=
{
"FD_Fem_Out",
{{"SpaceStepNumber",INT2,{100},ALLOW },{"TimeStepNumber",INT2,{100},ALLOW},
{"Theta",RGDOUBLE051,{100},ALLOW}, {"Refinement",RGDOUBLE14,{100},ALLOW},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(FD_Fem_Out),
{{"Price",DOUBLE,{100},FORBID},{"Delta",DOUBLE,{100},FORBID} ,{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(FD_Fem_Out),
CHK_split,
MET(Init)
};
static int
traverse_file(Elf *elf, GElf_Ehdr * ehdr, char *cur_file, Cmd_Info *cmd_info)
{
Elf_Scn * scn;
Elf_Scn * temp_scn;
Elf_Data * data;
GElf_Shdr * shdr;
char *temp_name;
section_info_table * sinfo;
GElf_Xword x;
int ret = 0, SYM = 0; /* used by strip command */
int phnum = ehdr->e_phnum;
unsigned int i, scn_index;
size_t shstrndx, shnum;
Sect_exists = 0;
if (elf_getshnum(elf, &shnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (elf_getshstrndx(elf, &shstrndx) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
scn = 0;
scn_index = 1;
sinfo = &sec_table[scn_index];
while ((scn = elf_nextscn(elf, scn)) != 0) {
char *name;
shdr = &(sinfo->shdr);
if (gelf_getshdr(scn, shdr) == NULL) {
error_message(NO_SECT_TABLE_ERROR,
LIBelf_ERROR, elf_errmsg(-1),
prog, cur_file);
return (FAILURE);
} else {
name = elf_strptr(elf, shstrndx,
(size_t)shdr->sh_name);
if (name == NULL)
name = "_@@@###";
}
sinfo->scn = scn;
sinfo->secno = scn_index;
sinfo->osecno = scn_index;
SET_ACTION(sinfo->flags, ACT_NOP);
sinfo->name = name;
if (ehdr->e_phnum == 0)
SET_LOC(sinfo->flags, NOSEG);
else
SET_LOC(sinfo->flags, scn_location(scn, elf));
if (shdr->sh_type == SHT_GROUP) {
if (list_appendc(&cmd_info->sh_groups, sinfo) == 0) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
}
/*
* If the target section is pointed by a section
* holding relocation infomation, then the
* pointing section would be useless if the
* target section is removed.
*/
if ((shdr->sh_type == SHT_REL ||
shdr->sh_type == SHT_RELA) &&
(shdr->sh_info != SHN_UNDEF &&
(temp_scn = elf_getscn(elf, shdr->sh_info)) != 0)) {
GElf_Shdr tmp_shdr;
if (gelf_getshdr(temp_scn, &tmp_shdr) != NULL) {
temp_name = elf_strptr(elf, shstrndx,
(size_t)tmp_shdr.sh_name);
sinfo->rel_name = temp_name;
sinfo->rel_scn_index =
shdr->sh_info;
if (phnum == 0)
sinfo->rel_loc = NOSEG;
else
sinfo->rel_loc =
scn_location(temp_scn, elf);
}
}
data = 0;
if ((data = elf_getdata(scn, data)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
sinfo->data = data;
/*
* Check if this section is a candidate for
* action to be processes.
*/
if (sectcmp(name) == 0) {
SET_CANDIDATE(sinfo->flags);
/*
* This flag just shows that there was a
* candidate.
*/
Sect_exists++;
}
/*
* Any of the following section types should
* also be removed (if possible) if invoked via
* the 'strip' command.
*/
if (CHK_OPT(cmd_info, I_AM_STRIP) &&
((shdr->sh_type == SHT_SUNW_DEBUG) ||
(shdr->sh_type == SHT_SUNW_DEBUGSTR))) {
SET_CANDIDATE(sinfo->flags);
Sect_exists++;
}
/*
* Zap this file ?
*/
if ((cmd_info->flags & zFLAG) &&
(shdr->sh_type == SHT_PROGBITS)) {
SET_CANDIDATE(sinfo->flags);
Sect_exists++;
}
x = GET_LOC(sinfo->flags);
/*
* Remeber the note sections index so that we can
* reset the NOTE segments offset to point to it.
*
* It may have been assigned a new location in the
* resulting output elf image.
*/
if (shdr->sh_type == SHT_NOTE)
notesctndx = scn_index;
if (x == IN || x == PRIOR)
off_table[scn_index] =
shdr->sh_offset;
if (shdr->sh_type == SHT_NOBITS)
nobits_table[scn_index] = 1;
/*
* If this section satisfies the condition,
* apply the actions specified.
*/
if (ISCANDIDATE(sinfo->flags)) {
ret += apply_action(sinfo, cur_file, cmd_info);
}
/*
* If I am strip command, determine if symtab can go or not.
*/
if (CHK_OPT(cmd_info, I_AM_STRIP) &&
(CHK_OPT(cmd_info, xFLAG) == 0) &&
(CHK_OPT(cmd_info, lFLAG) == 0)) {
if (shdr->sh_type == SHT_SYMTAB &&
GET_LOC(sinfo->flags) == AFTER) {
SYM = scn_index;
}
}
scn_index++;
sinfo++;
}
sinfo->scn = (Elf_Scn *) -1;
/*
* If there were any errors traversing the file,
* just return error.
*/
if (ret != 0)
return (FAILURE);
/*
* Remove symbol table if possible
*/
if (CHK_OPT(cmd_info, I_AM_STRIP) && SYM != 0) {
GElf_Shdr tmp_shdr;
(void) gelf_getshdr(sec_table[SYM].scn, &tmp_shdr);
sec_table[SYM].secno = (GElf_Word)DELETED;
++(cmd_info->no_of_nulled);
if (Sect_exists == 0)
++Sect_exists;
SET_ACTION(sec_table[SYM].flags, ACT_DELETE);
off_table[SYM] = 0;
/*
* Can I remove section header
* string table ?
*/
if ((tmp_shdr.sh_link < shnum) &&
(tmp_shdr.sh_link != SHN_UNDEF) &&
(tmp_shdr.sh_link != shstrndx) &&
(GET_LOC(sec_table[tmp_shdr.sh_link].flags) == AFTER)) {
sec_table[tmp_shdr.sh_link].secno = (GElf_Word)DELETED;
++(cmd_info->no_of_nulled);
if (Sect_exists == 0)
++Sect_exists;
SET_ACTION(sec_table[tmp_shdr.sh_link].flags,\
ACT_DELETE);
off_table[tmp_shdr.sh_link] = 0;
}
}
/*
* If I only printed the contents, then
* just report so.
*/
if (CHK_OPT(cmd_info, pFLAG) && !CHK_OPT(cmd_info, MIGHT_CHG))
return (DONT_BUILD); /* don't bother creating a new file */
/* since the file has not changed */
/*
* I might need to add a new section. Check it.
*/
if (Sect_exists == 0 && CHK_OPT(cmd_info, aFLAG)) {
int act = 0;
new_sec_string = calloc(1, cmd_info->str_size + 1);
if (new_sec_string == NULL)
return (FAILURE);
for (act = 0; act < actmax; act++) {
if (Action[act].a_action == ACT_APPEND) {
(void) strcat(new_sec_string,
Action[act].a_string);
(void) strcat(new_sec_string, "\n");
cmd_info->no_of_append = 1;
}
}
}
/*
* If I did not append any new sections, and I did not
* modify/delete any sections, then just report so.
*/
if ((Sect_exists == 0 && cmd_info->no_of_append == 0) ||
!CHK_OPT(cmd_info, MIGHT_CHG))
return (DONT_BUILD);
/*
* Found at least one section which was processed.
* Deleted or Appended or Compressed.
*/
if (Sect_exists) {
/*
* First, handle the deleted sections.
*/
if (cmd_info->no_of_delete != 0 ||
cmd_info->no_of_nulled != 0) {
int acc = 0;
int rel_idx;
/*
* Handle relocation/target
* sections.
*/
sinfo = &(sec_table[0]);
for (i = 1; i < shnum; i++) {
sinfo++;
rel_idx = sinfo->rel_scn_index;
if (rel_idx == 0)
continue;
/*
* If I am removed, then remove my
* target section.
*/
if (((sinfo->secno ==
(GElf_Word)DELETED) ||
(sinfo->secno ==
(GElf_Word)NULLED)) &&
sinfo->rel_loc != IN) {
if (GET_LOC(sec_table[rel_idx].flags) ==
PRIOR)
sec_table[rel_idx].secno =
(GElf_Word)NULLED;
else
sec_table[rel_idx].secno =
(GElf_Word)DELETED;
SET_ACTION(sec_table[rel_idx].flags,\
ACT_DELETE);
}
/*
* I am not removed. Check if my target is
* removed or nulled. If so, let me try to
* remove my self.
*/
if (((sec_table[rel_idx].secno ==
(GElf_Word)DELETED) ||
(sec_table[rel_idx].secno ==
(GElf_Word)NULLED)) &&
(GET_LOC(sinfo->flags) != IN)) {
if (GET_LOC(sinfo->flags) ==
PRIOR)
sinfo->secno =
(GElf_Word)NULLED;
else
sinfo->secno =
(GElf_Word)DELETED;
SET_ACTION(sinfo->flags,\
ACT_DELETE);
}
}
/*
* Now, take care of DELETED sections
*/
sinfo = &(sec_table[1]);
for (i = 1; i < shnum; i++) {
shdr = &(sinfo->shdr);
if (sinfo->secno == (GElf_Word)DELETED) {
acc++;
/*
* The SHT_GROUP section which this section
* is a member may be able to be removed.
* See post_process().
*/
if (shdr->sh_flags & SHF_GROUP)
cmd_info->flags |= SHF_GROUP_DEL;
} else {
/*
* The data buffer of SHT_GROUP this section
* is a member needs to be updated.
* See post_process().
*/
sinfo->secno -= acc;
if ((shdr->sh_flags &
SHF_GROUP) && (acc != 0))
cmd_info->flags |= SHF_GROUP_MOVE;
}
sinfo++;
}
}
}
/*
* I know that the file has been modified.
* A new file need to be created.
*/
return (SUCCESS);
}
static int first=1;
if (first)
{
Met->Par[0].Val.V_PDOUBLE=2.0;
Met->Par[1].Val.V_PDOUBLE=0.01;
Met->Par[2].Val.V_INT2=600;
first=0;
}
return OK;
}
PricingMethod MET(AP_fastwhamer)=
{
"AP_FastWHAmer",
{ {"Scale of logprice range", DOUBLE, {100}, ALLOW},
{"Space Discretization Step",DOUBLE,{500},ALLOW},
{"TimeStepNumber",INT2,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(AP_fastwhamer),
{{"Price",DOUBLE,{100},FORBID},
{"Delta",DOUBLE,{100},FORBID},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(AP_fastwhamer),
CHK_split,
MET(Init)
};
{
if ( Met->init == 0)
{
Met->init=1;
Met->HelpFilenameHint = "mc_cgmy_lookbackfixed";
Met->Par[0].Val.V_ENUM.value=0;
Met->Par[0].Val.V_ENUM.members=&PremiaEnumMCRNGs;
Met->Par[1].Val.V_PINT=100;
Met->Par[2].Val.V_LONG=100000;
}
return OK;
}
PricingMethod MET(MC_CGMY_FixedLookback)=
{
"MC_CGMY_FixedLookback",
{{"RandomGenerator",ENUM,{100},ALLOW},
{"Number of discretization steps",LONG,{100},ALLOW},{"N iterations",LONG,{100},ALLOW},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(MC_CGMY_FixedLookback),
{
{"Price",DOUBLE,{100},FORBID},
{"Delta",DOUBLE,{100},FORBID},
{"Price Error",DOUBLE,{100},FORBID},
{"Delta Error",DOUBLE,{100},FORBID},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(MC_CGMY_FixedLookback),
CHK_ok,
MET(Init)
} ;
return WRONG;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->Par[0].Val.V_LONG=10;
}
return OK;
}
PricingMethod MET(TR_CapFloorLRS1D)=
{
"TR_LRS1D_CapFloor",
{{"TimeStepNumber for Period",LONG,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(TR_CapFloorLRS1D),
{{"Price",DOUBLE,{100},FORBID}/*,{"Delta",DOUBLE,{100},FORBID} */,{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(TR_CapFloorLRS1D),
CHK_ok,
MET(Init)
} ;
return OK;
}
PricingMethod MET(MC_Alfonsi_Bates)=
{
"MC_Alfonsi_Bates",
{{"N iterations",LONG,{100},ALLOW},
{"TimeStepNumber",LONG,{100},ALLOW},
{"RandomGenerator",ENUM,{100},ALLOW},
{"Confidence Value",DOUBLE,{100},ALLOW},
{"Cir Order",ENUM,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(MC_Alfonsi_Bates),
{{"Price",DOUBLE,{100},FORBID},
{"Delta",DOUBLE,{100},FORBID} ,
{"Error Price",DOUBLE,{100},FORBID},
{"Error Delta",DOUBLE,{100},FORBID} ,
{"Inf Price",DOUBLE,{100},FORBID},
{"Sup Price",DOUBLE,{100},FORBID} ,
{"Inf Delta",DOUBLE,{100},FORBID},
{"Sup Delta",DOUBLE,{100},FORBID} ,
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(MC_Alfonsi_Bates),
CHK_mc,
MET(Init)
};
Met->Par[3].Val.V_RGDOUBLE12= 1.5;
Met->Par[4].Val.V_DOUBLE= 0.95;
}
return OK;
}
PricingMethod MET(MC_Pelsser_Heston)=
{
"MC_Pelsser",
{{"N iterations",INT,{100},ALLOW},
{"TimeStepNumber",INT,{100},ALLOW},
{"RandomGenerator",ENUM,{100},ALLOW},
{"THRESHOLD",DOUBLE,{100},ALLOW},
{"Confidence Value",DOUBLE,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(MC_Pelsser_Heston),
{{"Price",DOUBLE,{100},FORBID},
{"Delta",DOUBLE,{100},FORBID} ,
{"Error Price",DOUBLE,{100},FORBID},
{"Error Delta",DOUBLE,{100},FORBID} ,
{"Inf Price",DOUBLE,{100},FORBID},
{"Sup Price",DOUBLE,{100},FORBID} ,
{"Inf Delta",DOUBLE,{100},FORBID},
{"Sup Delta",DOUBLE,{100},FORBID} ,
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(MC_Pelsser_Heston),
CHK_mc,
MET(Init)
};
Met->Res[6].Viter=ALLOW;
Met->Res[7].Viter=ALLOW;
}
return OK;
}
PricingMethod MET(MC_Dupire)=
{
"MC_Dupire",
{{"N iterations",LONG,{100},ALLOW},{"TimeStepNumber",LONG,{100},ALLOW},
{"RandomGenerator (Quasi Random not supported)",ENUM,{100},ALLOW},
{"Delta Increment Rel (Digit)",PDOUBLE,{100},ALLOW},
{"Confidence Value",DOUBLE,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(MC_Dupire),
{{"Price",DOUBLE,{100},FORBID},
{"Delta",DOUBLE,{100},FORBID} ,
{"Error Price",DOUBLE,{100},FORBID},
{"Error Delta",DOUBLE,{100},FORBID} ,
{"Inf Price",DOUBLE,{100},FORBID},
{"Sup Price",DOUBLE,{100},FORBID} ,
{"Inf Delta",DOUBLE,{100},FORBID},
{"Sup Delta",DOUBLE,{100},FORBID} ,
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(MC_Dupire),
CHK_mc,
MET(Init)
};
}
static int CHK_OPT(CF_PutMertonHeston)(void *Opt, void *Mod)
{
return strcmp( ((Option*)Opt)->Name,"PutEuro");
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
}
return OK;
}
PricingMethod MET(CF_PutMertonHeston)=
{
"CF_Put_MerHes",
{{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(CF_PutMertonHeston),
{{"Price",DOUBLE,{100},FORBID},
{"Delta",DOUBLE,{100},FORBID} ,
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(CF_PutMertonHeston),
CHK_ok,
MET(Init)
};
return Euler(ptOpt->EuOrAm.Val.V_BOOL,ptMod->S0.Val.V_PDOUBLE,ptOpt->PayOff.Val.V_NUMFUNC_1,
ptOpt->Maturity.Val.V_DATE-ptMod->T.Val.V_DATE,r,divid,ptMod->Sigma.Val.V_PDOUBLE,
Met->Par[0].Val.V_INT,&(Met->Res[0].Val.V_DOUBLE),&(Met->Res[1].Val.V_DOUBLE));
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->HelpFilenameHint = "tr_euler_bs";
Met->Par[0].Val.V_INT2=100;
}
return OK;
}
PricingMethod MET(TR_Euler)=
{
"TR_Euler",
{{"StepNumber",INT2,{100},ALLOW},{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(TR_Euler),
{{"Price",DOUBLE,{100},FORBID},{"Delta",DOUBLE,{100},FORBID} ,{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(TR_Euler),
CHK_tree,
MET(Init)
};
static int CHK_OPT(AP_Spread_Bjerksund)(void *Opt, void *Mod)
{
return NONACTIVE;
}
int CALC(AP_Spread_Bjerksund)(void*Opt,void *Mod,PricingMethod *Met)
{
return AVAILABLE_IN_FULL_PREMIA;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
}
return OK;
}
PricingMethod MET(AP_Spread_Bjerksund)=
{
"AP_Spread_Bjerksund",
{{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(AP_Spread_Bjerksund),
{{"Price",DOUBLE,{100},FORBID},{"Delta1",DOUBLE,{100},FORBID} ,{"Delta2",DOUBLE,{100},FORBID} ,
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(AP_Spread_Bjerksund),
CHK_ok,
MET(Init)
} ;
if ((strcmp(((Option*)Opt)->Name,"ZeroCouponBond")==0) )
return OK;
else
return WRONG;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->Par[0].Val.V_LONG=50;
}
return OK;
}
PricingMethod MET(TR_ZCBondHW1D)=
{
"TR_HullWhite1d_ZCBond",
{{"TimeStepNumber",LONG,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(TR_ZCBondHW1D),
{{"Price",DOUBLE,{100},FORBID}/*,{"Delta",DOUBLE,{100},FORBID} */,{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(TR_ZCBondHW1D),
CHK_ok,
MET(Init)
} ;
Met->Par[3].Val.V_PDOUBLE=0.0001;
first=0;
}
return OK;
}
PricingMethod MET(MC_MadanYor_CGMY)=
{
"MC_Madan_Yor",
{{"N iterations",LONG,{100},ALLOW},
{"RandomGenerator",ENUM,{100},ALLOW},
{"Confidence Value",DOUBLE,{100},ALLOW},
{"Eps (jumps smaller than eps are truncated)",DOUBLE,{100},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(MC_MadanYor_CGMY),
{{"Price",DOUBLE,{100},FORBID},
{"Delta",DOUBLE,{100},FORBID},
{"Inf Price",DOUBLE,{100},FORBID},
{"Sup Price",DOUBLE,{100},FORBID} ,
{"Inf Delta",DOUBLE,{100},FORBID},
{"Sup Delta",DOUBLE,{100},FORBID},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(MC_MadanYor_CGMY),
CHK_mc,
MET(Init)
} ;
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
static int first=1;
if (first)
{
Met->HelpFilenameHint = "AP_FASTWH_cgmy_LookbackFloating";
Met->Par[0].Val.V_PDOUBLE=1.0;
Met->Par[1].Val.V_PDOUBLE=0.001;
first=0;
}
return OK;
}
PricingMethod MET(AP_WH_FloatingLookback)=
{
"AP_FastWH",
{ {"Scale of logprice range", DOUBLE, {100}, ALLOW},
{"Space Discretization Step",DOUBLE,{500},ALLOW},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(AP_WH_FloatingLookback),
{{"Price",DOUBLE,{100},FORBID},
{"Delta",DOUBLE,{100},FORBID},
{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(AP_WH_FloatingLookback),
CHK_split,
MET(Init)
};
ptOpt->BMaturity.Val.V_DATE-ptMod->T.Val.V_DATE,
&(Met->Res[0].Val.V_DOUBLE));
}
static int CHK_OPT(CF_ZCBondSG1D)(void *Opt, void *Mod)
{
return strcmp( ((Option*)Opt)->Name,"ZeroCouponBond");
}
static int MET(Init)(PricingMethod *Met,Option *Opt)
{
if ( Met->init == 0)
{
Met->init=1;
Met->HelpFilenameHint = "cf_quadratic1d_zcbond";
}
return OK;
}
PricingMethod MET(CF_ZCBondSG1D)=
{
"CF_SquareGaussian1d_ZCBond",
{{" ",PREMIA_NULLTYPE,{0},FORBID}},
CALC(CF_ZCBondSG1D),
{{"Price",DOUBLE,{100},FORBID} ,{" ",PREMIA_NULLTYPE,{0},FORBID}},
CHK_OPT(CF_ZCBondSG1D),
CHK_ok,
MET(Init)
} ;
