static double hyij(long i, long j)
{
return (Delta/12.0) * (12.0*(alphaC(i)*ad(j))
+4.0*( betaC(i)*ad(j) + alphaC(i)*bd(j) + gammaC(i)*ad(j) + alphaC(i)*cd(j))
+1.0*( betaC(i)*cd(j) + gammaC(i)*bd(j))
+2.0*( betaC(i)*bd(j) + gammaC(i)*cd(j)) );
}
static void range(const point_t *x, size_t c, box_t *B)
{
while (c--)
{
bd(&(B->min.x), x[c].x);
bu(&(B->max.x), x[c].x);
bd(&(B->min.y), x[c].y);
bu(&(B->max.y), x[c].y);
}
}
boost::shared_ptr<PhotonArray> SBAdd::SBAddImpl::shoot(int N, UniformDeviate u) const
{
dbg<<"Add shoot: N = "<<N<<std::endl;
dbg<<"Target flux = "<<getFlux()<<std::endl;
double totalAbsoluteFlux = getPositiveFlux() + getNegativeFlux();
double fluxPerPhoton = totalAbsoluteFlux / N;
// Initialize the output array
boost::shared_ptr<PhotonArray> result(new PhotonArray(0));
double remainingAbsoluteFlux = totalAbsoluteFlux;
int remainingN = N;
// Get photons from each summand, using BinomialDeviate to
// randomize distribution of photons among summands
for (ConstIter pptr = _plist.begin(); pptr!= _plist.end(); ++pptr) {
double thisAbsoluteFlux = pptr->getPositiveFlux() + pptr->getNegativeFlux();
// How many photons to shoot from this summand?
int thisN = remainingN; // All of what's left, if this is the last summand...
std::list<SBProfile>::const_iterator nextPtr = pptr;
++nextPtr;
if (nextPtr!=_plist.end()) {
// otherwise allocate a randomized fraction of the remaining photons to this summand:
BinomialDeviate bd(u, remainingN, thisAbsoluteFlux/remainingAbsoluteFlux);
thisN = bd();
}
if (thisN > 0) {
boost::shared_ptr<PhotonArray> thisPA = pptr->shoot(thisN, u);
// Now rescale the photon fluxes so that they are each nominally fluxPerPhoton
// whereas the shoot() routine would have made them each nominally
// thisAbsoluteFlux/thisN
thisPA->scaleFlux(fluxPerPhoton*thisN/thisAbsoluteFlux);
result->append(*thisPA);
}
remainingN -= thisN;
remainingAbsoluteFlux -= thisAbsoluteFlux;
if (remainingN <=0) break;
if (remainingAbsoluteFlux <= 0.) break;
}
dbg<<"Add Realized flux = "<<result->getTotalFlux()<<std::endl;
// This process produces correlated photons, so mark the resulting array as such.
if (_plist.size() > 1) result->setCorrelated();
return result;
}
Board toBoard(const std::string & str)
{
std::stringstream ss;
ss << str;
char buf[20];
ss.getline(buf,16);
Board bd(DefaultBoard);
for(int i = 0;i < 8;++i)
{
ss.getline(buf,16);
for(int j = 0;j < 8;++j)
{
switch(buf[j*2])
{
case 'x':
bd[xyToPos(i,j)] = BLACK;
break;
case 'o':
bd[xyToPos(i,j)] = WHITE;
break;
case '.':
bd[xyToPos(i,j)] = NONE;
break;
}
}
}
return bd;
}
void solve_with_Cpp(MultiFab& soln, MultiFab& gphi, Real a, Real b, MultiFab& alpha,
PArray<MultiFab>& beta, MultiFab& rhs, const BoxArray& bs, const Geometry& geom)
{
BL_PROFILE("solve_with_Cpp()");
BndryData bd(bs, 1, geom);
set_boundary(bd, rhs, 0);
ABecLaplacian abec_operator(bd, dx);
abec_operator.setScalars(a, b);
abec_operator.setCoefficients(alpha, beta);
MultiGrid mg(abec_operator);
mg.setVerbose(verbose);
mg.solve(soln, rhs, tolerance_rel, tolerance_abs);
PArray<MultiFab> grad_phi(BL_SPACEDIM, PArrayManage);
for (int n = 0; n < BL_SPACEDIM; ++n)
grad_phi.set(n, new MultiFab(BoxArray(soln.boxArray()).surroundingNodes(n), 1, 0));
#if (BL_SPACEDIM == 2)
abec_operator.compFlux(grad_phi[0],grad_phi[1],soln);
#elif (BL_SPACEDIM == 3)
abec_operator.compFlux(grad_phi[0],grad_phi[1],grad_phi[2],soln);
#endif
// Average edge-centered gradients to cell centers.
BoxLib::average_face_to_cellcenter(gphi, grad_phi, geom);
}
bool Border::toolOperations()
{
if (!loadToDImg())
{
return false;
}
BorderContainer prm;
prm.preserveAspectRatio = settings()[QLatin1String("preserveAspectRatio")].toBool();
prm.borderType = settings()[QLatin1String("borderType")].toInt();
prm.borderWidth1 = settings()[QLatin1String("borderWidth1")].toInt();
prm.borderWidth2 = settings()[QLatin1String("borderWidth2")].toInt();
prm.borderWidth3 = settings()[QLatin1String("borderWidth3")].toInt();
prm.borderWidth4 = settings()[QLatin1String("borderWidth4")].toInt();
prm.borderPercent = settings()[QLatin1String("borderPercent")].toDouble();
prm.borderPath = settings()[QLatin1String("borderPath")].toString();
prm.solidColor = settings()[QLatin1String("solidColor")].value<QColor>();
prm.niepceBorderColor = settings()[QLatin1String("niepceBorderColor")].value<QColor>();
prm.niepceLineColor = settings()[QLatin1String("niepceLineColor")].value<QColor>();
prm.bevelUpperLeftColor = settings()[QLatin1String("bevelUpperLeftColor")].value<QColor>();
prm.bevelLowerRightColor = settings()[QLatin1String("bevelLowerRightColor")].value<QColor>();
prm.decorativeFirstColor = settings()[QLatin1String("decorativeFirstColor")].value<QColor>();
prm.decorativeSecondColor = settings()[QLatin1String("decorativeSecondColor")].value<QColor>();
prm.orgWidth = image().width();
prm.orgHeight = image().height();
BorderFilter bd(&image(), 0L, prm);
applyFilterChangedProperties(&bd);
return (savefromDImg());
}
OutputInfo FullyConnected::initialize(std::vector<double*>& parameterPointers,
std::vector<double*>& parameterDerivativePointers)
{
parameterPointers.reserve(parameterPointers.size() + J * (I + bias));
parameterDerivativePointers.reserve(parameterDerivativePointers.size() + J * (I + bias));
for(int j = 0; j < J; j++)
{
for(int i = 0; i < I; i++)
{
parameterPointers.push_back(&W(j, i));
parameterDerivativePointers.push_back(&Wd(j, i));
}
if(bias)
{
parameterPointers.push_back(&b(j));
parameterDerivativePointers.push_back(&bd(j));
}
}
initializeParameters();
OutputInfo info;
info.dimensions.push_back(J);
return info;
}
int main()
{
DatasimDate myBirthday(29, 8, 1952);
string myName ("Daniel J. Duffy");
Person dd(myName, myBirthday);
dd.print();
DatasimDate bBirthday(06, 8, 1994);
string bName ("Brendan Duffy");
Person bd(bName, bBirthday);
bd.print();
Employee dde (myName, myBirthday, string("Cuchulainn Chief"), 0.01, 65);
dde.print();
cout << "Working with pointers I\n"; // Non-polymorphic function
Person* p = &dde;
p -> print();
cout << "Working with pointers II\n"; // Polymorphic function
p -> DeepPrint();
return 0;
}
void CoverBond::apply(Particle *p) const {
Bond bd(p);
core::XYZ ea(bd.get_bonded(0)), eb(bd.get_bonded(1));
core::XYZR r(p);
r.set_coordinates(.5*(ea.get_coordinates()+ eb.get_coordinates()));
r.set_radius((r.get_coordinates()- ea.get_coordinates()).get_magnitude());
}
void solve(MultiFab& soln, const MultiFab& anaSoln,
Real a, Real b, MultiFab& alpha, MultiFab beta[],
MultiFab& rhs, const BoxArray& bs, const Geometry& geom,
solver_t solver)
{
BL_PROFILE("solve");
soln.setVal(0.0);
const Real run_strt = ParallelDescriptor::second();
BndryData bd(bs, 1, geom);
set_boundary(bd, rhs);
ABecLaplacian abec_operator(bd, dx);
abec_operator.setScalars(a, b);
abec_operator.setCoefficients(alpha, beta);
MultiGrid mg(abec_operator);
mg.setMaxIter(maxiter);
mg.setVerbose(verbose);
mg.setFixedIter(1);
mg.solve(soln, rhs, tolerance_rel, tolerance_abs);
Real run_time = ParallelDescriptor::second() - run_strt;
ParallelDescriptor::ReduceRealMax(run_time, ParallelDescriptor::IOProcessorNumber());
if (ParallelDescriptor::IOProcessor()) {
std::cout << "Run time : " << run_time << std::endl;
}
}
void CoverBond::apply_index(Model *m, ParticleIndex pi) const {
Bond bd(m, pi);
core::XYZ ea(bd.get_bonded(0)), eb(bd.get_bonded(1));
core::XYZR r(m, pi);
r.set_coordinates(.5 * (ea.get_coordinates() + eb.get_coordinates()));
r.set_radius((r.get_coordinates() - ea.get_coordinates()).get_magnitude());
}
void testObj::test<3>(void)
{
BinData bd(3);
memcpy(bd.data(), "abc", 3);
ensure_equals("invalid byte 1", bd.data()[0], 'a');
ensure_equals("invalid byte 2", bd.data()[1], 'b');
ensure_equals("invalid byte 3", bd.data()[2], 'c');
}
ParticlesTemp CoverBond::get_input_particles(Particle *p) const {
Bond bd(p);
ParticlesTemp ret(3);
ret[0]=p;
ret[1]= bd.get_bonded(0);
ret[2]= bd.get_bonded(1);
return ret;
}
void DisassemblerView::showBookmarks()
{
BookmarkDialog bd(this->_disassembler, this);
int res = bd.exec();
if((res == BookmarkDialog::Accepted) && bd.selectedBlock())
ui->disassemblerWidget->jumpTo(bd.selectedBlock());
}
int main (int argc, char** argv)
{
Terminal t;
t.func();
BoldDecorator bd(t);
bd.func();
BarEndlineDecorator(bd).func();
}
void Display::OnChange(int id)
{
CString bmesg;
if(cbox->GetCount()<=0)
return;
if(id==IDC_RADIO1 && radio1->GetCheck()) //Send to client
{
cbox->EnableWindow(TRUE);
if(cbox->GetCount()>=1)
{
curuser.Empty();
cbox->GetLBText(cbox->GetCurSel(),curuser);
log.WriteString("\nConnected to user "+curuser);
selectflag=1;
startRecording();
}
else
{
curuser.Empty();
selectflag=0;
stopRecording();
//stopPlaying(); //****** REMOVED ******//
}
}
if(id==IDC_RADIO2 && radio2->GetCheck()) //Send to All
{
curuser="******";
if(isstart==0) //Stop the record and play
OnStop();
log.WriteString("\n Broadcasting message");
Broadcast bd(IDD_DIALOG5,this);
bd.DoModal();
bmesg="OVER:";
selectflag=1;
if(sockclt.Send(bmesg,bmesg.GetLength()))
log.WriteString("\n Over Mesg sent to Server");
else
log.WriteString("\n Unable to send over mesg to Server");
curuser.Empty();
radio1->SetCheck(1);
radio2->SetCheck(0);
}
}
// Note: diagnostic HACK
void justProcessInputVCFCandidates(CandidateGenerationHelper &candidate_generator, ExtendParameters *parameters) {
// just take from input file
vcf::VariantCallFile vcfFile;
vcfFile.open(parameters->candidateVCFFileName);
vcfFile.parseSamples = false;
//my_job_server.NewVariant(vcfFile);
vcf::Variant variant(vcfFile);
long int position = 0;
long int startPos = 0;
long int stopPos = 0;
string contigName = "";
//clear the BED targets and populate new targets that span just the variant positions
candidate_generator.parser->targets.clear();
while (vcfFile.getNextVariant(variant)) {
position = variant.position;
contigName = variant.sequenceName;
startPos = position - 10;
stopPos = position + 10;
//range check
if (candidate_generator.parser->targets.size() > 0) {
BedTarget * prevbd = &(candidate_generator.parser->targets[candidate_generator.parser->targets.size()-1]);
if (contigName.compare(prevbd->seq) == 0 && (startPos <= prevbd->right) && (startPos > prevbd->left)) {
prevbd->right = stopPos;
}
else {
BedTarget bd(contigName,
startPos,
stopPos);
candidate_generator.parser->targets.push_back(bd);
}
}
else {
BedTarget bd(contigName,
startPos,
stopPos);
candidate_generator.parser->targets.push_back(bd);
}
}
}
BinaryData TxIOPair::serializeDbKey(void) const
{
if (!hasTxIn())
return getDBKeyOfOutput();
BinaryData bd(getDBKeyOfInput());
bd.getPtr()[4] |= 0x80;
return bd;
}
Bond create_bond(Bonded a, Bonded b, Int t) {
IMP_USAGE_CHECK(a.get_particle() != b.get_particle(),
"The endpoints of a bond must be disjoint");
Particle *p = IMP::core::internal::graph_connect(
a.get_particle(), b.get_particle(), internal::get_bond_data().graph_);
Bond bd(p);
bd.set_type(t);
return bd;
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "srs_body_detector");
ros::NodeHandle nh;
BodyDetector bd(nh);
ros::spin();
return 0;
}
ModelObjectsTemp CoverBond::do_get_inputs(
Model *m, const ParticleIndexes &pis) const {
ModelObjectsTemp ret(3 * pis.size());
for (unsigned int i = 0; i < pis.size(); ++i) {
Bond bd(m, pis[i]);
ret[3 * i + 0] = m->get_particle(pis[i]);
ret[3 * i + 1] = bd.get_bonded(0);
ret[3 * i + 2] = bd.get_bonded(1);
}
return ret;
}
void Storm3D_SpotlightShared::setClipPlanes(const float *cameraView)
{
D3DXMATRIX m(cameraView);
float determinant = D3DXMatrixDeterminant(&m);
D3DXMatrixInverse(&m, &determinant, &m);
D3DXMatrixTranspose(&m, &m);
D3DXVECTOR3 d(direction.x, direction.y, direction.z);
VC2 bd(d.x, d.z);
bd.Normalize();
D3DXVECTOR3 p1(position.x - 8*bd.x, position.y, position.z - 8*bd.y);
//D3DXVECTOR3 p1(position.x - 1*bd.x, position.y, position.z - 1*bd.y);
D3DXVECTOR3 p2(p1.x, p1.y + 5.f, p1.z);
float angle = D3DXToRadian(fov) * .55f;
D3DXPLANE leftPlane;
D3DXMATRIX leftTransform;
D3DXMatrixRotationY(&leftTransform, -angle);
D3DXVECTOR3 leftPoint(direction.x, 0, direction.z);
D3DXVECTOR4 leftPoint2;
D3DXVec3Transform(&leftPoint2, &leftPoint, &leftTransform);
leftPoint = p1;
leftPoint.x += leftPoint2.x;
leftPoint.z += leftPoint2.z;
D3DXPlaneFromPoints(&leftPlane, &p1, &p2, &leftPoint);
D3DXPlaneNormalize(&leftPlane, &leftPlane);
D3DXPlaneTransform(&leftPlane, &leftPlane, &m);
D3DXPLANE rightPlane;
D3DXMATRIX rightTransform;
D3DXMatrixRotationY(&rightTransform, angle);
D3DXVECTOR3 rightPoint(direction.x, 0, direction.z);
D3DXVECTOR4 rightPoint2;
D3DXVec3Transform(&rightPoint2, &rightPoint, &rightTransform);
rightPoint = p1;
rightPoint.x += rightPoint2.x;
rightPoint.z += rightPoint2.z;
D3DXPlaneFromPoints(&rightPlane, &rightPoint, &p2, &p1);
D3DXPlaneNormalize(&rightPlane, &rightPlane);
D3DXPlaneTransform(&rightPlane, &rightPlane, &m);
D3DXPLANE backPlane;
D3DXVECTOR3 pb(p1.x, p1.y, p1.z);
D3DXPlaneFromPointNormal(&backPlane, &pb, &d);
D3DXPlaneNormalize(&backPlane, &backPlane);
D3DXPlaneTransform(&backPlane, &backPlane, &m);
device.SetClipPlane(0, leftPlane);
device.SetClipPlane(1, rightPlane);
device.SetClipPlane(2, backPlane);
device.SetRenderState(D3DRS_CLIPPLANEENABLE, D3DCLIPPLANE0 | D3DCLIPPLANE1 | D3DCLIPPLANE2);
}
void __fastcall TFrameDestination::bt_BrowseDirClick(TObject *Sender)
{
ecc::TBrowseForDirectory bd(PGlobals->UseNewUIOnBFD);
bd.Handle = Handle;
bd.Directory = _formattedDestDir(ed_Directory->Text);
bd.Title = _("Choose Destination Directory:");
if (bd.Execute())
{
ed_Directory->Text = IncludeTrailingPathDelimiter(bd.Directory);
GuiToProfile.setModified(true);
}
}
int main(int argc, char** argv)
{
std::string channel = "/board_scheme";
if (argc>1)
{
channel=std::string(argv[1]);
}
ros::init(argc, argv, "board_display");
ttt::BoardScheme bd(channel);
ros::spin();
return 0;
}
Plant::Plant(UniSim::Identifier name, QObject *parent)
: Model(name, parent) {
new Parameter<int>("beginDay", &beginDay, 1, this, "desc");
new Parameter<int>("beginMonth", &beginMonth, 5, this, "desc");
QString bd("bioDays");
for (int i = 0; i < NumStages; ++i)
new Parameter<double>(bd + ('A' + i) , &bioDays[i], 0., this, "desc");
new PullVariable<double>("stage", &stage, this, "desc");
new PullVariable<double>("total", &total, this, "desc");
}
void BreakpointDockWidget::on_actionAdd_Breakpoint_triggered()
{
int result;
BreakpointDialog bd(m_pBreakpoints,-1,this);
result = bd.exec();
if ( result )
{
m_pBreakpoints->AddBreakpoint(bd.getBreakpoint());
emit breakpointsChanged();
emit markProjectDirty(true);
}
}
int main( int argc, char *argv[]){
po::variables_map vm;
process_args( argc, argv, vm);
//setup some variables
std::string full_complex_name = vm[ "input-file"].as< std::string>();
std::string complex_name( full_complex_name);
std::string binary_name( argv[ 0]);
std::string base_name( full_complex_name);
std::string output_name;
size_t found = complex_name.rfind( '/');
if ( found != std::string::npos){
complex_name.replace( 0, found+1, "");
}
found = full_complex_name.rfind('.');
if ( found != std::string::npos){
base_name.replace(found,full_complex_name.length(), "");
output_name = base_name + ".phat";
}
std::ofstream out(output_name.c_str());
Complex complex;
// Read the cell_set in
ctl::read_complex( full_complex_name, complex);
Complex_filtration complex_filtration( complex);
typedef ctl::Filtration_boundary< Complex_filtration>
Filtration_boundary;
typedef Filtration_boundary::Term Filtration_term;
typedef ctl::Chain< Filtration_term> Chain;
std::cout << "Writing PHAT ASCII file To: " << output_name << std::endl;
Filtration_boundary bd( complex_filtration);
for (Complex_filtration_iterator sigma = complex_filtration.begin();
sigma != complex_filtration.end(); ++sigma){
Chain cascade_boundary;
cascade_boundary.reserve( bd.length( sigma));
for( auto i = bd.begin( sigma); i != bd.end( sigma); ++i){
cascade_boundary.emplace( i->cell(), i->coefficient());
}
cascade_boundary.sort();
out << (*sigma)->first.dimension();
for( auto term : cascade_boundary){
out << " " << term.cell();
}
out << std::endl;
}
return 0;
}
int createConstraints(const Problem<double>& P, IloEnv& env, IloModel& model, IloNumVarArray& t, IloNumVarMatrix& x, IloNumVarMatrix& y, IloNumVarMatrix& b, IloNumVarMatrix& w,const std::vector<int>& config){
try {
assert(config[1]+config[2]<=1);
std::vector<std::vector<double>> bound(2*P.nbTask-1);
std::vector<double> bd(2*P.nbTask,P.D);
createObj(P,env,model,b);//objective min b_ie
createConstraintStartBeforeEnd(P,env, model,x,y);
createConstraintOrd(P,model,t);//contrainte te < te+1
createConstraintOneStart(P,env,model,x,y);//contrai sum zie>=1
createConstraintCapacity(P,env,model,t,b);//contrainte capacity
createConstraintMinDur(P,model,t,x,y);//durée minimale
createConstraintEnergy(P,env,model,t,b,w);//contrainte Wi
createConstraintNulEnergy(P,env,model,x,y,w);
createConstraintBmax(P,model,t,b);//contrainte bmax
createConstraintNonConsump(P,model,env,x,y,b,config[3]);//bie=0 si zie=0
//additional constraints
if (config[0]) {
boundSepEvts(P,bound,config[0]);
createConstraintSepEvt(P,model,t,bound);
if (config[1])
createConstraintBmin(P,model,env,t,x,y,b,bound); //contrainte bmin
}
else if (config[1]){
boundSepEvts(P,bound,config[1]);
createConstraintBmin(P,model,env,t,x,y,b,bound); //contrainte bmin
}
else
createConstraintBmin(P,model,env,t,x,y,b,config[2]); //contrainte bmin
if (config[5])
boundEvts(P,bd);
createConstraintTimeW(P,model,t,x,y,bd);// te > ri et tf < di
if (config[4]) {
if (!config[5])
boundEvts(P,bd);
createConstraintBoundEvt(P,model,t,bd);
}
if (config[6])
createConstraintKnapsack(P,env,model,x,y);//knapsack
return 0;
}
catch (IloException& e){
std::cout << "iloexcpetion in createConstraint" << e <<std::endl;
e.end();
return 1;
}
}
std::map<int, double> IonizationEfficiencySimulator::calc_charge_distribution(const Peptide &peptide) {
std::map<int,double> charge_to_percentage;
int num_basic = 1+peptide.num_basic_residues();
boost::math::binomial bd(num_basic, .7+(g_uniform_distribution(g_rng)*.3)); // success rate in [0.7,1.0]
for (int i = 1; i <= num_basic; i++) {
charge_to_percentage[i] = boost::math::pdf(bd,i);
//std::cout << i << " " << num_basic << " " << boost::math::pdf(bd,i) << std::endl;
}
return charge_to_percentage;
}
Mat HistologicalEntities::getRBC(const std::vector<Mat>& bgr,
::cciutils::SimpleCSVLogger *logger, ::cciutils::cv::IntermediateResultHandler *iresHandler) {
CV_Assert(bgr.size() == 3);
/*
%T1=2.5; T2=2;
T1=5; T2=4;
imR2G = double(r)./(double(g)+eps);
bw1 = imR2G > T1;
bw2 = imR2G > T2;
ind = find(bw1);
if ~isempty(ind)
[rows, cols]=ind2sub(size(imR2G),ind);
rbc = bwselect(bw2,cols,rows,8) & (double(r)./(double(b)+eps)>1);
else
rbc = zeros(size(imR2G));
end
*/
std::cout.precision(5);
double T1 = 5.0;
double T2 = 4.0;
Size s = bgr[0].size();
Mat bd(s, CV_32FC1);
Mat gd(s, bd.type());
Mat rd(s, bd.type());
bgr[0].convertTo(bd, bd.type(), 1.0, FLT_EPSILON);
bgr[1].convertTo(gd, gd.type(), 1.0, FLT_EPSILON);
bgr[2].convertTo(rd, rd.type(), 1.0, 0.0);
Mat imR2G = rd / gd;
Mat imR2B = (rd / bd) > 1.0;
if (iresHandler) iresHandler->saveIntermediate(imR2G, 101);
if (iresHandler) iresHandler->saveIntermediate(imR2B, 102);
Mat bw1 = imR2G > T1;
Mat bw2 = imR2G > T2;
Mat rbc;
if (countNonZero(bw1) > 0) {
// imwrite("test/in-bwselect-marker.pgm", bw2);
// imwrite("test/in-bwselect-mask.pgm", bw1);
rbc = bwselect<unsigned char>(bw2, bw1, 8) & imR2B;
} else {
rbc = Mat::zeros(bw2.size(), bw2.type());
}
return rbc;
}
