void gui::initNet ()
{
socket=new QTcpSocket ();
qRegisterMetaType<QAbstractSocket::SocketState>("SocketState");
connect (socket,SIGNAL (stateChanged(QAbstractSocket::SocketState)),SLOT (tiskniStav (QAbstractSocket::SocketState)));
connect (socket,SIGNAL (connected ()),SLOT (pripojeno ()));
connect (socket,SIGNAL (readyRead ()),this,SLOT (cti ()));
socket->connectToHost (QHostAddress::LocalHost,6000);
}
void iterator_operator_minus()
{
tmm t;
BOOST_TEST(t.empty() == true);
BOOST_TEST(t.size() == 0);
BOOST_TEST(t.begin() == t.end());
t[s] = 1;
t[s1] = 2;
t[s2] = 3;
BOOST_TEST(t.begin() != t.end());
tmm::iterator ti;
tmm::const_iterator cti(t.end());
ti = t.begin();
BOOST_TEST((*ti).second == 1);
(*ti).second = 10;
BOOST_TEST((*ti).second == 10);
cti = t.begin();
BOOST_TEST((*cti).second == 10);
--ti;
BOOST_TEST(ti == t.begin());
BOOST_TEST(t[s2] == 3);
ti = t.end();
--ti;
BOOST_TEST((*ti).second == 2);
t[s3] = 4;
++ti;
BOOST_TEST((*ti).second == 4);
++ti;
BOOST_TEST(ti == t.end());
++ti;
BOOST_TEST(ti == t.end());
--ti;
BOOST_TEST((*ti).second == 4);
size_t node_cnt = 4 + 2 + 4 + 2;
t[s4] = 5;
t[s5] = 6;
BOOST_TEST(t.count_node() == node_cnt);
BOOST_TEST(t.size() == 6);
}
inline void Assembler::jmpl( Register s1, int simm13a, Register d, RelocationHolder const& rspec ) { insert_nop_after_cbcond(); cti(); emit_data( op(arith_op) | rd(d) | op3(jmpl_op3) | rs1(s1) | immed(true) | simm(simm13a, 13), rspec); has_delay_slot(); }
inline void Assembler::jmpl( Register s1, Register s2, Register d ) { insert_nop_after_cbcond(); cti(); emit_int32( op(arith_op) | rd(d) | op3(jmpl_op3) | rs1(s1) | rs2(s2)); has_delay_slot(); }
inline void Assembler::call( address d, relocInfo::relocType rt ) { insert_nop_after_cbcond(); cti(); emit_data( op(call_op) | wdisp(intptr_t(d), intptr_t(pc()), 30), rt); has_delay_slot(); assert(rt != relocInfo::virtual_call_type, "must use virtual_call_Relocation::spec"); }
inline void Assembler::cbcond(Condition c, CC cc, Register s1, int simm5, Label& L) { cti(); no_cbcond_before(); emit_data(op(branch_op) | cond_cbcond(c) | op2(bpr_op2) | branchcc(cc) | wdisp10(intptr_t(target(L)), intptr_t(pc())) | rs1(s1) | immed(true) | simm(simm5, 5)); }
inline void Assembler::bp( Condition c, bool a, CC cc, Predict p, address d, relocInfo::relocType rt ) { v9_only(); insert_nop_after_cbcond(); cti(); emit_data( op(branch_op) | annul(a) | cond(c) | op2(bp_op2) | branchcc(cc) | predict(p) | wdisp(intptr_t(d), intptr_t(pc()), 19), rt); has_delay_slot(); }
inline void Assembler::br( Condition c, bool a, address d, relocInfo::relocType rt ) { v9_dep(); insert_nop_after_cbcond(); cti(); emit_data( op(branch_op) | annul(a) | cond(c) | op2(br_op2) | wdisp(intptr_t(d), intptr_t(pc()), 22), rt); has_delay_slot(); }
inline void Assembler::bpr( RCondition c, bool a, Predict p, Register s1, address d, relocInfo::relocType rt ) { v9_only(); insert_nop_after_cbcond(); cti(); emit_data( op(branch_op) | annul(a) | cond(c) | op2(bpr_op2) | wdisp16(intptr_t(d), intptr_t(pc())) | predict(p) | rs1(s1), rt); has_delay_slot(); }
inline void Assembler::rett( Register s1, int simm13a, relocInfo::relocType rt) { cti(); emit_data( op(arith_op) | op3(rett_op3) | rs1(s1) | immed(true) | simm(simm13a, 13), rt); has_delay_slot(); }
inline void Assembler::rett( Register s1, Register s2 ) { cti(); emit_int32( op(arith_op) | op3(rett_op3) | rs1(s1) | rs2(s2)); has_delay_slot(); }
/**
* Description not yet available.
* \param
*/
void laplace_approximation_calculator::
check_hessian_type(function_minimizer * pfmin)
{
int ip = 0;
if (quadratic_prior::get_num_quadratic_prior()>0)
{
hesstype=4;
if (allocated(Hess))
{
if (Hess.indexmax()!=usize)
{
Hess.deallocate();
Hess.allocate(1,usize,1,usize);
}
}
else
{
Hess.allocate(1,usize,1,usize);
}
if (allocated(Hessadjoint))
{
if (Hessadjoint.indexmax()!=usize)
{
Hessadjoint.deallocate();
Hessadjoint.allocate(1,usize,1,usize);
}
}
else
{
Hessadjoint.allocate(1,usize,1,usize);
}
return;
}
else
{
int nv=initial_df1b2params::set_index();
if (allocated(used_flags))
{
if (used_flags.indexmax() != nv)
{
used_flags.safe_deallocate();
}
}
if (!allocated(used_flags))
{
used_flags.safe_allocate(1,nv);
}
//for (ip=1;ip<=num_der_blocks;ip++)
{
used_flags.initialize();
// do we need to reallocate memory for df1b2variables?
check_for_need_to_reallocate(ip);
df1b2_gradlist::set_no_derivatives();
//cout << re_objective_function_value::pobjfun << endl;
//cout << re_objective_function_value::pobjfun->ptr << endl;
(*re_objective_function_value::pobjfun)=0;
df1b2variable pen=0.0;
df1b2variable zz=0.0;
initial_df1b2params::reset(y,pen);
// call function to do block diagonal newton-raphson
// the step vector from the newton-raphson is in the vector step
df1b2_gradlist::set_no_derivatives();
funnel_init_var::lapprox=this;
block_diagonal_flag=5;
quadratic_prior::in_qp_calculations=1;
if (sparse_hessian_flag)
{
// just to get the number of separable calls
separable_calls_counter=0;
pfmin->AD_uf_inner();
// allocate space for uncompressed sparse hessian information
//num_separable_calls=separable_calls_counter;
if (triplet_information==0)
{
triplet_information =new i3_array(1,separable_calls_counter);
}
else if ( triplet_information->indexmax() != separable_calls_counter)
{
delete triplet_information;
triplet_information =new i3_array(1,separable_calls_counter);
}
triplet_information->initialize();
separable_calls_counter=0;
}
pfmin->pre_user_function();
if (sparse_hessian_flag)
{
// turn triplet_informaiton into compressed_triplet_information
int mmin= triplet_information->indexmin();
int mmax= triplet_information->indexmax();
int ndim=0;
for (int i=mmin;i<=mmax;i++)
{
if (allocated((*triplet_information)(i)))
{
ndim+=(*triplet_information)(i,1).indexmax();
}
}
if (compressed_triplet_information)
{
delete compressed_triplet_information;
compressed_triplet_information=0;
}
compressed_triplet_information=new imatrix(1,ndim,1,3);
(*compressed_triplet_information)(3).fill_seqadd(1,1);
int ii=0;
for (int i=mmin;i<=mmax;i++)
{
if (allocated((*triplet_information)(i)))
{
int jmin=(*triplet_information)(i,1).indexmin();
int jmax=(*triplet_information)(i,1).indexmax();
for (int j=jmin;j<=jmax;j++)
{
ii++;
(*compressed_triplet_information)(ii,1)=
(*triplet_information)(i,1,j);
(*compressed_triplet_information)(ii,2)=
(*triplet_information)(i,2,j);
(*compressed_triplet_information)(ii,3)=ii;
}
}
}
imatrix & cti= *compressed_triplet_information;
cti=sort(cti,1);
int lmin=1;
int lmax=0;
for (int i=2;i<=ndim;i++)
{
if (cti(i,1)>cti(i-1,1))
{
lmax=i-1;
cti.sub(lmin,lmax)=sort(cti.sub(lmin,lmax),2);
lmin=i;
}
}
cti.sub(lmin,ndim)=sort(cti.sub(lmin,ndim),2);
imatrix tmp=trans(cti);
delete compressed_triplet_information;
compressed_triplet_information=new imatrix(tmp);
}
quadratic_prior::in_qp_calculations=0;
int non_block_diagonal=0;
for (int i=xsize+1;i<=xsize+usize;i++)
{
if (used_flags(i)>1)
{
non_block_diagonal=1;
break;
}
}
if (non_block_diagonal)
{
if (bw< usize/2 && sparse_hessian_flag==0)
{
hesstype=3; //banded
if (bHess)
{
if (bHess->bandwidth() !=bw)
{
delete bHess;
bHess = new banded_symmetric_dmatrix(1,usize,bw);
if (bHess==0)
{
cerr << "Error allocating banded_symmetric_dmatrix" << endl;
ad_exit(1);
}
}
}
else
{
bHess = new banded_symmetric_dmatrix(1,usize,bw);
if (bHess==0)
{
cerr << "Error allocating banded_symmetric_dmatrix" << endl;
ad_exit(1);
}
}
if (bHessadjoint)
{
if (bHessadjoint->bandwidth() !=bw)
{
delete bHessadjoint;
bHessadjoint = new banded_symmetric_dmatrix(1,usize,bw);
if (bHessadjoint==0)
{
cerr << "Error allocating banded_symmetric_dmatrix" << endl;
ad_exit(1);
}
}
}
else
{
bHessadjoint = new banded_symmetric_dmatrix(1,usize,bw);
if (bHessadjoint==0)
{
cerr << "Error allocating banded_symmetric_dmatrix" << endl;
ad_exit(1);
}
}
}
else
{
//check_sparse_matrix_structure();
hesstype=4; // band is so wide so use full matrix
if (bHess)
{
delete bHess;
bHess=0;
}
if (bHessadjoint)
{
delete bHessadjoint;
bHessadjoint=0;
}
if (allocated(Hess))
{
if (sparse_hessian_flag)
{
Hess.deallocate();
}
else
{
if (Hess.indexmax() != usize)
{
Hess.deallocate();
Hess.allocate(1,usize,1,usize);
}
}
}
else
{
if (sparse_hessian_flag==0)
Hess.allocate(1,usize,1,usize);
}
if (sparse_hessian_flag)
{
make_sparse_triplet();
}
if (allocated(Hessadjoint))
{
if (sparse_hessian_flag)
{
Hess.deallocate();
}
else
{
if (Hessadjoint.indexmax() != usize)
{
Hessadjoint.deallocate();
Hessadjoint.allocate(1,usize,1,usize);
}
}
}
else
{
if (sparse_hessian_flag==0)
Hessadjoint.allocate(1,usize,1,usize);
}
}
}
else
{
hesstype=2;
}
if (hesstype==2 && num_importance_samples>0)
{
if (importance_sampling_components)
{
delete importance_sampling_components;
importance_sampling_components=0;
}
importance_sampling_components=
new dvar_matrix(1,pmin->lapprox->num_separable_calls,
1,num_importance_samples);
}
if (hesstype==2 && (num_importance_samples>0 || use_gauss_hermite>0))
{
const ivector & itmp=(*num_local_re_array)(1,num_separable_calls);
const ivector & itmpf=(*num_local_fixed_array)(1,num_separable_calls);
// ****************************************************
// ****************************************************
if (antiflag>0)
{
// generate antithetical rv's
generate_antithetical_rvs();
}
if (use_gauss_hermite>0)
{
if (gh)
{
delete gh;
gh=0;
}
gh=new gauss_hermite_stuff(this,use_gauss_hermite,
num_separable_calls,itmp);
}
if (block_diagonal_vch)
{
delete block_diagonal_vch;
block_diagonal_vch=0;
}
block_diagonal_vch = new dvar3_array(1,num_separable_calls,
1,itmp,1,itmp);
if (block_diagonal_ch)
{
delete block_diagonal_ch;
block_diagonal_ch=0;
}
block_diagonal_ch = new d3_array(1,num_separable_calls,
1,itmp,1,itmp);
if (block_diagonal_hessian)
{
delete block_diagonal_hessian;
block_diagonal_hessian=0;
}
block_diagonal_hessian = new d3_array(1,num_separable_calls,
1,itmp,1,itmp);
if (block_diagonal_hessian ==0)
{
cerr << "error_allocating d3_array" << endl;
ad_exit(1);
}
if (block_diagonal_re_list)
{
delete block_diagonal_re_list;
block_diagonal_re_list = 0;
}
block_diagonal_re_list = new imatrix(1,num_separable_calls,
1,itmp);
if (block_diagonal_re_list == 0)
{
cerr << "error_allocating imatrix" << endl;
ad_exit(1);
}
if (block_diagonal_fe_list)
{
delete block_diagonal_fe_list;
block_diagonal_fe_list = 0;
}
block_diagonal_fe_list = new imatrix(1,num_separable_calls,
1,itmpf);
if (block_diagonal_fe_list ==0)
{
cerr << "error_allocating imatrix" << endl;
ad_exit(1);
}
// ****************************************************
if (block_diagonal_Dux)
{
delete block_diagonal_Dux;
block_diagonal_Dux=0;
}
block_diagonal_Dux = new d3_array(1,num_separable_calls,
1,itmp,1,itmpf);
if (block_diagonal_Dux ==0)
{
cerr << "error_allocating d3_array" << endl;
ad_exit(1);
}
// ****************************************************
// ****************************************************
if (block_diagonal_vhessian)
{
delete block_diagonal_vhessian;
block_diagonal_vhessian=0;
}
block_diagonal_vhessian = new dvar3_array(1,num_separable_calls,
1,itmp,1,itmp);
if (block_diagonal_vhessian ==0)
{
cerr << "error_allocating d3_array" << endl;
ad_exit(1);
}
if (block_diagonal_vhessianadjoint)
{
delete block_diagonal_vhessianadjoint;
block_diagonal_vhessianadjoint=0;
}
block_diagonal_vhessianadjoint = new d3_array(1,num_separable_calls,
1,itmp,1,itmp);
if (block_diagonal_vhessianadjoint ==0)
{
cerr << "error_allocating d3_array" << endl;
ad_exit(1);
}
}
funnel_init_var::lapprox=0;
block_diagonal_flag=0;
pen.deallocate();
}
}
}
/**
* Description not yet available.
* \param
*/
void laplace_approximation_calculator::make_sparse_triplet(void)
{
//int i;
/*
int mmax=Hess.indexmax();
int nz=sum(Hess);
if (sparse_triplet)
{
delete sparse_triplet;
sparse_triplet=0;
}
*/
int nz2=0;
if (compressed_triplet_information)
{
imatrix & cti = *compressed_triplet_information;
int mmin=cti(cti.indexmin()).indexmin();
int mmax=cti(cti.indexmin()).indexmax();
nz2=1;
int lmin=cti(2,1);
for (int i=mmin+1;i<=mmax;i++)
{
if (cti(1,i)>cti(1,i-1))
{
nz2++;
lmin=cti(2,i);
}
else if (cti(2,i)>lmin)
{
lmin=cti(2,i);
nz2++;
}
}
}
//cout << nz2-nz << endl;
if (sparse_triplet)
{
delete sparse_triplet;
sparse_triplet=0;
}
//sparse_triplet = new dcompressed_triplet(1,nz2,usize,usize);
if (sparse_triplet2)
{
delete sparse_triplet2;
sparse_triplet2=0;
}
sparse_triplet2 = new dcompressed_triplet(1,nz2,usize,usize);
if (compressed_triplet_information)
{
imatrix & cti = *compressed_triplet_information;
int mmin=cti(cti.indexmin()).indexmin();
int mmax=cti(cti.indexmin()).indexmax();
if (sparse_iterator)
{
delete sparse_iterator;
sparse_iterator=0;
}
sparse_iterator=new ivector(mmin,mmax);
int ii=1;
int lmin=cti(2,1);
(*sparse_triplet2)(1,ii)=cti(1,1);
(*sparse_triplet2)(2,ii)=cti(2,1);
(*sparse_iterator)(cti(3,1))=ii;
for (int i=mmin+1;i<=mmax;i++)
{
if (cti(1,i)>cti(1,i-1))
{
ii++;
(*sparse_triplet2)(1,ii)=cti(1,i);
(*sparse_triplet2)(2,ii)=cti(2,i);
lmin=cti(2,i);
}
else if (cti(2,i)>lmin)
{
ii++;
(*sparse_triplet2)(1,ii)=cti(1,i);
(*sparse_triplet2)(2,ii)=cti(2,i);
lmin=cti(2,i);
}
(*sparse_iterator)(cti(3,i))=ii;
}
}
//cout << setw(8) << setprecision(2) << setscientific() << rowsum(Hess)
// << endl;
//cout << setw(8) << setprecision(2) << setscientific() << Hess << endl;
/*
int ii=0;
for (i=1;i<=mmax;i++)
{
for (int j=i;j<=mmax;j++)
{
if (Hess(i,j) != 0.0)
{
++ii;
(*sparse_triplet)(1,ii)=i;
(*sparse_triplet)(2,ii)=j;
(*sparse_triplet)(ii)=0.0;
}
}
}
*/
//sparse_symbolic = new hs_symbolic(*sparse_triplet,1);
sparse_symbolic2 = new hs_symbolic(*sparse_triplet2,1);
}
