t_map load_map(t_meta *meta, char *name)
{
int fd;
int i;
int ret;
UCHAR *line;
t_map map;
fd = xopen(name, O_RDONLY, meta);
map.data = xmemalloc(sizeof(UCHAR*) * 3000, meta);
i = 0;
map.width = -1;
while ((ret = get_next_line(fd, (char**)&line)) > 0)
{
map.data[i] = analyse_data(line, meta, name);
if (++i >= 3000)
error_file(meta, name);
if (map.width == -1)
map.width = ret;
else if (ret != map.width)
error_file(meta, name);
}
close(fd);
map.height = i;
if (ret < 0 || map.height == 0 || map.width == 0)
error_file(meta, name);
return (map);
}
t_raw read_file(int fd)
{
char *text;
t_raw raw;
int er;
int len;
int size;
len = 0;
size = 100000;
raw.lines = xmalloc(size * sizeof(t_rawline*));
raw.width = 0;
while ((er = get_next_line(fd, &text)) > 0)
{
raw.lines[len].data = ft_strsplit(text, ' ');
if (!raw.lines[len].data)
error_memory();
raw.lines[len].len = ft_tablen(raw.lines[len].data);
raw.width = MAX(raw.width, raw.lines[len].len);
if (++len == size)
error_file();
free(text);
}
if (er < 0)
error_file();
raw.height = len;
return (raw);
}
int my_file_fd(char *path, int (*f)(char *), int flag)
{
int fd;
char *print;
char *tmp;
if ((fd = open(path, O_DIRECTORY, S_IRUSR)) > 0)
return (error_file(fd, my_strncat(path, " is a folder", 12), f));
if ((fd = open(path, flag, S_IWUSR)) > 0)
return (fd);
tmp = my_strncat("can't access to ", path, my_strlen(path));
if (errno == EACCES)
print = my_strncat(tmp, " permission denied", 18);
else if (errno == ENOENT)
print = my_strncat(tmp, " file not found", 15);
else if (errno == ENAMETOOLONG)
print = my_strncat(tmp, " too long pathname", 18);
else
print = tmp;
if (print != tmp)
free(tmp);
(*f)(print);
free(print);
return (-1);
}
int force_file_fd(char *path, int (*f)(char *))
{
int fd;
char *print;
char *tmp;
if ((fd = open(path, O_DIRECTORY, S_IRUSR)) > 0)
return (error_file(fd, my_strncat(path, " is a folder", 12), f));
if ((fd = open(path, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) > 0)
return (fd);
tmp = my_strncat("can't access to ", path, my_strlen(path));
if (errno == EACCES)
print = my_strncat(tmp, ": permission denied", 19);
else if (errno == ENOENT)
print = my_strncat(tmp, ": file not found", 16);
else if (errno == ENAMETOOLONG)
print = my_strncat(tmp, ": too long pathname", 19);
else
print = tmp;
if (print != tmp)
free(tmp);
(*f)(print);
free(print);
return (-1);
}
TestReportFrame::TestReportFrame(wxFrame *inParent,
TestRunReport::ptr inReport)
: wxFrame(inParent, -1, wxT("Test Results"))
{
mOutput = new wxTextCtrl(this, -1, wxT(""), wxDefaultPosition,
wxDefaultSize,
wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH);
wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
sizer->Add(mOutput, 1 /* stretch */, wxGROW, 0);
SetSizer(sizer);
sizer->SetSizeHints(this);
SetClientSize(640, 240);
mOutput->AppendText(wxString(inReport->GetSummary().c_str(), wxConvLocal));
mOutput->AppendText(wxT("\n"));
TestRunReport::iterator i = inReport->begin();
for (; i != inReport->end(); ++i) {
if ((*i)->GetTestResult() == TEST_FAILED) {
wxString str;
wxString error_file( (*i)->GetErrorFile().c_str(), wxConvLocal);
wxString name( (*i)->GetName().c_str(), wxConvLocal);
wxString message( (*i)->GetErrorMessage().c_str(), wxConvLocal);
str.Printf(wxT("%s:%d: %s: %s\n"),
error_file.c_str(),
(*i)->GetErrorLine(),
name.c_str(),
message.c_str());
mOutput->AppendText(str);
}
}
}
static int load_rom_gfx1(void)
{
int i, res;
char fname[32], *parent;
if ((memory_region_gfx1 = memalign(MEM_ALIGN, memory_length_gfx1)) == NULL)
{
error_memory("REGION_GFX1");
return 0;
}
memset(memory_region_gfx1, 0, memory_length_gfx1);
parent = strlen(parent_name) ? parent_name : NULL;
for (i = 0; i < num_gfx1rom; )
{
strcpy(fname, gfx1rom[i].name);
if ((res = file_open(game_name, parent, gfx1rom[i].crc, fname)) < 0)
{
if (res == -2)
error_crc(fname);
else
error_file(fname);
return 0;
}
msg_printf(TEXT(LOADING), fname);
i = rom_load(gfx1rom, memory_region_gfx1, i, num_gfx1rom);
file_close();
}
return 1;
}
int verif_pos(t_wolf *wolf)
{
t_f_point *pos;
int x;
int y;
x = 0;
while (x < wolf->size_line_map)
{
y = 0;
while (y < wolf->size_map - 1)
{
if (!is_wall(x, y, wolf, 1))
{
wolf->play->pos_player->x = x + 0.5;
wolf->play->pos_player->y = y + 0.5;
return (0);
}
y++;
}
x++;
}
error_file();
return (1);
}
UCHAR *analyse_data(UCHAR *data, t_meta *meta, char *name)
{
int i;
i = 0;
while (data[i])
{
if (data[i] == ' ')
data[i] = (0);
else if (data[i] >= '0' && data[i] <= '9')
data[i] = data[i] - '0' + 1;
else if (data[i] >= 'A' && data[i] <= 'Z')
data[i] = data[i] - 'A' + PORTAL_1;
else
error_file(meta, name);
i++;
}
return (data);
}
void IOManager<B,F>::writeSequenceData(unsigned sequence, string filename, unsigned fract)
{
filename = path + filename;
cout << "writing sequence data to " << filename << "..." << endl;
fstream real_signal_file((filename+"_real").c_str(), ios::out);
fstream imag_signal_file((filename+"_imag").c_str(), ios::out);
fstream error_file((filename + "_error").c_str(), ios::out);
const Matrix2D &real_signal = evaluator.getRealSignal();
const Matrix2D &imag_signal = evaluator.getImagSignal();
const Matrix2D &error = evaluator.getError();
real_signal_file << real_signal;
imag_signal_file << imag_signal;
error_file << error;
real_signal_file.close();
imag_signal_file.close();
error_file.close();
}
void my_dir_soi(t_cmds *cmds)
{
int fdi;
pid_t father;
cmds->done = 1;
fdi = open(cmds->str, O_RDONLY);
if (fdi == -1)
error_file(cmds->str);
else
{
father = fork();
if (father > 0)
{
wait(0);
close(fdi);
}
if (father == 0)
make_soi(cmds, fdi);
}
}
MDX_DATA *mdx_open_mdx( char *name ) {
int i,j;
int ptr;
unsigned char *buf;
MDX_DATA *mdx;
/* allocate work area */
mdx = __alloc_mdxwork();
if ( mdx == NULL ) return NULL;
/* data read */
if (!__load_file(mdx, name)) {
goto error_end;
}
/* title parsing */
for ( i=0 ; i<MDX_MAX_TITLE_LENGTH ; i++ ) {
mdx->data_title[i] = '\0';
}
i=0;
ptr=0;
buf = mdx->data;
mdx->data_title[i]=0;
if (mdx->length<3) {
goto error_end;
}
while(1) {
if ( buf[ptr+0] == 0x0d &&
buf[ptr+1] == 0x0a &&
buf[ptr+2] == 0x1a ) break;
mdx->data_title[i++]=buf[ptr++]; /* warning! this text is SJIS */
if ( i>=MDX_MAX_TITLE_LENGTH ) i--;
if ( ptr > mdx->length ) error_file();
}
mdx->data_title[i++]=0;
/* pdx name */
ptr+=3;
for ( i=0 ; i<MDX_MAX_PDX_FILENAME_LENGTH ; i++ ) {
mdx->pdx_name[i]='\0';
}
i=0;
j=0;
mdx->haspdx=FLAG_FALSE;
while(1) {
if ( buf[ptr] == 0x00 ) break;
mdx->haspdx=FLAG_TRUE;
mdx->pdx_name[i++] = buf[ptr++];
if ( strcasecmp( ".pdx", (char *)(buf+ptr-1) )==0 ) j=1;
if ( i>= MDX_MAX_PDX_FILENAME_LENGTH ) i--;
if ( ptr > mdx->length ) error_file();
}
if ( mdx->haspdx==FLAG_TRUE && j==0 ) {
mdx->pdx_name[i+0] = '.';
mdx->pdx_name[i+1] = 'p';
mdx->pdx_name[i+2] = 'd';
mdx->pdx_name[i+3] = 'x';
}
/* get voice data offset */
ptr++;
mdx->base_pointer = ptr;
mdx->voice_data_offset =
(unsigned int)buf[ptr+0]*256 +
(unsigned int)buf[ptr+1] + mdx->base_pointer;
if ( mdx->voice_data_offset > mdx->length ) error_file();
/* get MML data offset */
mdx->mml_data_offset[0] =
(unsigned int)buf[ptr+2+0] * 256 +
(unsigned int)buf[ptr+2+1] + mdx->base_pointer;
if ( mdx->mml_data_offset[0] > mdx->length ) error_file();
if ( buf[mdx->mml_data_offset[0]] == MDX_SET_PCM8_MODE ) {
mdx->ispcm8mode = 1;
mdx->tracks = 16;
} else {
mdx->ispcm8mode = 0;
mdx->tracks = 9;
}
for ( i=0 ; i<mdx->tracks ; i++ ) {
mdx->mml_data_offset[i] =
(unsigned int)buf[ptr+i*2+2+0] * 256 +
(unsigned int)buf[ptr+i*2+2+1] + mdx->base_pointer;
if ( mdx->mml_data_offset[i] > mdx->length ) error_file();
}
/* init. configuration */
mdx->is_use_pcm8 = FLAG_TRUE;
mdx->is_use_fm = FLAG_TRUE;
mdx->is_use_opl3 = FLAG_TRUE;
i = strlen(MDX_VERSION_TEXT1);
if ( i > MDX_VERSION_TEXT_SIZE ) i=MDX_VERSION_TEXT_SIZE;
strncpy( (char *)mdx->version_1, MDX_VERSION_TEXT1, i );
i = strlen(MDX_VERSION_TEXT2);
if ( i > MDX_VERSION_TEXT_SIZE ) i=MDX_VERSION_TEXT_SIZE;
strncpy( (char *)mdx->version_2, MDX_VERSION_TEXT2, i );
return mdx;
error_end:
if (mdx) {
if (mdx->data) {
free(mdx->data);
mdx->data = NULL;
}
free(mdx);
}
return NULL;
}
Py::Object pysvn_client::cmd_diff_peg( const Py::Tuple &a_args, const Py::Dict &a_kws )
{
static argument_description args_desc[] =
{
{ true, name_tmp_path },
{ true, name_url_or_path },
{ false, name_peg_revision },
{ false, name_revision_start },
{ false, name_revision_end },
{ false, name_recurse },
{ false, name_ignore_ancestry },
{ false, name_diff_deleted },
#if defined( PYSVN_HAS_CLIENT_DIFF_PEG2 )
{ false, name_ignore_content_type },
#endif
#if defined( PYSVN_HAS_CLIENT_DIFF_PEG3 )
{ false, name_header_encoding },
{ false, name_diff_options },
#endif
#if defined( PYSVN_HAS_CLIENT_DIFF_PEG4 )
{ false, name_depth },
{ false, name_relative_to_dir },
{ false, name_changelists },
#endif
{ false, NULL }
};
FunctionArguments args( "diff_peg", args_desc, a_args, a_kws );
args.check();
std::string tmp_path( args.getUtf8String( name_tmp_path ) );
std::string path( args.getUtf8String( name_url_or_path ) );
svn_opt_revision_t revision_start = args.getRevision( name_revision_start, svn_opt_revision_base );
svn_opt_revision_t revision_end = args.getRevision( name_revision_end, svn_opt_revision_working );
svn_opt_revision_t peg_revision = args.getRevision( name_peg_revision, revision_end );
SvnPool pool( m_context );
#if defined( PYSVN_HAS_CLIENT_DIFF_PEG4 )
svn_depth_t depth = args.getDepth( name_depth, name_recurse, svn_depth_infinity, svn_depth_infinity, svn_depth_files );
std::string std_relative_to_dir;
const char *relative_to_dir = NULL;
if( args.hasArg( name_relative_to_dir ) )
{
std_relative_to_dir = args.getBytes( name_relative_to_dir );
relative_to_dir = std_relative_to_dir.c_str();
}
apr_array_header_t *changelists = NULL;
if( args.hasArg( name_changelists ) )
{
changelists = arrayOfStringsFromListOfStrings( args.getArg( name_changelists ), pool );
}
#else
bool recurse = args.getBoolean( name_recurse, true );
#endif
bool ignore_ancestry = args.getBoolean( name_ignore_ancestry, true );
bool diff_deleted = args.getBoolean( name_diff_deleted, true );
#if defined( PYSVN_HAS_CLIENT_DIFF_PEG2 )
bool ignore_content_type = args.getBoolean( name_ignore_content_type, false );
#endif
#if defined( PYSVN_HAS_CLIENT_DIFF_PEG3 )
std::string header_encoding( args.getUtf8String( name_header_encoding, empty_string ) );
const char *header_encoding_ptr = APR_LOCALE_CHARSET;
if( !header_encoding.empty() )
header_encoding_ptr = header_encoding.c_str();
apr_array_header_t *options = NULL;
if( args.hasArg( name_diff_options ) )
{
options = arrayOfStringsFromListOfStrings( args.getArg( name_diff_options ), pool );
}
else
{
options = apr_array_make( pool, 0, sizeof( const char * ) );
}
#else
apr_array_header_t *options = apr_array_make( pool, 0, sizeof( const char * ) );
#endif
bool is_url = is_svn_url( path );
revisionKindCompatibleCheck( is_url, peg_revision, name_peg_revision, name_url_or_path );
revisionKindCompatibleCheck( is_url, revision_start, name_revision_start, name_url_or_path );
revisionKindCompatibleCheck( is_url, revision_end, name_revision_end, name_url_or_path );
svn_stringbuf_t *stringbuf = NULL;
try
{
std::string norm_tmp_path( svnNormalisedIfPath( tmp_path, pool ) );
std::string norm_path( svnNormalisedIfPath( path, pool ) );
checkThreadPermission();
PythonAllowThreads permission( m_context );
pysvn_apr_file output_file( pool );
pysvn_apr_file error_file( pool );
output_file.open_unique_file( norm_tmp_path );
error_file.open_unique_file( norm_tmp_path );
// std::cout << "peg_revision " << peg_revision.kind << " " << peg_revision.value.number << std::endl;
// std::cout << "revision_start " << revision_start.kind << " " << revision_start.value.number << std::endl;
// std::cout << "revision_end " << revision_end.kind << " " << revision_end.value.number << std::endl;
#if defined( PYSVN_HAS_CLIENT_DIFF_PEG4 )
svn_error_t *error = svn_client_diff_peg4
(
options,
norm_path.c_str(),
&peg_revision,
&revision_start,
&revision_end,
relative_to_dir,
depth,
ignore_ancestry,
!diff_deleted,
ignore_content_type,
header_encoding_ptr,
output_file.file(),
error_file.file(),
changelists,
m_context,
pool
);
#elif defined( PYSVN_HAS_CLIENT_DIFF_PEG3 )
svn_error_t *error = svn_client_diff_peg3
(
options,
norm_path.c_str(),
&peg_revision,
&revision_start,
&revision_end,
recurse,
ignore_ancestry,
!diff_deleted,
ignore_content_type,
header_encoding_ptr,
output_file.file(),
error_file.file(),
m_context,
pool
);
#elif defined( PYSVN_HAS_CLIENT_DIFF_PEG2 )
svn_error_t *error = svn_client_diff_peg2
(
options,
norm_path.c_str(),
&peg_revision,
&revision_start,
&revision_end,
recurse,
ignore_ancestry,
!diff_deleted,
ignore_content_type,
output_file.file(),
error_file.file(),
m_context,
pool
);
#else
svn_error_t *error = svn_client_diff_peg
(
options,
norm_path.c_str(),
&peg_revision,
&revision_start,
&revision_end,
recurse,
ignore_ancestry,
!diff_deleted,
output_file.file(),
error_file.file(),
m_context,
pool
);
#endif
permission.allowThisThread();
if( error != NULL )
throw SvnException( error );
output_file.close();
output_file.open_tmp_file();
error = svn_stringbuf_from_aprfile( &stringbuf, output_file.file(), pool );
if( error != NULL )
throw SvnException( error );
}
catch( SvnException &e )
{
// use callback error over ClientException
m_context.checkForError( m_module.client_error );
throw_client_error( e );
}
// cannot convert to Unicode as we have no idea of the encoding of the bytes
return Py::String( stringbuf->data, (int)stringbuf->len );
}
/*
* user error file
*/
void NetflixAlgorithm::write_user_error_file(string error, bool use_average)
{
ofstream error_file(error.c_str());
ofstream c_error_file(('c' + error).c_str());
double user_errors[NUM_MOVIES + 1];
int user_rating_sizes[NUM_MOVIES + 1];
memset(user_errors, 0, sizeof(user_errors));
memset(user_rating_sizes, 0, sizeof(user_rating_sizes));
int num_ratings_in_movie;
vector<movie_rating> movies;
double r;
// go through each movie
for (int i = 1; i <= NUM_MOVIES; ++i)
{
// grab the data
movies.clear();
valid_set.get_all_movie_ratings(i, movies);
num_ratings_in_movie = movies.size();
// go through each rating and print
for (int j = 0; j < num_ratings_in_movie; ++j)
{
r = predict_rating(movies[j].user_id, i,
movies[j].year, movies[j].month, movies[j].day);
double rating_error = pow(r - movies[j].rating, 2);
int num_user_ratings = training_set.get_num_user_ratings(movies[j].user_id);
user_errors[num_user_ratings] += rating_error;
++user_rating_sizes[num_user_ratings];
}
}
double total = 0;
double temp = 0;
double temptwo = 0;
for (int i = 1; i <= 20; ++i)
{
temp = user_errors[i] / (user_rating_sizes[i] > 0 ? user_rating_sizes[i] : 1);
error_file << temp << endl;
total += temp/20;
c_error_file << total << endl;
}
for (int i = 20 + 1; i <= NUM_MOVIES; ++i)
{
temp = user_errors[i] / (user_rating_sizes[i] > 0 ? user_rating_sizes[i] : 1);
temptwo = user_errors[i-20] / (user_rating_sizes[i-20] > 0 ? user_rating_sizes[i-20] : 1);
error_file << temp << endl;
total += (temp - temptwo)/20;
c_error_file << total << endl;
}
error_file.flush();
error_file.close();
c_error_file.flush();
c_error_file.close();
}
