void receive_history_result(const data_chunk& data,
blockchain::fetch_handler_history handle_fetch)
{
BITCOIN_ASSERT(data.size() >= 4);
std::error_code ec;
auto deserial = make_deserializer(data.begin(), data.end());
if (!read_error_code(deserial, data.size(), ec))
return;
BITCOIN_ASSERT(deserial.iterator() == data.begin() + 4);
size_t row_size = 36 + 4 + 8 + 36 + 4;
if ((data.size() - 4) % row_size != 0)
{
log_error() << "Malformed response for *.fetch_history";
return;
}
size_t number_rows = (data.size() - 4) / row_size;
blockchain::history_list history(number_rows);
for (size_t i = 0; i < history.size(); ++i)
{
blockchain::history_row& row = history[i];
row.output.hash = deserial.read_hash();
row.output.index = deserial.read_4_bytes();
row.output_height = deserial.read_4_bytes();
row.value = deserial.read_8_bytes();
row.spend.hash = deserial.read_hash();
row.spend.index = deserial.read_4_bytes();
row.spend_height = deserial.read_4_bytes();
}
BITCOIN_ASSERT(deserial.iterator() == data.end());
handle_fetch(ec, history);
}
static void
search(struct hash *h) {
read_hash(h,"a");
read_hash(h,"b");
read_hash(h,"c");
int i;
char buffer[10];
for (i=0;i<100;i++) {
sprintf(buffer,"%d",i*2);
read_hash(h,buffer);
}
}
hash_digest block_result::transaction_hash(size_t i) const
{
BITCOIN_ASSERT(slab_);
BITCOIN_ASSERT(i < transactions_size());
const uint8_t* first = slab_ + 80 + 4 + 4 + i * hash_size;
auto deserial = make_deserializer_unsafe(first);
return deserial.read_hash();
}
static void
read_next(ParseInfo pi, const char *key) {
VALUE obj;
if ((void*)&obj < pi->stack_min) {
rb_raise(rb_eSysStackError, "JSON is too deeply nested");
}
next_non_white(pi); /* skip white space */
switch (*pi->s) {
case '{':
read_hash(pi, key);
break;
case '[':
read_array(pi, key);
break;
case '"':
read_str(pi, key);
break;
case '+':
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
read_num(pi, key);
break;
case 'I':
read_num(pi, key);
break;
case 't':
read_true(pi, key);
break;
case 'f':
read_false(pi, key);
break;
case 'n':
read_nil(pi, key);
break;
case '\0':
return;
default:
return;
}
}
bool leveldb_common::fetch_spend(const output_point& spent_output,
input_point& input_spend)
{
data_chunk spent_key = create_spent_key(spent_output);
std::string raw_spend;
leveldb::Status status = db_.spend->Get(
leveldb::ReadOptions(), slice(spent_key), &raw_spend);
if (status.IsNotFound())
return false;
else if (!status.ok())
{
log_fatal(LOG_BLOCKCHAIN) << "fetch_spend: " << status.ToString();
return false;
}
const data_chunk raw_spend_data(raw_spend.begin(), raw_spend.end());
auto deserial = make_deserializer(
raw_spend_data.begin(), raw_spend_data.end());
input_spend.hash = deserial.read_hash();
input_spend.index = deserial.read_4_bytes();
return true;
}
bool leveldb_common::deserialize_block(leveldb_block_info& blk_info,
const std::string& raw_data, bool read_header, bool read_tx_hashes)
{
// Read the header (if neccessary).
// There is always at least one tx in a block.
BITCOIN_ASSERT(raw_data.size() >= 80 + 4 + hash_digest_size);
BITCOIN_ASSERT((raw_data.size() - 84) % hash_digest_size == 0);
if (read_header)
satoshi_load(raw_data.begin(), raw_data.begin() + 80, blk_info.header);
if (!read_tx_hashes)
return true;
// Read the tx hashes for this block (if neccessary).
auto deserial = make_deserializer(raw_data.begin() + 80, raw_data.end());
uint32_t tx_count = deserial.read_4_bytes();
for (size_t i = 0; i < tx_count; ++i)
{
const hash_digest& tx_hash = deserial.read_hash();
blk_info.tx_hashes.push_back(tx_hash);
}
return true;
}
const hashtable_database_reader::get_result hashtable_database_reader::get(
const hash_digest& key_hash) const
{
uint64_t bucket_index = remainder(key_hash.data(), writer_.buckets());
BITCOIN_ASSERT(bucket_index < writer_.buckets());
uint64_t record_offset = read_record_offset(file_.data(), bucket_index);
const uint64_t header_size = 24 + writer_.buckets() * 8;
const uint8_t* all_records_begin = file_.data() + header_size;
const uint8_t* all_records_end =
all_records_begin + writer_.records_size();
const uint8_t* record_begin = all_records_begin + record_offset;
// We don't know the end of a record, so we use the end of all records
// for the deserializer.
// We will be jumping around the records since it's a chained
// list per bucket.
// Begin iterating the list.
while (true)
{
auto deserial = make_deserializer(record_begin, all_records_end);
const hash_digest current_hash = deserial.read_hash();
uint64_t value_size = deserial.read_variable_uint();
if (current_hash != key_hash)
{
// Move to next record in bucket.
// Skip the transaction data.
deserial.set_iterator(deserial.iterator() + value_size);
uint64_t next_record = deserial.read_8_bytes();
if (next_record == record_doesnt_exist)
return {nullptr, nullptr};
record_begin = all_records_begin + next_record;
continue;
}
// We have the record!
return {deserial.iterator(), deserial.iterator() + value_size};
}
BITCOIN_ASSERT_MSG(false, "Broke out of unbreakable loop!");
return {nullptr, nullptr};
}
void history_scan_database::scan(const address_bitset& key,
read_function read_func, size_t from_height) const
{
BITCOIN_ASSERT(key.size() >= settings_.sharded_bitsize);
const hsdb_shard& shard = lookup(key);
address_bitset sub_key = drop_prefix(key);
auto read_wrapped = [&read_func](const uint8_t* data)
{
auto deserial = make_deserializer_unsafe(data);
history_row row{
// output or spend?
marker_to_id(deserial.read_byte()),
// point
deserial.read_hash(),
deserial.read_4_bytes(),
// height
deserial.read_4_bytes(),
// value or checksum
deserial.read_8_bytes()};
read_func(row);
};
shard.scan(sub_key, read_wrapped, from_height);
}
static GwyContainer*
shimadzu_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *meta, *container = NULL;
GwyDataField *dfield = NULL;
GError *err = NULL;
gchar *buffer = NULL;
GHashTable *hash;
gchar *head;
gsize size = 0;
gboolean ok;
gint text_data_start;
if (!g_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < HEADER_SIZE + 2) {
err_TOO_SHORT(error);
return NULL;
}
if (memcmp(buffer, MAGIC, MAGIC_SIZE) != 0
&& !(memcmp(buffer, MAGIC_ASCII, MAGIC_ASCII_SIZE) == 0
&& (memcmp(buffer + MAGIC_ASCII_SIZE+1,
MAGIC, MAGIC_SIZE) == 0
|| memcmp(buffer + MAGIC_ASCII_SIZE+2,
MAGIC, MAGIC_SIZE) == 0))) {
err_FILE_TYPE(error, "Shimadzu");
g_free(buffer);
return NULL;
}
head = g_memdup(buffer, HEADER_SIZE+1);
head[HEADER_SIZE] = '\0';
/* text_data_start is set to nonzero if data are text */
hash = read_hash(head, &text_data_start, error);
ok = !!hash;
if (ok) {
if (text_data_start)
dfield = read_text_data(buffer, text_data_start, hash, error);
else
dfield = read_binary_data(buffer, size, hash, error);
ok = !!dfield;
}
if (ok) {
GQuark quark;
const gchar *title;
container = gwy_container_new();
quark = gwy_app_get_data_key_for_id(0);
gwy_container_set_object(container, quark, dfield);
g_object_unref(dfield);
meta = shimadzu_get_metadata(hash);
gwy_container_set_object_by_name(container, "/0/meta", meta);
g_object_unref(meta);
title = g_hash_table_lookup(hash, "Channel");
if (title && *title)
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup(title));
else
gwy_app_channel_title_fall_back(container, 0);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
}
g_free(head);
g_free(buffer);
g_hash_table_destroy(hash);
return container;
}
static GwyContainer*
nanoscope_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *meta, *container = NULL;
GError *err = NULL;
gchar *buffer = NULL;
gchar *p;
const gchar *self;
gsize size = 0;
NanoscopeFileType file_type;
NanoscopeData *ndata;
NanoscopeValue *val;
GHashTable *hash, *scannerlist = NULL, *scanlist = NULL;
GList *l, *list = NULL;
gint i, xres = 0, yres = 0;
gboolean ok, has_version = FALSE;
if (!g_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
file_type = NANOSCOPE_FILE_TYPE_NONE;
if (size > MAGIC_SIZE) {
if (!memcmp(buffer, MAGIC_TXT, MAGIC_SIZE))
file_type = NANOSCOPE_FILE_TYPE_TXT;
else if (!memcmp(buffer, MAGIC_BIN, MAGIC_SIZE))
file_type = NANOSCOPE_FILE_TYPE_BIN;
}
if (!file_type) {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("File is not a Nanoscope file, "
"or it is a unknown subtype."));
g_free(buffer);
return NULL;
}
gwy_debug("File type: %d", file_type);
/* as already know file_type, fix the first char for hash reading */
*buffer = '\\';
p = buffer;
while ((hash = read_hash(&p, &err))) {
ndata = g_new0(NanoscopeData, 1);
ndata->hash = hash;
list = g_list_append(list, ndata);
}
if (err) {
g_propagate_error(error, err);
ok = FALSE;
}
else
ok = TRUE;
for (l = list; ok && l; l = g_list_next(l)) {
ndata = (NanoscopeData*)l->data;
hash = ndata->hash;
self = g_hash_table_lookup(hash, "#self");
/* The alternate names were found in files written by some beast
* called Nanoscope E software */
if (gwy_strequal(self, "Scanner list")
|| gwy_strequal(self, "Microscope list")) {
scannerlist = hash;
continue;
}
if (gwy_strequal(self, "File list")) {
has_version = !!g_hash_table_lookup(hash, "Version");
gwy_debug("has Version: %d", has_version);
continue;
}
if (gwy_strequal(self, "Ciao scan list")
|| gwy_strequal(self, "Afm list")
|| gwy_strequal(self, "NC Afm list")) {
get_scan_list_res(hash, &xres, &yres);
scanlist = hash;
}
if (!gwy_strequal(self, "Ciao image list")
&& !gwy_strequal(self, "AFM image list")
&& !gwy_strequal(self, "NCAFM image list"))
continue;
ndata->data_field = hash_to_data_field(hash, scannerlist, scanlist,
file_type, has_version,
size, buffer,
xres, yres,
&p, error);
ok = ok && ndata->data_field;
}
if (ok) {
gchar key[40];
i = 0;
container = gwy_container_new();
for (l = list; l; l = g_list_next(l)) {
ndata = (NanoscopeData*)l->data;
if (ndata->data_field) {
g_snprintf(key, sizeof(key), "/%d/data", i);
gwy_container_set_object_by_name(container, key,
ndata->data_field);
if ((val = g_hash_table_lookup(ndata->hash, "@2:Image Data"))
&& val->soft_scale) {
g_snprintf(key, sizeof(key), "/%d/data/title", i);
gwy_container_set_string_by_name(container, key,
g_strdup(val->soft_scale));
}
meta = nanoscope_get_metadata(ndata->hash, list);
g_snprintf(key, sizeof(key), "/%d/meta", i);
gwy_container_set_object_by_name(container, key, meta);
g_object_unref(meta);
gwy_app_channel_check_nonsquare(container, i);
i++;
}
}
if (!i)
gwy_object_unref(container);
}
for (l = list; l; l = g_list_next(l)) {
ndata = (NanoscopeData*)l->data;
gwy_object_unref(ndata->data_field);
if (ndata->hash)
g_hash_table_destroy(ndata->hash);
g_free(ndata);
}
g_free(buffer);
g_list_free(list);
if (!container && ok)
err_NO_DATA(error);
return container;
}
int main(int argc, char* argv[])
{
TEST_PARAS myparas = parse_test_paras(argc, argv, testfile, embeddingfile, trainfile);
printf("Predicting...\n");
if(!myparas.allow_self_transition)
printf("Do not allow self-transtion.\n");
if (!myparas.underflow_correction)
printf("Underflow correction disabled\n");
int new_test_song_exp = (myparas.train_test_hash_file[0] != '\0');
if(myparas.tagfile[0] == '\0' && new_test_song_exp)
{
printf("Have to support with a tag file if you want to test on unseen songs.\n");
exit(1);
}
int d;
int m;
int l;
int i;
int j;
int s;
int fr;
int to;
double* bias_terms = 0;
double** X = read_matrix_file(embeddingfile, &l, &d, &bias_terms);
double** realX;
PDATA pd = read_playlists_data(testfile);
//int k = pd.num_songs;
int k;
double llhood = 0.0;
double uniform_llhood = 0.0;
double realn = 0.0;
double not_realn= 0.0;
int* train_test_hash;
int k_train;
int k_test;
TDATA td;
if(!new_test_song_exp)
{
k = pd.num_songs;
if(myparas.tagfile[0] != '\0')
{
td = read_tag_data(myparas.tagfile);
m = td.num_tags;
myparas.num_points = l / (k + m);
realX = zerosarray(k * myparas.num_points, d);
calculate_realX(X, realX, td, k, m, d, myparas.num_points);
free_tag_data(td);
if(myparas.tag_ebd_filename[0] != '\0')
write_embedding_to_file(X + k * myparas.num_points, m * myparas.num_points, d, myparas.tag_ebd_filename, 0);
}
else
{
myparas.num_points = l / k;
realX = zerosarray(k * myparas.num_points, d);
Array2Dcopy(X, realX, l, d);
}
Array2Dfree(X, l, d);
}
else
{
printf("Prediction on unseen songs.\n");
td = read_tag_data(myparas.tagfile);
m = td.num_tags;
k = td.num_songs;
train_test_hash = read_hash(myparas.train_test_hash_file, &k_train);
k_test = k - k_train;
printf("Number of new songs %d.\n", k_test);
myparas.num_points = l / (k_train + m);
realX = zerosarray(k * myparas.num_points, d);
calculate_realX_with_hash(X, realX, td, k, m, d, myparas.num_points, k_train, train_test_hash);
free_tag_data(td);
Array2Dfree(X, l, d);
}
if(myparas.song_ebd_filename[0] != '\0')
write_embedding_to_file(realX, k * myparas.num_points, d, myparas.song_ebd_filename, 0);
if(myparas.bias_ebd_filename[0] != '\0')
{
FILE* fp = fopen(myparas.bias_ebd_filename, "w");
for( i = 0; i < k ;i++)
{
fprintf(fp, "%f", bias_terms[i]);
if ( i != k - 1)
fputc('\n', fp);
}
fclose(fp);
}
double** square_dist;
if(myparas.square_dist_filename[0] != '\0')
square_dist = zerosarray(k, k);
int n = 0;
for(i = 0; i < pd.num_playlists; i ++)
if(pd.playlists_length[i] > 0)
n += pd.playlists_length[i] - 1;
printf("Altogether %d transitions.\n", n);fflush(stdout);
PHASH* tcount;
PHASH* tcount_train;
double** tcount_full;
double** tcount_full_train;
if(myparas.use_hash_TTable)
tcount = create_empty_hash(2 * n);
else
tcount_full = zerosarray(k, k);
HELEM temp_elem;
TPAIR temp_pair;
int idx;
double temp_val;
for(i = 0; i < pd.num_playlists; i ++)
{
if(pd.playlists_length[i] > myparas.range)
{
for(j = 0; j < pd.playlists_length[i] - 1; j++)
{
temp_pair.fr = pd.playlists[i][j];
temp_pair.to = pd.playlists[i][j + myparas.range];
//printf("(%d, %d)\n", temp_pair.fr, temp_pair.to);
if(temp_pair.fr >= 0 && temp_pair.to >= 0)
{
if(myparas.use_hash_TTable)
{
idx = exist_in_hash(tcount, temp_pair);
if(idx < 0)
{
temp_elem.key = temp_pair;
temp_elem.val = 1.0;
add_entry(tcount, temp_elem);
}
else
update_with(tcount, idx, 1.0);
}
else
tcount_full[temp_pair.fr][temp_pair.to] += 1.0;
}
}
}
}
TRANSITIONTABLE ttable;
TRANSITIONTABLE BFStable;
//Need to use the training file
if(myparas.output_distr)
{
PDATA pd_train = read_playlists_data(trainfile);
if(myparas.use_hash_TTable)
tcount_train = create_empty_hash(2 * n);
else
tcount_full_train = zerosarray(k, k);
for(i = 0; i < pd_train.num_playlists; i ++)
{
if(pd_train.playlists_length[i] > 1)
{
for(j = 0; j < pd_train.playlists_length[i] - 1; j++)
{
temp_pair.fr = pd_train.playlists[i][j];
temp_pair.to = pd_train.playlists[i][j + 1];
if(myparas.use_hash_TTable)
{
idx = exist_in_hash(tcount_train, temp_pair);
if(idx < 0)
{
temp_elem.key = temp_pair;
temp_elem.val = 1.0;
add_entry(tcount_train, temp_elem);
}
else
update_with(tcount_train, idx, 1.0);
}
else
tcount_full_train[temp_pair.fr][temp_pair.to] += 1.0;
}
}
}
}
FILE* song_distr_file;
FILE* trans_distr_file;
double* song_sep_ll;
if(myparas.output_distr)
{
printf("Output likelihood distribution file turned on.\n");
if(myparas.output_distr)
{
song_distr_file = fopen(songdistrfile, "w");
trans_distr_file = fopen(transdistrfile, "w");
song_sep_ll = (double*)calloc(k, sizeof(double));
}
}
int* test_ids_for_new_songs;
if(new_test_song_exp)
test_ids_for_new_songs = get_test_ids(k, k_train, train_test_hash);
for(fr = 0; fr < k; fr++)
{
int collection_size;
int* collection_idx;
if(myparas.fast_collection)
{
collection_size = (BFStable.parray)[fr].length;
if (collection_size == 0)
continue;
collection_idx = (int*)malloc(collection_size * sizeof(int));
LINKEDELEM* tempp = (BFStable.parray)[fr].head;
for(i = 0; i < collection_size; i++)
{
collection_idx[i] = tempp -> idx;
tempp = tempp -> pnext;
}
}
else if(new_test_song_exp)
{
collection_size = k_test;
collection_idx = (int*)malloc(collection_size * sizeof(int));
int_list_copy(test_ids_for_new_songs, collection_idx, k_test);
}
else
collection_size = k;
double** delta = zerosarray(collection_size, d);
double* p = (double*)calloc(collection_size, sizeof(double));
double** tempkd = zerosarray(collection_size, d);
double* tempk = (double*)calloc(collection_size, sizeof(double));
double** mid_delta = 0;
double* mid_p = 0;
double** mid_tempkd = 0;
// I get a seg fault when these get freed. Don't understand.
if (myparas.num_points == 3) {
mid_delta = zerosarray(collection_size, d);
mid_p = (double*)calloc(collection_size, sizeof(double));
mid_tempkd = zerosarray(collection_size, d);
}
for(j = 0; j < collection_size; j++)
{
for(i = 0; i < d; i++)
{
if(myparas.fast_collection || new_test_song_exp)
delta[j][i] = realX[fr][i] - realX[(myparas.num_points - 1) * k + collection_idx[j]][i];
else
delta[j][i] = realX[fr][i] - realX[(myparas.num_points - 1) * k + j][i];
}
if(myparas.num_points == 3) {
if(myparas.fast_collection || new_test_song_exp)
mid_delta[j][i] =
realX[k + fr][i] - realX[k + collection_idx[j]][i];
else
mid_delta[j][i] = realX[k + fr][i] - realX[k + j][i];
}
}
mat_mult(delta, delta, tempkd, collection_size, d);
scale_mat(tempkd, collection_size, d, -1.0);
sum_along_direct(tempkd, p, collection_size, d, 1);
if(myparas.square_dist_filename[0] != '\0')
for(i = 0; i < k; i++)
square_dist[fr][i] = -p[i];
if (bias_terms != 0)
add_vec(p, bias_terms, collection_size, 1.0);
if (myparas.num_points == 3) {
// Just use the mid_deltas (midpoint differences): square them,
// then sum and add to the p vector directly, then the midpoint
// probability is incorporated
mat_mult(mid_delta, mid_delta, mid_tempkd, collection_size, d);
scale_mat(mid_tempkd, collection_size, d, -1.0);
sum_along_direct(mid_tempkd, mid_p, collection_size, d, 1);
add_vec(p, mid_p, collection_size, 1.0);
}
if (myparas.underflow_correction == 1) {
double max_val = p[0];
for(i = 0; i < collection_size; i++)
max_val = p[i] > max_val? p[i] : max_val;
vec_scalar_sum(p, -max_val, collection_size);
}
Veccopy(p, tempk, collection_size);
exp_on_vec(tempk, collection_size);
//exp_on_vec(p, collection_size);
// underflow checking:
// for (i = 0; i < collection_size; i++)
// if (p[i] < 0.000001)
// p[i] = 0.000001;
double temp_sum;
if(myparas.allow_self_transition)
temp_sum = sum_vec(tempk, collection_size);
else
{
temp_sum = 0.0;
for(i = 0; i < collection_size; i++)
if(!myparas.fast_collection || new_test_song_exp)
temp_sum += (i != fr)? tempk[i] : 0.0;
else
temp_sum += (collection_idx[i] != fr)? tempk[i] : 0.0;
}
vec_scalar_sum(p, -log(temp_sum), collection_size);
//scale_vec(p, collection_size, 1.0 / temp_sum);
//printf("done...\n");
for(to = 0; to < k; to++)
{
if(myparas.allow_self_transition || (!myparas.allow_self_transition && fr != to))
{
temp_pair.fr = fr;
temp_pair.to = to;
//printf("(%d, %d)\n", fr, to);
if(myparas.use_hash_TTable)
idx = exist_in_hash(tcount, temp_pair);
else
idx = tcount_full[fr][to] > 0.0? 1 : -1;
//printf("%d\n", idx);fflush(stdout);
int idx_train;
//printf("done...\n");fflush(stdout);
if(myparas.output_distr)
{
if(myparas.use_hash_TTable)
idx_train = exist_in_hash(tcount_train, temp_pair);
else
idx_train = tcount_full_train[fr][to] > 0.0? 1 : -1;
}
if(idx >= 0)
{
if(myparas.fast_collection || new_test_song_exp)
{
s = -1;
for(i = 0; i < collection_size; i++)
{
if(collection_idx[i] == to)
{
s = i;
break;
}
}
}
else
s = to;
//printf("%d\n", idx);fflush(stdout);
if(myparas.use_hash_TTable)
temp_val = retrieve_value_with_idx(tcount, idx);
else
temp_val = tcount_full[fr][to];
if(s < 0)
not_realn += temp_val;
else
{
//printf("s = %d\n", s);
llhood += temp_val * p[s];
if(new_test_song_exp)
uniform_llhood += temp_val * log(1.0 / (double) k_test);
realn += temp_val;
if(myparas.output_distr)
{
//double temp_val_train = idx_train >= 0? retrieve_value_with_idx(tcount_train, idx_train): 0.0;
double temp_val_train;
if(idx_train < 0)
temp_val_train = 0.0;
else
temp_val_train = myparas.use_hash_TTable ? retrieve_value_with_idx(tcount_train, idx_train) : tcount_full_train[fr][to];
song_sep_ll[fr] += temp_val * p[s];
song_sep_ll[to] += temp_val * p[s];
fprintf(trans_distr_file, "%d %d %f\n", (int)temp_val_train, (int)temp_val, temp_val * p[s]);
}
}
}
}
}
Array2Dfree(delta, collection_size, d);
free(p);
Array2Dfree(tempkd, collection_size, d);
free(tempk);
if (myparas.num_points == 3) {
Array2Dfree(mid_delta, collection_size, d);
free(mid_p);
Array2Dfree(mid_tempkd, collection_size, d);
}
if(myparas.fast_collection || new_test_song_exp)
free(collection_idx);
}
if(myparas.output_distr)
{
printf("Writing song distr.\n");
for(i = 0; i < k; i++)
fprintf(song_distr_file, "%d %f\n", (int)(pd.id_counts[i]), song_sep_ll[i]);
fclose(song_distr_file);
fclose(trans_distr_file);
free(song_sep_ll);
}
llhood /= realn;
printf("Avg log-likelihood on test: %f\n", llhood);
if(myparas.fast_collection)
printf("Ratio of transitions that do not appear in the training set: %f\n", not_realn / (realn + not_realn));
if(new_test_song_exp)
{
uniform_llhood /= realn;
printf("Avg log-likelihood for uniform baseline: %f\n", uniform_llhood);
}
if(myparas.use_hash_TTable)
free_hash(tcount);
else
Array2Dfree(tcount_full, k, k);
free_playlists_data(pd);
if(myparas.output_distr)
{
if(myparas.use_hash_TTable)
free_hash(tcount_train);
else
Array2Dfree(tcount_full_train, k, k);
}
Array2Dfree(realX, k * myparas.num_points, d);
if(new_test_song_exp)
{
free(train_test_hash);
free(test_ids_for_new_songs);
}
if(myparas.square_dist_filename[0] != '\0')
{
write_embedding_to_file(square_dist, k, k, myparas.square_dist_filename, 0);
Array2Dfree(square_dist, k, k);
}
}
static mrb_value
read_value(MarshalContext *ctx)
{
mrb_state *mrb = ctx->mrb;
char type = ctx->readByte();
mrb_value value;
if (mrb->arena_idx > maxArena)
maxArena = mrb->arena_idx;
int arena = mrb_gc_arena_save(mrb);
switch (type)
{
case TYPE_NIL :
value = mrb_nil_value();
break;
case TYPE_TRUE :
value = mrb_true_value();
break;
case TYPE_FALSE :
value = mrb_false_value();
break;
case TYPE_FIXNUM :
value = mrb_fixnum_value(read_fixnum(ctx));
break;
case TYPE_BIGNUM :
value = mrb_fixnum_value(read_bignum(ctx));
break;
case TYPE_FLOAT :
value = mrb_float_value(mrb, read_float(ctx));
ctx->objects.add(value);
break;
case TYPE_STRING :
value = read_string_value(ctx);
ctx->objects.add(value);
break;
case TYPE_ARRAY :
value = read_array(ctx);
break;
case TYPE_HASH :
value = read_hash(ctx);
break;
case TYPE_SYMBOL :
value = mrb_symbol_value(read_symbol(ctx));
break;
case TYPE_SYMLINK :
value = mrb_symbol_value(read_symlink(ctx));
break;
case TYPE_OBJECT :
value = read_object(ctx);
break;
case TYPE_IVAR :
value = read_instance_var(ctx);
break;
case TYPE_LINK :
value = read_link(ctx);
break;
case TYPE_USERDEF :
value = read_userdef(ctx);
ctx->objects.add(value);
break;
default :
CCLOG( "Marshal.load: unsupported value type '%c',gbufsize %d",type,g_buf_size);
CCAssert(false,"f**k");
//exit(0);
}
mrb_gc_arena_restore(mrb, arena);
return value;
}