static void
render_scene (APP_STATE_T * state)
{
update_model (state);
redraw_scene (state);
TRACE_VC_MEMORY_ONCE_FOR_ID ("after render_scene", gid2);
}
/*
* The main procedure is similar to the main found in ARITH1E.C. It has
* to initialize the coder and the model. It then sits in a loop reading
* input symbols and encoding them. One difference is that every 256
* symbols a compression check is performed. If the compression ratio
* falls below 10%, a flush character is encoded. This flushes the encod
* ing model, and will cause the decoder to flush its model when the
* file is being expanded. The second difference is that each symbol is
* repeatedly encoded until a successful encoding occurs. When trying to
* encode a character in a particular order, the model may have to
* transmit an ESCAPE character. If this is the case, the character has
* to be retransmitted using a lower order. This process repeats until a
* successful match is found of the symbol in a particular context.
* Usually this means going down no further than the order -1 model.
* However, the FLUSH and DONE symbols drop back to the order -2 model.
*
*/
void CompressFile(FILE *input,BIT_FILE *output,int argc,char *argv[])
{
SYMBOL s;
int c;
int escaped;
int flush = 0;
long int text_count = 0;
initialize_options( argc, argv );
initialize_model();
initialize_arithmetic_encoder();
for ( ; ; ) {
if ( ( ++text_count & 0x0ff ) == 0 )
flush = check_compression( input, output );
if ( !flush )
c = getc( input );
else
c = FLUSH;
if ( c == EOF )
c = DONE;
do {
escaped = convert_int_to_symbol( c, &s);
encode_symbol( output, &s );
} while ( escaped );
if ( c == DONE )
break;
if ( c == FLUSH ) {
flush_model();
flush = 0;
}
update_model( c );
add_character_to_model( c );
}
flush_arithmetic_encoder( output );
}
int main ()
{
bcm_host_init();
printf("Note: ensure you have sufficient gpu_mem configured\n");
// Clear application state
memset( state, 0, sizeof( *state ) );
// Start OGLES
init_ogl(state);
// Setup the model world
init_model_proj(state);
// initialise the OGLES texture(s)
init_textures(state);
while (!terminate)
{
update_model(state);
redraw_scene(state);
}
exit_func();
return 0;
}
/*
* The main loop for expansion is very similar to the expansion
* routine used in the simpler compression program, ARITH1E.C. The
* routine first has to initialize the the arithmetic coder and the
* model. The decompression loop differs in a couple of respect.
* First of all, it handles the special ESCAPE character, by
* removing them from the input bit stream but just throwing them
* away otherwise. Secondly, it handles the special FLUSH character.
* Once the main decoding loop is done, the cleanup code is called,
* and the program exits.
*
*/
void ExpandFile(BIT_FILE *input,FILE *output,int argc,char *argv[])
{
SYMBOL s;
int c;
int count;
initialize_options( argc, argv );
initialize_model();
initialize_arithmetic_decoder( input );
for ( ; ; ) {
do {
get_symbol_scale( &s );
count = get_current_count( &s );
c = convert_symbol_to_int( count, &s );
remove_symbol_from_stream( input, &s );
} while ( c == ESCAPE );
if ( c == DONE )
break;
if ( c != FLUSH )
putc( (char) c, output );
else
flush_model();
update_model( c );
add_character_to_model( c );
}
}
RFO::RFO()
{
version=0.1f;
m_cols = new ModelColumns();
m_model = Gtk::TreeStore::create (*m_cols);
update_model();
}
CExport double calculate_VR(void* ptr, void** p) {
if (!update_model(ptr, p)) {
show_error("calculate_VR");
return DBL_NAN;
}
return ((SphereModel*)ptr)->calculate_VR();
}
CExport void calculate_qxqy(void* ptr, void** p, int nq, double iq[], double qx[], double qy[]) {
if (!update_model(ptr, p))
show_error("calculate_qxqy", nq, iq);
else
while (nq-- != 0)
*iq++ = (*(SphereModel*)ptr)(*qx++, *qy++);
}
void RFO::clear()
{
Objects.clear();
version = 0.0f;
m_filename = "";
transform3D.identity();
update_model();
}
void SelectWidget::select_index(int index) {
selected_index = index;
if (selected_index >= 0) {
SelectWidgetItem *item = &items.at(selected_index);
label.set_text(item->name);
label.update();
update_model();
}
}
void RFO::DeleteSelected(Gtk::TreeModel::iterator &iter)
{
int i = (*iter)[m_cols->m_object];
int j = (*iter)[m_cols->m_file];
if (j >= 0)
Objects[i].files.erase (Objects[i].files.begin() + j);
else if (i >= 0)
Objects.erase (Objects.begin() + i);
update_model();
}
void RFO::DeleteSelected(Gtk::TreeModel::iterator &iter)
{
RFO_Object *object;
RFO_File *file;
get_selected_stl (iter, object, file);
if (file != NULL)
Objects[object->idx].files.erase (Objects[object->idx].files.begin() + file->idx);
else if (object != NULL)
Objects.erase (Objects.begin() + object->idx);
update_model();
}
/***********************************
* Decompress a 32 bit Integer
***********************************/
uint32_t decompress_int(Arithmetic_stream as, stream_model *PA){
uint32_t Byte = 0, prevByte = 0, x = 0;
// we encode byte per byte i.e. x = [B0 B1 B2 B3] (msB first)
// Read B0 the Arithmetic Stream using the alphabet model
Byte = read_value_from_as(as, PA[0]);
// Update model
update_model(PA[0], Byte);
prevByte = Byte;
x = Byte << 24;
// Read B1 from the Arithmetic Stream using the alphabet model
Byte = read_value_from_as(as, PA[1]);
// Update model
update_model(PA[1], Byte);
prevByte = Byte;
x |= Byte << 16;
// Send B2 to the Arithmetic Stream using the alphabet model
Byte = read_value_from_as(as, PA[2]);
// Update model
update_model(PA[2], Byte);
prevByte = Byte;
x |= Byte << 8;
// Send B3 to the Arithmetic Stream using the alphabet model
Byte = read_value_from_as(as, PA[3]);
// Update model
update_model(PA[3], Byte);
x |= Byte;
return x;
}
static void encode_arith_symbol(MscCoderArithModel *arithModel, PutBitContext *pb, int value) {
MscCoderArithSymbol arithSymbol;
// convert value to range symbol
convert_int_to_symbol(arithModel, value, &arithSymbol);
// encode symbol by arith encoder
encode_symbol(pb, &arithSymbol);
// update arithmetic model
update_model(arithModel, value);
}
HandModel::HandModel( const vector<float>& values ) {
BoundedParameter<float> par;
par.l = -FLT_MAX;
par.u = FLT_MAX;
for ( unsigned int i = 0; i < values.size(); i++ ) {
par.v = values[i];
params.push_back( par );
}
update_model();
}
// calculations
CExport void calculate_q(void* ptr, void** p, int nq, double iq[], double q[]) {
if (!update_model(ptr, p))
show_error("calculate_q", nq, iq);
else
{
std::cout << "err q" << " " << nq << " " << q << " " << iq << std::endl;
std::cout << "err q" << " " << nq << " " << *(q) << " " << *(iq) << std::endl;
while (nq-- != 0)
{
*iq++ = (*(SphereModel*)ptr)(*q++);
std::cout << "err q" << " " << nq << " " << q << " " << iq << std::endl;
std::cout << "err q" << " " << nq << " " << q[-1] << " " << iq[-1] << std::endl; }
std::cout << "done q" << std::endl; }
}
/***********************************
* Compress a 32 bit Integer
***********************************/
uint32_t compress_int(Arithmetic_stream as, stream_model *PA, uint32_t x){
uint32_t Byte = 0, prevByte = 0;
// we encode byte per byte i.e. x = [B0 B1 B2 B3] (msB first)
// Send B0 to the Arithmetic Stream using the alphabet model
Byte = x >> 24;
send_value_to_as(as, PA[0], Byte);
// Update model
update_model(PA[0], Byte);
prevByte = Byte;
// Send B1 to the Arithmetic Stream using the alphabet model
Byte = (x & 0x00ff0000) >> 16;
send_value_to_as(as, PA[1], Byte);
// Update model
update_model(PA[1], Byte);
prevByte = Byte;
// Send B2 to the Arithmetic Stream using the alphabet model
Byte = (x & 0x0000ff00) >> 8;
send_value_to_as(as, PA[2], Byte);
// Update model
update_model(PA[2], Byte);
prevByte = Byte;
// Send B3 to the Arithmetic Stream using the alphabet model
Byte = (x & 0x000000ff);
send_value_to_as(as, PA[3], Byte);
// Update model
update_model(PA[3], Byte);
return 1;
}
//���������������������������������������������������������������������������
// Lander - run
//���������������������������������������������������������������������������
void Lander::step ()
{
if (!remote)
{
process_events ();
update_model ();
// If we're on the network, let everyone know our new position
if (Net && Net->is_active())
{
LanderPositionData pd (*this);
Net->broadcast (player_id, &pd, sizeof (pd));
}
}
}
Gtk::TreePath RFO::createFile(RFO_Object *parent, const Slicer &stl,
std::string location)
{
RFO_File r;
r.stl = stl;
r.location = location;
parent->files.push_back(r);
update_model();
Gtk::TreePath path;
path.push_back (0); // root
path.push_back (parent->idx);
path.push_back (parent->files.size() - 1);
return path;
}
bool ChessFieldModel::load_game(QUrl file)
{
QString qstr = file.path();
QByteArray ba = qstr.toLatin1();
const char *fname = ba.data();
if(!fname || !*fname) {
return false;
}
std::ifstream in(fname+1);// because of trailing '/'
if(in) {
bool ret = m_chess_board.load_game(in);
in.close();
update_model();
return ret;
}
return false;
}
static int decode_arith_symbol(MscCoderArithModel *arithModel, GetBitContext *gb) {
MscCoderArithSymbol arithSymbol;
int count, value;
// get range symbol
get_symbol_scale(arithModel, &arithSymbol);
// get value for symbol
count = get_current_count(&arithSymbol);
value = convert_symbol_to_int(arithModel, count, &arithSymbol);
// remove symbol from stream
remove_symbol_from_stream(gb, &arithSymbol);
// update arithmetic coder model
update_model(arithModel, value);
return value;
}
SelectWidget::SelectWidget(GuiWindow *gui_window) :
Widget(gui_window),
label(gui_window->gui)
{
arrow_icon_img = gui->img_caret_down;
padding_left = 4;
padding_right = 4;
padding_top = 4;
padding_bottom = 4;
icon_spacing = 4;
hovering = false;
text_color = color_fg_text();
selected_index = -1;
context_menu = create<MenuWidgetItem>(gui_window);
context_menu_open = false;
update_model();
}
arma::cube ung_ssm::predict_sample(const arma::mat& theta_posterior,
const arma::mat& alpha, const arma::uvec& counts,
const unsigned int predict_type, const unsigned int nsim) {
unsigned int d = 1;
if (predict_type == 3) d = m;
arma::mat expanded_theta = rep_mat(theta_posterior, counts);
arma::mat expanded_alpha = rep_mat(alpha, counts);
unsigned int n_samples = expanded_theta.n_cols;
arma::cube sample(d, n, nsim * n_samples);
for (unsigned int i = 0; i < n_samples; i++) {
update_model(expanded_theta.col(i));
a1 = expanded_alpha.col(i);
sample.slices(i * nsim, (i + 1) * nsim - 1) =
sample_model(predict_type, nsim);
}
return sample;
}
unsigned int do_deari(unsigned int insize)
{
in_size = (unsigned int)insize;
in_pos = 0;
deari_pos = 0;
start_model(); /* Set up other modules. */
start_inputing_bits();
start_decoding();
for (;;) { /* Loop through characters. */
int ch; int symbol;
symbol = decode_symbol(cum_freq); /* Decode next symbol. */
if (symbol==EOF_symbol) break; /* Exit loop if EOF symbol. */
ch = index_to_char[symbol]; /* Translate to a character.*/
deari[deari_pos++]=(unsigned char)ch; /* Write that character. */
update_model(symbol); /* Update the model. */
}
return deari_pos;
}
TextWidget::TextWidget(GuiWindow *gui_window) :
Widget(gui_window),
_userdata(NULL),
_label(gui),
_padding_left(4),
_padding_right(4),
_padding_top(4),
_padding_bottom(4),
_text_color(0.0f, 0.0f, 0.0f, 1.0f),
_sel_text_color(1.0f, 1.0f, 1.0f, 1.0f),
_background_color(0.828f, 0.862f, 0.916f, 1.0f),
_hover_color(0.7f, 0.7f, 0.8f, 1.0f),
_selection_color(color_selection()),
_cursor_color(0.1216f, 0.149f, 0.2078, 1.0f),
_auto_size(false),
fixed_min_width(0),
fixed_max_width(200),
_icon_size_w(16),
_icon_size_h(16),
_icon_margin(4),
_cursor_start(0),
_cursor_end(0),
_select_down(false),
_have_focus(false),
_scroll_x(0),
_placeholder_label(gui),
_placeholder_color(0.4f, 0.4f, 0.4f, 1.0f),
_mouse_down_dbl(false),
_background_on(true),
_hover_on(false),
_text_interaction_on(true),
_icon_img(NULL),
_hovering(false),
_on_key_event(default_on_key_event),
_on_text_change_event(default_on_text_change_event),
_on_mouse_event(default_on_mouse_event)
{
update_model();
}
void TextWidget::scroll_index_into_view(int char_index) {
if (_auto_size) {
_scroll_x = 0;
} else {
int x, y;
pos_at_cursor(char_index, x, y);
int cursor_too_far_right = x - (width - _padding_right);
if (cursor_too_far_right > 0)
_scroll_x += cursor_too_far_right;
int cursor_too_far_left = -x + label_start_x();
if (cursor_too_far_left > 0)
_scroll_x -= cursor_too_far_left;
int max_scroll_x = max(0, _label.width() - (width - label_start_x() - _padding_right));
_scroll_x = clamp(0, _scroll_x, max_scroll_x);
}
update_model();
update_selection_model();
}
bool GurobiProgram::solve(bool relax){
//cout << "\n Presolve = " << grb_env->get(GRB_IntParam_Presolve) << endl;
// print_constraints();
if (relax) relax_model();
// relax_model();
grb_mod->optimize();
// grb_mod->write("~/Gqc_ots.lp");
if (grb_mod->get(GRB_IntAttr_Status) != 2) {
cerr << "\nModel has not been solved to optimality, error code = " << grb_mod->get(GRB_IntAttr_Status) << endl;
return false;
}
update_model();
//grb_mod->write("/home/kbestuzheva/PowerTools--/qc_ots.lp");
GRBVar* gvars = grb_mod->getVars();
for(int i = 0; i < grb_mod->get(GRB_IntAttr_NumVars); ++i) {
// cout << gvars[i].get(GRB_StringAttr_VarName) << " " << gvars[i].get(GRB_DoubleAttr_X) << endl;
if (gvars[i].get(GRB_CharAttr_VType)==GRB_BINARY) {
cout << gvars[i].get(GRB_StringAttr_VarName) << " ";
cout << gvars[i].get(GRB_DoubleAttr_X);
cout << "\n";
}
}
// cout << "\n***** Optimal Objective = " << grb_mod->get(GRB_DoubleAttr_ObjVal) << " *****\n";
model->_opt = grb_mod->get(GRB_DoubleAttr_ObjVal);
if (grb_mod->get(GRB_IntAttr_IsMIP)) {
cout.setf(ios::fixed);
cout.precision(3);
cout << "Results: " << grb_mod->get(GRB_DoubleAttr_ObjVal) << " & ";
cout.precision(4);
cout << (grb_mod->get(GRB_DoubleAttr_MIPGap))*100 << "% & ";
cout.precision(0);
cout << grb_mod->get(GRB_DoubleAttr_NodeCount) << " & ";
cout.precision(2);
cout << grb_mod->get(GRB_DoubleAttr_Runtime) << " & " << endl;
}
delete[] gvars;
return true;
}
void model::update(double time)
{
view::update(time);
create_phys();
double dt = time - (last_update_ ? *last_update_ : 0);
if (!cg::eq_zero(dt))
{
update_model(time, dt);
sync_phys(dt);
sync_nodes_manager(dt);
update_contact_effects(time);
}
last_update_ = time;
}
int
mug_msg_list_view_query (MugMsgListView * self, const char *query)
{
MugMsgListViewPrivate *priv;
gboolean rv;
g_return_val_if_fail (MUG_IS_MSG_LIST_VIEW (self), FALSE);
priv = MUG_MSG_LIST_VIEW_GET_PRIVATE (self);
gtk_list_store_clear (priv->_store);
g_free (priv->_query);
priv->_query = query ? g_strdup (query) : NULL;
if (!query)
return TRUE;
rv = update_model (priv->_store, priv->_xpath, query, self);
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (self));
return rv;
}
void model::update(double time)
{
view::update(time);
if(start_)
{
start_();
start_.clear();
}
double dt = time - (last_update_ ? *last_update_ : 0);
if (!cg::eq_zero(dt))
{
update_model(time, dt);
#if 0
if (!manual_controls_)
#endif
sync_phys(dt);
#if 0
else
{
cg::geo_base_3 base = phys_->get_base(*phys_zone_);
decart_position cur_pos = phys_vehicle_->get_position();
geo_position cur_glb_pos(cur_pos, base);
set_state(state_t(cur_glb_pos.pos, cur_pos.orien.get_course(), 0));
}
#endif
sync_nodes_manager(dt);
}
last_update_ = time;
}
int _main ()
{
bcm_host_init();
// Clear application state
memset( state, 0, sizeof( *state ) );
// Start OGLES
init_ogl(state);
// Setup the model world
init_model_proj(state);
// initialise the OGLES texture(s)
init_textures(state);
while (!terminate)
{
update_model(state);
redraw_scene(state);
}
exit_func();
return 0;
}
