static SCM pg_get_row(SCM res) {
struct pg_res *pgr;
SCM row;
scm_assert_smob_type(pg_res_tag, res);
pgr = (struct pg_res *)SCM_SMOB_DATA(res);
if (pgr->cursor >= pgr->tuples) return SCM_BOOL_F;
row = build_row(pgr);
pgr->cursor++;
scm_remember_upto_here_2(res, row);
return row;
}
static SCM pg_each_row(SCM res, SCM func) {
struct pg_res *pgr;
scm_assert_smob_type(pg_res_tag, res);
pgr = (struct pg_res *)SCM_SMOB_DATA(res);
while (pgr->cursor < pgr->tuples) {
scm_call_1(func, build_row(pgr));
pgr->cursor++;
}
PQclear(pgr->res);
pgr->res = NULL;
scm_remember_upto_here_2(res, func);
return SCM_UNSPECIFIED;
}
builder_iface&
array_builder::operator<<(std::string& buffer) {
if (m_reply_ready)
return *this;
if (not fetch_array_size(buffer))
return *this;
while (buffer.size() and not m_reply_ready)
if (not build_row(buffer))
return *this;
return *this;
}
static SCM pg_one_row(SCM conn, SCM query) {
struct pg_res *pgr;
SCM res, row;
scm_assert_smob_type(pg_conn_tag, conn);
res = pg_exec(conn, query);
pgr = (struct pg_res *)SCM_SMOB_DATA(res);
if (pgr->cursor < pgr->tuples) row = build_row(pgr);
else row = SCM_BOOL_F;
PQclear(pgr->res);
pgr->res = NULL;
scm_remember_upto_here_2(res, row);
scm_remember_upto_here_2(conn, query);
return row;
}
int
main(int argc, char *argv[])
{
const size_t n = 50000; /* number of observations */
const size_t p = 15; /* polynomial order + 1 */
double lambda = 0.0; /* regularization parameter */
gsl_vector *c_tsqr = gsl_vector_alloc(p);
gsl_vector *c_normal = gsl_vector_alloc(p);
if (argc > 1)
lambda = atof(argv[1]);
/* solve system with TSQR method */
solve_system(gsl_multilarge_linear_tsqr, lambda, n, p, c_tsqr);
/* solve system with Normal equations method */
solve_system(gsl_multilarge_linear_normal, lambda, n, p, c_normal);
/* output solutions */
{
gsl_vector *v = gsl_vector_alloc(p);
double t;
for (t = 10.0; t <= 11.0; t += 0.01)
{
double f_exact = func(t);
double f_tsqr, f_normal;
build_row(t, v);
gsl_blas_ddot(v, c_tsqr, &f_tsqr);
gsl_blas_ddot(v, c_normal, &f_normal);
printf("%f %e %e %e\n", t, f_exact, f_tsqr, f_normal);
}
gsl_vector_free(v);
}
gsl_vector_free(c_tsqr);
gsl_vector_free(c_normal);
return 0;
}
static SCM pg_map_rows(SCM res, SCM rest) {
struct pg_res *pgr;
SCM bag, row;
scm_assert_smob_type(pg_res_tag, res);
bag = row = SCM_EOL;
pgr = (struct pg_res *)SCM_SMOB_DATA(res);
while (pgr->cursor < pgr->tuples) {
row = build_row(pgr);
if (!scm_is_null(rest))
bag = scm_cons(scm_call_1(SCM_CAR(rest), row), bag);
else bag = scm_cons(row, bag);
pgr->cursor++;
}
PQclear(pgr->res);
pgr->res = NULL;
bag = scm_reverse(bag);
scm_remember_upto_here_2(bag, row);
scm_remember_upto_here_2(res, rest);
return bag;
}
TEST_F(TestObSSTableBlockBuilder, test_add_many_rows_to_one_block)
{
ObSSTableBlockBuilder block_builder;
block_builder.set_table_id(1000);
block_builder.set_column_group_id(2);
const char *block_buf = NULL;
const char *index_buf = NULL;
ObSSTableRow row;
int i = 0;
int ret;
ret = block_builder.init();
EXPECT_TRUE(OB_SUCCESS == ret);
while (true)
{
if (i > 10000)
{
break;
}
build_row(i, row);
ret = block_builder.add_row(row);
if (ret == OB_SUCCESS)
{
i++;
EXPECT_EQ(i, block_builder.get_row_count());
}
else
{
block_buf = block_builder.block_buf();
index_buf = block_builder.row_index_buf();
EXPECT_TRUE(block_builder.get_block_data_size() > 0);
EXPECT_TRUE(block_builder.get_row_index_size() > 0);
ret = block_builder.ensure_space(row.get_serialize_size());
EXPECT_TRUE(ret == OB_SUCCESS);
break;
}
}
}
TEST_F(TestObSSTableBlockBuilder, test_add_many_rows_to_blocks)
{
ObSSTableBlockBuilder block_builder;
block_builder.set_table_id(1000);
block_builder.set_column_group_id(2);
ObSSTableRow row;
int block_count = 0;
int i = 0;
int ret;
ret = block_builder.init();
EXPECT_TRUE(OB_SUCCESS == ret);
while (true)
{
build_row(i, row);
ret = block_builder.add_row(row);
EXPECT_TRUE(ret == OB_SUCCESS);
i++;
EXPECT_EQ(i, block_builder.get_row_count());
if (block_builder.get_block_size()
>= ObSSTableBlockBuilder::SSTABLE_BLOCK_SIZE / 4)
{
block_count++;
EXPECT_TRUE(block_builder.ensure_space(4) == OB_SUCCESS);
block_builder.reset();
block_builder.set_table_id(1000);
block_builder.set_column_group_id(2);
EXPECT_EQ(0, block_builder.get_row_count());
i = 0;
if (block_count > 10)
{
break;
}
}
}
}
int cal_main(int argc, char **argv)
{
struct tm *local_time;
struct tm zero_tm;
time_t now;
unsigned month, year, flags, i;
char *month_names[12];
char day_headings[28]; /* 28 for julian, 21 for nonjulian */
char buf[40];
flags = getopt32(argv, "jy");
/* This sets julian = flags & 1: */
option_mask32 &= 1;
month = 0;
argv += optind;
argc -= optind;
if (argc > 2) {
bb_show_usage();
}
if (!argc) {
time(&now);
local_time = localtime(&now);
year = local_time->tm_year + 1900;
if (!(flags & 2)) { /* no -y */
month = local_time->tm_mon + 1;
}
} else {
if (argc == 2) {
month = xatou_range(*argv++, 1, 12);
}
year = xatou_range(*argv, 1, 9999);
}
blank_string(day_headings, sizeof(day_headings) - 7 + 7*julian);
i = 0;
do {
zero_tm.tm_mon = i;
strftime(buf, sizeof(buf), "%B", &zero_tm);
month_names[i] = xstrdup(buf);
if (i < 7) {
zero_tm.tm_wday = i;
strftime(buf, sizeof(buf), "%a", &zero_tm);
strncpy(day_headings + i * (3+julian) + julian, buf, 2);
}
} while (++i < 12);
if (month) {
unsigned row, len, days[MAXDAYS];
unsigned *dp = days;
char lineout[30];
day_array(month, year, dp);
len = sprintf(lineout, "%s %d", month_names[month - 1], year);
printf("%*s%s\n%s\n",
((7*julian + WEEK_LEN) - len) / 2, "",
lineout, day_headings);
for (row = 0; row < 6; row++) {
build_row(lineout, dp)[0] = '\0';
dp += 7;
trim_trailing_spaces_and_print(lineout);
}
} else {
unsigned row, which_cal, week_len, days[12][MAXDAYS];
unsigned *dp;
char lineout[80];
sprintf(lineout, "%d", year);
center(lineout,
(WEEK_LEN * 3 + HEAD_SEP * 2)
+ julian * (J_WEEK_LEN * 2 + HEAD_SEP
- (WEEK_LEN * 3 + HEAD_SEP * 2)),
0);
puts("\n"); /* two \n's */
for (i = 0; i < 12; i++) {
day_array(i + 1, year, days[i]);
}
blank_string(lineout, sizeof(lineout));
week_len = WEEK_LEN + julian * (J_WEEK_LEN - WEEK_LEN);
for (month = 0; month < 12; month += 3-julian) {
center(month_names[month], week_len, HEAD_SEP);
if (!julian) {
center(month_names[month + 1], week_len, HEAD_SEP);
}
center(month_names[month + 2 - julian], week_len, 0);
printf("\n%s%*s%s", day_headings, HEAD_SEP, "", day_headings);
if (!julian) {
printf("%*s%s", HEAD_SEP, "", day_headings);
}
bb_putchar('\n');
for (row = 0; row < (6*7); row += 7) {
for (which_cal = 0; which_cal < 3-julian; which_cal++) {
dp = days[month + which_cal] + row;
build_row(lineout + which_cal * (week_len + 2), dp);
}
/* blank_string took care of nul termination. */
trim_trailing_spaces_and_print(lineout);
}
}
}
fflush_stdout_and_exit(EXIT_SUCCESS);
}
int
solve_system(const gsl_multilarge_linear_type * T,
const double lambda, const size_t n, const size_t p,
gsl_vector * c)
{
const size_t nblock = 5; /* number of blocks to accumulate */
const size_t nrows = n / nblock; /* number of rows per block */
gsl_multilarge_linear_workspace * w =
gsl_multilarge_linear_alloc(T, p);
gsl_matrix *X = gsl_matrix_alloc(nrows, p);
gsl_vector *y = gsl_vector_alloc(nrows);
gsl_rng *r = gsl_rng_alloc(gsl_rng_default);
size_t rowidx = 0;
double rnorm, snorm, rcond;
double t = 10.0;
double dt = 1.0 / (n - 1.0);
while (rowidx < n)
{
size_t nleft = n - rowidx; /* number of rows left to accumulate */
size_t nr = GSL_MIN(nrows, nleft); /* number of rows in this block */
gsl_matrix_view Xv = gsl_matrix_submatrix(X, 0, 0, nr, p);
gsl_vector_view yv = gsl_vector_subvector(y, 0, nr);
size_t i;
/* build (X,y) block with 'nr' rows */
for (i = 0; i < nr; ++i)
{
gsl_vector_view row = gsl_matrix_row(&Xv.matrix, i);
double yi = func(t);
double ei = gsl_ran_gaussian (r, 0.3 * yi); /* noise */
/* construct this row of LS matrix */
build_row(t, &row.vector);
/* set right hand side value with added noise */
gsl_vector_set(&yv.vector, i, yi + ei);
t += dt;
}
/* accumulate (X,y) block into LS system */
gsl_multilarge_linear_accumulate(&Xv.matrix, &yv.vector, w);
rowidx += nr;
}
/* solve large LS system and store solution in c */
gsl_multilarge_linear_solve(lambda, c, &rnorm, &snorm, w);
/* compute reciprocal condition number */
gsl_multilarge_linear_rcond(&rcond, w);
fprintf(stderr, "=== Method %s ===\n", gsl_multilarge_linear_name(w));
if (rcond != 0.0)
fprintf(stderr, "matrix condition number = %e\n", 1.0 / rcond);
fprintf(stderr, "residual norm = %e\n", rnorm);
fprintf(stderr, "solution norm = %e\n", snorm);
gsl_matrix_free(X);
gsl_vector_free(y);
gsl_multilarge_linear_free(w);
gsl_rng_free(r);
return 0;
}
