wchar_t *
Py_GetExecPrefix(void)
{
if (!module_search_path)
calculate_path();
return exec_prefix;
}
wchar_t *
Py_GetProgramFullPath(void)
{
if (!module_search_path)
calculate_path();
return progpath;
}
char *
Py_GetPrefix(void)
{
if (!module_search_path)
calculate_path();
return prefix;
}
wchar_t *
Py_GetPath(void)
{
if (!module_search_path)
calculate_path();
return module_search_path;
}
// Public methods
void GlobalPlanner::send_next_step(){
get_map_data();
populate_all_nodes();
get_destination();
get_current_location();
calculate_path();
find_next_step();
}
NodePath* Dijkstra::get_path(Node* start, Node* dest) {
/**
* After running the find_paths function, you can here extract the exact way from start to destination.
*/
if (saved_paths.find(NodePair(start, dest)) != saved_paths.end()) {
return create_path_copy(saved_paths[NodePair(start, dest)]);
}
// otherwise calculate a new path
return calculate_path(start, dest);
}
char* FileList::create_path(int number_override)
{
if(asset->format != list_type) return asset->path;
table_lock->lock("FileList::create_path");
char *path = (char*)"";
char output[BCTEXTLEN];
if(file->current_frame >= path_list.total || !asset->use_header)
{
int number;
if(number_override < 0)
number = file->current_frame++;
else
{
number = number_override;
file->current_frame++;
}
if(!asset->use_header)
{
number += first_number;
}
calculate_path(number, output);
path = new char[strlen(output) + 1];
strcpy(path, output);
path_list.append(path);
}
else
{
// Overwrite an old path
path = path_list.values[file->current_frame];
}
table_lock->unlock();
return path;
}
int FileList::read_frame(VFrame *frame)
{
int result = 0;
// PRINT_TRACE
// printf("FileList::read_frame %d %d use_header=%d current_frame=%d total=%d\n",
// __LINE__,
// result,
// asset->use_header,
// file->current_frame,
// path_list.total);
if(file->current_frame < 0 ||
(asset->use_header && file->current_frame >= path_list.total &&
asset->format == list_type))
return 1;
if(asset->format == list_type)
{
char string[BCTEXTLEN];
char *path;
if(asset->use_header)
{
path = path_list.values[file->current_frame];
}
else
{
path = calculate_path(file->current_frame, string);
}
FILE *in;
// Fix path for VFS
if(!strncmp(asset->path, RENDERFARM_FS_PREFIX, strlen(RENDERFARM_FS_PREFIX)))
sprintf(string, "%s%s", RENDERFARM_FS_PREFIX, path);
else
strcpy(string, path);
if(!use_path() || frame->get_color_model() == BC_COMPRESSED)
{
if(!(in = fopen(string, "rb")))
{
eprintf("Error while opening \"%s\" for reading. \n%m\n", string);
}
else
{
struct stat ostat;
stat(string, &ostat);
switch(frame->get_color_model())
{
case BC_COMPRESSED:
frame->allocate_compressed_data(ostat.st_size);
frame->set_compressed_size(ostat.st_size);
(void)fread(frame->get_data(), ostat.st_size, 1, in);
break;
default:
data->allocate_compressed_data(ostat.st_size);
data->set_compressed_size(ostat.st_size);
(void)fread(data->get_data(), ostat.st_size, 1, in);
result = read_frame(frame, data);
break;
}
fclose(in);
}
}
else
{
//printf("FileList::read_frame %d %s\n", __LINE__, string);
result = read_frame(frame, string);
}
}
else
{
// Allocate and decompress single frame into new temporary
//printf("FileList::read_frame %d\n", frame->get_color_model());
if(!temp || temp->get_color_model() != frame->get_color_model())
{
if(temp) delete temp;
temp = 0;
if(!use_path() || frame->get_color_model() == BC_COMPRESSED)
{
FILE *fd = fopen(asset->path, "rb");
if(fd)
{
struct stat ostat;
stat(asset->path, &ostat);
switch(frame->get_color_model())
{
case BC_COMPRESSED:
frame->allocate_compressed_data(ostat.st_size);
frame->set_compressed_size(ostat.st_size);
(void)fread(frame->get_data(), ostat.st_size, 1, fd);
break;
default:
data->allocate_compressed_data(ostat.st_size);
data->set_compressed_size(ostat.st_size);
(void)fread(data->get_data(), ostat.st_size, 1, fd);
temp = new VFrame(0,
-1,
asset->width,
asset->height,
frame->get_color_model(),
-1);
read_frame(temp, data);
break;
}
fclose(fd);
}
else
{
eprintf("Error while opening \"%s\" for reading. \n%m\n", asset->path);
result = 1;
}
}
else
{
temp = new VFrame(0,
-1,
asset->width,
asset->height,
frame->get_color_model(),
-1);
read_frame(temp, asset->path);
}
}
if(!temp) return result;
// printf("FileList::read_frame frame=%d temp=%d\n",
// frame->get_color_model(),
// temp->get_color_model());
if(frame->get_color_model() == temp->get_color_model())
{
frame->copy_from(temp);
}
else
{
// Never happens
BC_CModels::transfer(frame->get_rows(), /* Leave NULL if non existent */
temp->get_rows(),
frame->get_y(), /* Leave NULL if non existent */
frame->get_u(),
frame->get_v(),
temp->get_y(), /* Leave NULL if non existent */
temp->get_u(),
temp->get_v(),
0, /* Dimensions to capture from input frame */
0,
asset->width,
asset->height,
0, /* Dimensions to project on output frame */
0,
asset->width,
asset->height,
temp->get_color_model(),
frame->get_color_model(),
0, /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
temp->get_w(), /* For planar use the luma rowspan */
frame->get_w());
}
}
// printf("FileList::read_frame %d %d\n", __LINE__, result);
//
// if(frame->get_y())
// for(int i = 0; i < 100000; i++)
// {
// frame->get_y()[i] = 0xff;
// }
// if(frame->get_rows())
// for(int i = 0; i < 100000; i++)
// {
// frame->get_rows()[0][i] = 0xff;
// }
return result;
}
int
route_calculate(struct ccn_schedule *sched, void *clienth, struct ccn_scheduled_event *ev, int flags)
{
if(flags == CCN_SCHEDULE_CANCEL)
{
return -1;
}
nlsr_lock();
if ( nlsr->debugging )
printf("route_calculate called\n");
if ( nlsr->detailed_logging )
writeLogg(__FILE__,__FUNCTION__,__LINE__,"route_calculate called\n");
if( ! nlsr->is_build_adj_lsa_sheduled )
{
/* Calculate Route here */
print_routing_table();
print_npt();
//struct hashtb_param param_me = {0};
nlsr->map = hashtb_create(sizeof(struct map_entry), NULL);
nlsr->rev_map = hashtb_create(sizeof(struct map_entry), NULL);
make_map();
assign_mapping_number();
print_map();
print_rev_map();
do_old_routing_table_updates();
clear_old_routing_table();
print_routing_table();
print_npt();
int i;
int **adj_matrix;
int map_element=hashtb_n(nlsr->map);
adj_matrix=malloc(map_element * sizeof(int *));
for(i = 0; i < map_element; i++)
{
adj_matrix[i] = malloc(map_element * sizeof(int));
}
make_adj_matrix(adj_matrix,map_element);
if ( nlsr->debugging )
print_adj_matrix(adj_matrix,map_element);
long int source=get_mapping_no(nlsr->router_name);
int num_link=get_no_link_from_adj_matrix(adj_matrix, map_element ,source);
if ( nlsr->is_hyperbolic_calc == 1)
{
long int *links=(long int *)malloc(num_link*sizeof(long int));
long int *link_costs=(long int *)malloc(num_link*sizeof(long int));
get_links_from_adj_matrix(adj_matrix, map_element , links, link_costs, source);
struct hashtb_enumerator ee;
struct hashtb_enumerator *e = ⅇ
for (hashtb_start(nlsr->rev_map, e); e->key != NULL; hashtb_next(e))
{
struct map_entry *me=e->data;
if ( me->mapping != source )
{
long int *faces=(long int *)calloc(num_link,sizeof(long int));
double *nbr_dist=(double *)calloc(num_link,sizeof(double));
double *nbr_to_dest=(double *)calloc(num_link,sizeof(double));
for ( i=0 ; i < num_link; i++)
{
int face=get_next_hop_face_from_adl(get_router_from_rev_map(links[i]));
double dist_to_nbr=get_hyperbolic_distance(source,links[i]);
double dist_to_dest_from_nbr=get_hyperbolic_distance(links[i],me->mapping);
faces[i]=face;
nbr_dist[i]=dist_to_nbr;
nbr_to_dest[i]= dist_to_dest_from_nbr;
}
sort_hyperbolic_route(nbr_to_dest,nbr_dist, faces,0,num_link);
if (nlsr->max_faces_per_prefix == 0 )
{
for ( i=0 ; i < num_link; i++)
{
update_routing_table_with_new_hyperbolic_route(me->mapping,faces[i],nbr_to_dest[i]);
}
}
else if ( nlsr->max_faces_per_prefix > 0 )
{
if ( num_link <= nlsr->max_faces_per_prefix )
{
for ( i=0 ; i < num_link; i++)
{
update_routing_table_with_new_hyperbolic_route(me->mapping,faces[i],nbr_to_dest[i]);
}
}
else if (num_link > nlsr->max_faces_per_prefix)
{
for ( i=0 ; i < nlsr->max_faces_per_prefix; i++)
{
update_routing_table_with_new_hyperbolic_route(me->mapping,faces[i],nbr_to_dest[i]);
}
}
}
free(faces);
free(nbr_dist);
free(nbr_to_dest);
}
}
hashtb_end(e);
free(links);
free(link_costs);
}
else if (nlsr->is_hyperbolic_calc == 0 )
{
long int *parent=(long int *)malloc(map_element * sizeof(long int));
long int *dist=(long int *)malloc(map_element * sizeof(long int));
if ( (num_link == 0) || (nlsr->max_faces_per_prefix == 1 ) )
{
calculate_path(adj_matrix,parent,dist, map_element, source);
print_all_path_from_source(parent,source);
print_all_next_hop(parent,source);
update_routing_table_with_new_route(parent, dist,source);
}
else if ( (num_link != 0) && (nlsr->max_faces_per_prefix == 0 || nlsr->max_faces_per_prefix > 1 ) )
{
long int *links=(long int *)malloc(num_link*sizeof(long int));
long int *link_costs=(long int *)malloc(num_link*sizeof(long int));
get_links_from_adj_matrix(adj_matrix, map_element , links, link_costs, source);
for ( i=0 ; i < num_link; i++)
{
adjust_adj_matrix(adj_matrix, map_element,source,links[i],link_costs[i]);
calculate_path(adj_matrix,parent,dist, map_element, source);
print_all_path_from_source(parent,source);
print_all_next_hop(parent,source);
update_routing_table_with_new_route(parent, dist,source);
}
free(links);
free(link_costs);
}
free(parent);
free(dist);
}
print_routing_table();
print_npt();
update_npt_with_new_route();
print_routing_table();
print_npt();
for(i = 0; i < map_element; i++)
{
free(adj_matrix[i]);
}
free(adj_matrix);
destroy_map();
destroy_rev_map();
//hashtb_destroy(&nlsr->map);
//hashtb_destroy(&nlsr->rev_map);
}
nlsr->is_route_calculation_scheduled=0;
nlsr_unlock();
return 0;
}
/**
* Computes garch price for GARCH model
* @param[in] today_price taday price
* @param[in] alpha_zero garch parameter
* @param[in] alpha_one garch parameter
* @param[in] lambda the constant unit risk premium
* @param[in] beta_one garch parameter
* @param[in] interest the annulized interest
* @param[in] K exercise price
* @param[in] frequency frequency
* @param[in] T time to mutrity
* @param[in] choice emscorrection(ems_on or ems_off)
* @param[in] type_generator the type of generator for random number
* @param[out] garch option price
* garch->call obtains call option price
* garch->put obtains put option price
* @return OK if ok otherwise return FAIL
*/
static int garch_price(NumFunc_1 *p,double today_price,double alpha_zero,double alpha_one,double beta_one,double lambda,double interest,int frequency,double K,int T,int N,int choice,int type_generator,double *price,double *delta)
{
double sum_callorput;
double sum_delta;
double s_T;
double garch_delta;
int i;
PnlMat *path_ems, *path, *path1D;
PnlVect *h;
path=pnl_mat_create(T,N);
h=pnl_vect_create (1);
sum_callorput=0;
sum_delta=0;
pnl_vect_set(h,0,today_price);
if (calculate_path(h,path,interest,frequency,N,T,alpha_zero,alpha_one,lambda,beta_one,type_generator)==FAIL)
{
pnl_vect_free(&h);
pnl_mat_free(&path);
return FAIL;
}
//if we choose ems option
switch (choice)
{
case 1:
pnl_vect_free(&h);
pnl_rand_init(type_generator,N,T);
path_ems=pnl_mat_create(T,N);
if(ems(path,interest,frequency,path_ems)==FAIL)
{
pnl_mat_free(&path);
pnl_mat_free(&path_ems);
return FAIL;
}
pnl_mat_clone(path, path_ems);
for(i=0;i<N;i++)
{
s_T=pnl_mat_get(path,T-1,i);
sum_callorput=sum_callorput+(p->Compute)(p->Par,pnl_mat_get(path,T-1,i));
if(s_T>K) garch_delta=1.;
sum_delta=sum_delta+(s_T/today_price)*garch_delta;
}
pnl_mat_free(&path_ems);
break;
case 2:
path1D=pnl_mat_create(T,1);
pnl_rand_init(type_generator,1,T);
for(i=0;i<N;i++)
{
calculate_path(h,path1D,interest,frequency,1,T,alpha_zero,alpha_one,lambda,beta_one,type_generator);
s_T=pnl_mat_get(path1D,T-1,0);
sum_callorput=sum_callorput+(p->Compute)(p->Par,pnl_mat_get(path,T-1,i));
if(s_T>K) garch_delta=1.;
sum_delta=sum_delta+(s_T/today_price)*garch_delta;
}
pnl_vect_free(&h);
pnl_mat_free(&path1D);
break;
default:
printf ("Wrong value for parameter EMS\n");
return FAIL;
}
interest=(interest*frequency)/252.;
//Price
*price=sum_callorput/(N*pow(M_E,(interest*T)));
*delta=sum_delta/(N*pow(M_E,(T*interest)));
if ((p->Compute)==&Put) *delta=*delta-1;
pnl_mat_free(&path);
return OK ;
}
static void
calculate_path(void)
{
extern char *Py_GetProgramName(void);
static char delimiter[2] = {DELIM, '\0'};
static char separator[2] = {SEP, '\0'};
char *pythonpath = PYTHONPATH;
char *rtpypath = Py_GETENV("PYTHONPATH");
char *home = Py_GetPythonHome();
#ifndef _AMIGA
char *path = getenv("PATH");
char *prog = Py_GetProgramName();
#endif
char argv0_path[MAXPATHLEN+1];
char zip_path[MAXPATHLEN+1];
int pfound, efound; /* 1 if found; -1 if found build directory */
char *buf;
size_t bufsz;
size_t prefixsz;
char *defpath = pythonpath;
#ifdef WITH_NEXT_FRAMEWORK
NSModule pythonModule;
#endif
#ifdef _AMIGA
strcpy(progpath,fullprogpath());
#else /* !_AMIGA */
/* If there is no slash in the argv0 path, then we have to
* assume python is on the user's $PATH, since there's no
* other way to find a directory to start the search from. If
* $PATH isn't exported, you lose.
*/
if (strchr(prog, SEP))
strncpy(progpath, prog, MAXPATHLEN);
else if (path) {
while (1) {
char *delim = strchr(path, DELIM);
if (delim) {
size_t len = delim - path;
if (len > MAXPATHLEN)
len = MAXPATHLEN;
strncpy(progpath, path, len);
*(progpath + len) = '\0';
}
else
strncpy(progpath, path, MAXPATHLEN);
joinpath(progpath, prog);
if (isxfile(progpath))
break;
if (!delim) {
progpath[0] = '\0';
break;
}
path = delim + 1;
}
}
else
progpath[0] = '\0';
if (progpath[0] != SEP)
absolutize(progpath);
strncpy(argv0_path, progpath, MAXPATHLEN);
argv0_path[MAXPATHLEN] = '\0';
#ifdef WITH_NEXT_FRAMEWORK
/* On Mac OS X we have a special case if we're running from a framework.
** This is because the python home should be set relative to the library,
** which is in the framework, not relative to the executable, which may
** be outside of the framework. Except when we're in the build directory...
*/
pythonModule = NSModuleForSymbol(NSLookupAndBindSymbol("_Py_Initialize"));
/* Use dylib functions to find out where the framework was loaded from */
buf = (char *)NSLibraryNameForModule(pythonModule);
if (buf != NULL) {
/* We're in a framework. */
/* See if we might be in the build directory. The framework in the
** build directory is incomplete, it only has the .dylib and a few
** needed symlinks, it doesn't have the Lib directories and such.
** If we're running with the framework from the build directory we must
** be running the interpreter in the build directory, so we use the
** build-directory-specific logic to find Lib and such.
*/
strncpy(argv0_path, buf, MAXPATHLEN);
reduce(argv0_path);
joinpath(argv0_path, lib_python);
joinpath(argv0_path, LANDMARK);
#endif /* !_AMIGA */
if (!ismodule(argv0_path)) {
/* We are in the build directory so use the name of the
executable - we know that the absolute path is passed */
strncpy(argv0_path, prog, MAXPATHLEN);
}
else {
/* Use the location of the library as the progpath */
strncpy(argv0_path, buf, MAXPATHLEN);
}
}
#endif
#if HAVE_READLINK
{
char tmpbuffer[MAXPATHLEN+1];
int linklen = readlink(progpath, tmpbuffer, MAXPATHLEN);
while (linklen != -1) {
/* It's not null terminated! */
tmpbuffer[linklen] = '\0';
#ifdef _AMIGA
if (NULL==strchr(tmpbuffer,':'))
#else
if (tmpbuffer[0] == SEP)
#endif
/* tmpbuffer should never be longer than MAXPATHLEN,
but extra check does not hurt */
strncpy(argv0_path, tmpbuffer, MAXPATHLEN);
else {
/* Interpret relative to progpath */
reduce(argv0_path);
joinpath(argv0_path, tmpbuffer);
}
linklen = readlink(argv0_path, tmpbuffer, MAXPATHLEN);
}
}
#endif /* HAVE_READLINK */
reduce(argv0_path);
/* At this point, argv0_path is guaranteed to be less than
MAXPATHLEN bytes long.
*/
if (!(pfound = search_for_prefix(argv0_path, home))) {
if (!Py_FrozenFlag)
fprintf(stderr,
"Could not find platform independent libraries <prefix>\n");
strncpy(prefix, PREFIX, MAXPATHLEN);
joinpath(prefix, lib_python);
}
else
reduce(prefix);
strncpy(zip_path, prefix, MAXPATHLEN);
zip_path[MAXPATHLEN] = '\0';
if (pfound > 0) { /* Use the reduced prefix returned by Py_GetPrefix() */
reduce(zip_path);
reduce(zip_path);
}
else
strncpy(zip_path, PREFIX, MAXPATHLEN);
joinpath(zip_path, "lib/python00.zip");
bufsz = strlen(zip_path); /* Replace "00" with version */
zip_path[bufsz - 6] = VERSION[0];
zip_path[bufsz - 5] = VERSION[2];
if (!(efound = search_for_exec_prefix(argv0_path, home))) {
if (!Py_FrozenFlag)
fprintf(stderr,
"Could not find platform dependent libraries <exec_prefix>\n");
strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);
joinpath(exec_prefix, "lib/lib-dynload");
}
/* If we found EXEC_PREFIX do *not* reduce it! (Yet.) */
if ((!pfound || !efound) && !Py_FrozenFlag)
fprintf(stderr,
"Consider setting $PYTHONHOME to <prefix>[:<exec_prefix>]\n");
/* Calculate size of return buffer.
*/
bufsz = 0;
if (rtpypath)
bufsz += strlen(rtpypath) + 1;
prefixsz = strlen(prefix) + 1;
while (1) {
char *delim = strchr(defpath, DELIM);
#ifdef _AMIGA
if (NULL==strchr(defpath,':'))
#else
if (defpath[0] != SEP)
#endif
/* Paths are relative to prefix */
bufsz += prefixsz;
if (delim)
bufsz += delim - defpath + 1;
else {
bufsz += strlen(defpath) + 1;
break;
}
defpath = delim + 1;
}
bufsz += strlen(zip_path) + 1;
bufsz += strlen(exec_prefix) + 1;
/* This is the only malloc call in this file */
buf = PyMem_Malloc(bufsz);
if (buf == NULL) {
/* We can't exit, so print a warning and limp along */
fprintf(stderr, "Not enough memory for dynamic PYTHONPATH.\n");
fprintf(stderr, "Using default static PYTHONPATH.\n");
module_search_path = PYTHONPATH;
}
else {
/* Run-time value of $PYTHONPATH goes first */
if (rtpypath) {
strcpy(buf, rtpypath);
strcat(buf, delimiter);
}
else
buf[0] = '\0';
/* Next is the default zip path */
strcat(buf, zip_path);
strcat(buf, delimiter);
/* Next goes merge of compile-time $PYTHONPATH with
* dynamically located prefix.
*/
defpath = pythonpath;
while (1) {
char *delim = strchr(defpath, DELIM);
#ifdef _AMIGA
if (NULL==strchr(defpath,':')) {
#else
if (defpath[0] != SEP) {
#endif
strcat(buf, prefix);
strcat(buf, separator);
}
if (delim) {
size_t len = delim - defpath + 1;
size_t end = strlen(buf) + len;
strncat(buf, defpath, len);
*(buf + end) = '\0';
}
else {
strcat(buf, defpath);
break;
}
defpath = delim + 1;
}
strcat(buf, delimiter);
/* Finally, on goes the directory for dynamic-load modules */
strcat(buf, exec_prefix);
/* And publish the results */
module_search_path = buf;
}
/* Reduce prefix and exec_prefix to their essence,
* e.g. /usr/local/lib/python1.5 is reduced to /usr/local.
* If we're loading relative to the build directory,
* return the compiled-in defaults instead.
*/
if (pfound > 0) {
reduce(prefix);
reduce(prefix);
}
else
strncpy(prefix, PREFIX, MAXPATHLEN);
if (efound > 0) {
reduce(exec_prefix);
reduce(exec_prefix);
reduce(exec_prefix);
}
else
strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);
}
/* External interface */
char *
Py_GetPath(void)
{
if (!module_search_path)
calculate_path();
return module_search_path;
}
char *
Py_GetPrefix(void)
{
if (!module_search_path)
calculate_path();
return prefix;
}
char *
Py_GetExecPrefix(void)
{
if (!module_search_path)
calculate_path();
return exec_prefix;
}
char *
Py_GetProgramFullPath(void)
{
if (!module_search_path)
calculate_path();
return progpath;
}
