ADB PolymerPropsAd::polymerWaterVelocityRatio(const ADB& c) const
{
const int nc = c.size();
V mc(nc);
V dmc(nc);
for (int i = 0; i < nc; ++i) {
double m = 0;
double dm = 0;
polymer_props_.computeMcWithDer(c.value()(i), m, dm);
mc(i) = m;
dmc(i) = dm;
}
ADB::M dmc_diag(dmc.matrix().asDiagonal());
const int num_blocks = c.numBlocks();
std::vector<ADB::M> jacs(num_blocks);
for (int block = 0; block < num_blocks; ++block) {
jacs[block] = dmc_diag * c.derivative()[block];
}
return ADB::function(std::move(mc), std::move(jacs));
}
GeneralMatrix* GeneralMatrix::Transpose(TransposedMatrix* tm, MatrixType mt)
{
GeneralMatrix* gm1;
if (Compare(Type().t(),mt))
{
REPORT
gm1 = mt.New(ncols,nrows,tm);
for (int i=0; i<ncols; i++)
{
MatrixRow mr(gm1, StoreOnExit+DirectPart, i);
MatrixCol mc(this, mr.Data(), LoadOnEntry, i);
}
}
else
{
REPORT
gm1 = mt.New(ncols,nrows,tm);
MatrixRow mr(this, LoadOnEntry);
MatrixCol mc(gm1, StoreOnExit+DirectPart);
int i = nrows;
while (i--) { mc.Copy(mr); mr.Next(); mc.Next(); }
}
tDelete(); gm1->ReleaseAndDelete(); return gm1;
}
double pairdist_this_work_mc(const Grid &gsigma, const Grid &density, const Grid &nA, const Grid &n3,
const Grid &nbar_sokolowski, Cartesian r0, Cartesian r1) {
const Cartesian r01 = Cartesian(r0 - r1);
const double r = sqrt(r01.dot(r01));
const double eta0 = gsigma_to_eta(gsigma(r0));
const double eta1 = gsigma_to_eta(gsigma(r1));
return (mc(eta0, r, mc_r_step, g) + mc(eta1, r, mc_r_step, g))/2;
}
int
main()
{
size_t nelem = sizeof (names) / sizeof (*names);
printf("Test vertical.\n");
mc(stdout, nelem, names, 80, false);
printf("Test horizontal.\n");
mc(stdout, nelem, names, 80, true);
return (0);
}
V PolymerPropsAd::polymerWaterVelocityRatio(const V& c) const
{
const int nc = c.size();
V mc(nc);
for (int i = 0; i < nc; ++i) {
double m = 0;
polymer_props_.computeMc(c(i), m);
mc(i) = m;
}
return mc;
}
void moduleripper (void)
{
int size;
uae_u8 *buf, *p;
size = currprefs.chipmem_size;
for (int i = 0; i < MAX_RAM_BOARDS; i++) {
size += currprefs.fastmem[i].size;
size += currprefs.z3fastmem[i].size;
}
size += currprefs.bogomem_size;
size += currprefs.mbresmem_low_size;
size += currprefs.mbresmem_high_size;
buf = p = xmalloc (uae_u8, size);
if (!buf)
return;
memcpy (p, chipmem_bank.baseaddr, currprefs.chipmem_size);
p += currprefs.chipmem_size;
for (int i = 0; i < MAX_RAM_BOARDS; i++) {
mc (p, fastmem_bank[i].start, currprefs.fastmem[i].size);
p += currprefs.fastmem[i].size;
}
mc (p, bogomem_bank.start, currprefs.bogomem_size);
p += currprefs.bogomem_size;
mc (p, a3000lmem_bank.start, currprefs.mbresmem_low_size);
p += currprefs.mbresmem_low_size;
mc (p, a3000hmem_bank.start, currprefs.mbresmem_high_size);
p += currprefs.mbresmem_high_size;
for (int i = 0; i < MAX_RAM_BOARDS; i++) {
mc (p, z3fastmem_bank[i].start, currprefs.z3fastmem[i].size);
p += currprefs.z3fastmem[i].size;
}
got = 0;
canceled = 0;
#ifdef _WIN32
__try {
#endif
prowizard_search (buf, size);
#ifdef _WIN32
} __except(ExceptionFilter (GetExceptionInformation (), GetExceptionCode ())) {
write_log (_T("prowizard scan crashed\n"));
}
#endif
if (!got)
notify_user (NUMSG_MODRIP_NOTFOUND);
else if (!canceled)
notify_user (NUMSG_MODRIP_FINISHED);
xfree (buf);
}
void
DGtal::AngleLinearMinimizerByAdaptiveStepGradientDescent::oneStep( unsigned int i1, unsigned int i2 )
{
ModuloComputer< int> mc( size() );
std::vector<double> grad ( getFormerGradient() );
double mid;
unsigned int i = i1;
do
{
unsigned int inext = mc.next( i );
ValueInfo & vi = this->rw( i );
double val = vi.oldValue;
mid = AngleComputer::cast( val - myStep*grad[ i ] );
if ( AngleComputer::less( mid, vi.min ) ) mid = vi.min;
if ( AngleComputer::less( vi.max, mid ) ) mid = vi.max;
vi.value = mid;
// go to next.
i = inext;
}
while ( i != i2 );
double E1 = getFormerEnergy( i1, i2 );
double E2 = getEnergy( i1, i2 );
if ( E1 <= E2 )
{
myStep /= 4.0;
}
else
{
/* doubling step. */
myStep *= 2.0;
}
}
ColorRectSprite::ColorRectSprite()
{
STDMaterial mat;
mat._base = STDRenderer::white;
_mat = mc().cache(mat);
}
std::vector<cv::Point2f> ShapeFilter::findMassCenter(cv::Mat img){
//getting the contours
cv::Mat canny;
std::vector<std::vector<cv::Point> > contours;
std::vector<cv::Vec4i> hierarchy;
cv::Canny(img, canny, 50, 20, 3);
cv::findContours(canny, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
double max = 0;
double area = 0;
int index = 0;
std::vector<cv::Moments> mu(contours.size() );
for(unsigned int i = 0; i < contours.size(); i++ )
{
mu[i] = cv::moments( contours[i], false );
area = cv::contourArea(contours[i]);
if (area > max){
max = area;
index = i;
}
}
// Get the mass centers:
std::vector<cv::Point2f> mc( contours.size() );
for(unsigned int i = 0; i < contours.size(); i++ )
{mc[i] = cv::Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00 );}
std::vector<cv::Point2f> result;
if (max > 0)
result.push_back(mc[index]);
return result;
}
int main(int argc, char *argv[])
{
BoundingBox bbox(vcg::Point3i(-20, -20, -20), vcg::Point3i(20, 20, 20));
vcg::Point3i resolution(40, 40, 40);
Volume volume;
Walker walker(bbox, resolution);
typedef vcg::tri::MarchingCubes<Mesh, Walker> MarchingCubes;
typedef vcg::tri::ExtendedMarchingCubes<Mesh, Walker> ExtendedMarchingCubes;
// MARCHING CUBES
Mesh mc_mesh;
printf("[MARCHING CUBES] Building mesh...");
MarchingCubes mc(mc_mesh, walker);
walker.BuildMesh<MarchingCubes>(mc_mesh, volume, mc);
vcg::tri::io::ExporterPLY<Mesh>::Save( mc_mesh, "marching_cubes.ply");
printf("OK!\n");
// EXTENDED MARCHING CUBES
Mesh emc_mesh;
printf("[EXTENDED MARCHING CUBES] Building mesh...");
ExtendedMarchingCubes emc(emc_mesh, walker, 30);
walker.BuildMesh<ExtendedMarchingCubes>(emc_mesh, volume, emc);
vcg::tri::io::ExporterPLY<Mesh>::Save( emc_mesh, "extended_marching_cubes.ply");
printf("OK!\n");
};
static void do_command(char *c)
{
char *token;
token = get_token(&c);
if(strcmp(token, "flush") == 0) flush_bridge_cache();
else if(strcmp(token, "mr") == 0) mr(get_token(&c), get_token(&c));
else if(strcmp(token, "mw") == 0) mw(get_token(&c), get_token(&c), get_token(&c));
else if(strcmp(token, "mc") == 0) mc(get_token(&c), get_token(&c), get_token(&c));
else if(strcmp(token, "crc") == 0) crc(get_token(&c), get_token(&c));
else if(strcmp(token, "ls") == 0) ls();
else if(strcmp(token, "load") == 0) load(get_token(&c), get_token(&c));
else if(strcmp(token, "serialboot") == 0) serialboot();
else if(strcmp(token, "netboot") == 0) netboot();
else if(strcmp(token, "cardboot") == 0) cardboot(0);
else if(strcmp(token, "mdior") == 0) mdior(get_token(&c));
else if(strcmp(token, "mdiow") == 0) mdiow(get_token(&c), get_token(&c));
else if(strcmp(token, "reboot") == 0) reboot();
else if(strcmp(token, "help") == 0) help();
else if(strcmp(token, "") != 0)
printf("Command not found\n");
}
void getColorTrajectory::detectTrajectory(Mat frame)
{
resized=frame;
cv::Mat hsv_image, detected;
cv::medianBlur(resized, resized, 3);//blur the image before changing to HSV
cv::cvtColor(resized, hsv_image, cv::COLOR_BGR2HSV);//change from BGR to HSV, easier to detect colors
cv::inRange(hsv_image, cv::Scalar(colorDetected.at(0), colorDetected.at(1), colorDetected.at(2)),//detect a color
cv::Scalar(colorDetected.at(3), colorDetected.at(4), colorDetected.at(5)), detected);
cv::medianBlur(detected, detected,3);//blur again
Mat canny_output;
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
RNG rng(12345);
/// Detect edges using canny
Canny( detected, canny_output, 100, 100*2, 3 );
/// Find contours
findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
/// Draw contours
Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
for( int i = 0; i< contours.size(); i++ )
{
Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() );
}
//saves the contours
findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
/// Get the moments
vector<Moments> mu(contours.size() );
if(contours.empty()==false)
{
for( int i = 0; i < contours.size(); i++ )
{ mu[i] = moments( contours[i], false ); }
/// Get the mass centers:
vector<Point2f> mc( contours.size() );
for( int i = 0; i < contours.size(); i++ )
{ mc[i] = Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00 ); }
if((mc[0].x != mc[0].x) == false)//VERY IMPORTANT!!! THIS line delete all the NaN value from the trajectory
trajectory.push_back(mc[0]);//only save one contour
}
}
void HoleRepairer::extractIsosurface()
{
std::vector<double> mcvertexs;
std::vector<double> mcnormals;
std::vector<unsigned int> mcfaces;
MarchingCubes mc(&m_distanceGrid, m_voxelSize, m_boundingBox.limits[0]);
mc.Initialize(RangValors(2*m_maxDistanceNegative, 0), 1, 0, 1, IJK(VOX_SAMPLES, VOX_SAMPLES, VOX_SAMPLES), false, false);
mc.Run(mcvertexs, mcnormals, mcfaces);
std::vector<glm::vec3> vertices;
std::vector<int> vtable;
for (unsigned int i = 0; i < mcvertexs.size(); i+= 3) {
vertices.push_back(glm::vec3(mcvertexs[i], mcvertexs[i+1], mcvertexs[i+2]));
}
for (unsigned int i = 0; i < mcfaces.size(); i++) {
vtable.push_back(mcfaces[i]);
}
m_outMesh = new TriangleMesh();
m_outMesh->setVertices(vertices, vtable);
m_outMesh->computeNormalsPerFace();
m_outMesh->computeBoundingBox();
std::cout << " verts: " << mcvertexs.size()/3 << std::endl;
std::cout << " faces: " << mcfaces.size()/3 << std::endl;
}
void CMirrorService::pushMessageToLocalQueueFromMessage( std::vector<TMessageCarrier>& msgQueue, NLNET::CMessage& msgin )
{
TMessageCarrier mc( true );
msgQueue.push_back( mc );
msgin.serial( msgQueue.back().SenderId );
msgin.serialMemStream( msgQueue.back().Msg );
}
double
DGtal::AngleLinearMinimizer::optimize( unsigned int i1, unsigned int i2 )
{
ASSERT( size() > 2 );
ModuloComputer< int> mc( size() );
unsigned int i = i1;
// (I) first pass to work on old values.
do
{
ValueInfo & vi = this->rw( i );
vi.oldValue = vi.value;
// go to next.
i = mc.next( i );
}
while ( i != i2 );
this->oneStep( i1, i2 );
mySum = 0.0;
myMax = 0.0;
i = i1;
do
{
const ValueInfo & vi = this->ro( i );
double diff = fabs( AngleComputer::deviation( vi.value, vi.oldValue ) );
if ( diff > myMax )
myMax = diff;
mySum += diff;
i = mc.next( i );
}
while ( i != i2 );
return mySum;
}
TEST(MouseControllerUnitTest, CheckConstructor)
{
Root * root = new Root;
MouseController mc(root);
EXPECT_EQ(root, mc.root_);
root->release();
}
TEST_F(MouseControllerUnitTestBase, ShiftUnexpected)
{
MouseController mc(root);
//处理意外情况 没有up直接leave
MouseEvent down1(kET_MOUSE_DOWN, kMB_LEFT, root,
Point::Make(45, 45), Point::Make(45, 45), 0);
mc.handleEvent(down1);
EXPECT_EQ(v31, mc.capture());
MouseEvent move1(kET_MOUSE_MOVE, kMB_NONE, root,
Point::Make(29, 20), Point::Make(29, 20), 0);
mc.handleEvent(move1);
EXPECT_EQ(v31, mc.capture());
MouseEvent leave1(kET_MOUSE_LEAVE, kMB_NONE, root,
Point::Make(45, 45), Point::Make(45, 45), 0);
mc.handleEvent(leave1);
EXPECT_EQ(nullptr, mc.capture());
EXPECT_EQ(nullptr, mc.over());
//当前capture 没有mouseable属性
mc.handleEvent(down1);
EXPECT_EQ(v31, mc.capture());
v31->setMouseable(false);
mc.handleEvent(move1);
EXPECT_EQ(nullptr, mc.capture());
EXPECT_EQ(v2, mc.over());
v31->setMouseable(true);
//当前capture 被remove
mc.handleEvent(down1);
EXPECT_EQ(v31, mc.capture());
v31->detachFromParent();
mc.handleEvent(move1);
EXPECT_EQ(nullptr, mc.capture());
EXPECT_EQ(v2, mc.over());
}
std::list<Instance*> Layer::getInstancesIn(Rect& rec) {
std::list<Instance*> matching_instances;
ModelCoordinate mc(rec.x, rec.y);
m_instanceTree->findInstances(mc, rec.w, rec.h, matching_instances);
return matching_instances;
}
void MethodCreator::forward_method_to(DexMethod* meth, DexMethod* smeth) {
auto code = meth->get_code();
if (code != nullptr) {
meth->set_code(nullptr);
delete code;
}
MethodCreator mc(meth);
MethodBlock* block = mc.get_main_block();
std::vector<Location> args;
auto proto = smeth->get_proto();
auto rtype = proto->get_rtype();
auto meth_args = proto->get_args();
if (meth_args != nullptr) {
uint16_t arg_count =
static_cast<uint16_t>(meth_args->get_type_list().size());
for (auto i = 0; i < arg_count; ++i) {
args.push_back(mc.get_local(i));
}
}
block->invoke(smeth, args);
if (rtype == get_void_type()) {
block->ret_void();
} else {
auto ret = mc.make_local(rtype);
block->move_result(ret, rtype);
block->ret(ret);
}
mc.create();
}
void MainWindow::createWorldActions()
{
QDir mc(m_MinecraftPath);
if (!mc.cd("saves"))
{
return;
}
QDirIterator it(mc);
int key = 1;
while (it.hasNext())
{
it.next();
if (!it.fileInfo().isDir())
{
continue;
}
QString name = getWorldName(it.filePath().toStdString());
if (name.isEmpty())
{
continue;
}
QAction * w = new QAction(this);
w->setText(name);
w->setData(it.filePath() + "/region");
if (key < 10)
{
w->setShortcut("Ctrl+" + QString::number(key));
key++;
}
connect(w, SIGNAL(triggered()), this, SLOT(openVanillaWorld()));
m_WorldActions.append(w);
}
}
// create a klass of array holding typeArrays
Klass* TypeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
int dim = dimension();
assert(dim <= n, "check order of chain");
if (dim == n)
return this;
if (higher_dimension() == NULL) {
if (or_null) return NULL;
ResourceMark rm;
JavaThread *jt = (JavaThread *)THREAD;
{
MutexLocker mc(Compile_lock, THREAD); // for vtables
// Atomic create higher dimension and link into list
MutexLocker mu(MultiArray_lock, THREAD);
if (higher_dimension() == NULL) {
Klass* oak = ObjArrayKlass::allocate_objArray_klass(
class_loader_data(), dim + 1, this, CHECK_NULL);
ObjArrayKlass* h_ak = ObjArrayKlass::cast(oak);
h_ak->set_lower_dimension(this);
OrderAccess::storestore();
set_higher_dimension(h_ak);
assert(h_ak->oop_is_objArray(), "incorrect initialization of ObjArrayKlass");
}
}
} else {
CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
}
ObjArrayKlass* h_ak = ObjArrayKlass::cast(higher_dimension());
if (or_null) {
return h_ak->array_klass_or_null(n);
}
return h_ak->array_klass(n, THREAD);
}
void PD_API MCPackSideChains( WorkSpace& wspace, Physics::Forcefield& ffs, Physics::Forcefield& ff, const Library::RotamerLibrary& rotLib )
{
// Our moveset
Manipulator::MoveSet moves( wspace );
Manipulator::SidechainRotamerLibMove* rotamer = new Manipulator::SidechainRotamerLibMove( wspace, rotLib, 1.0, 1.0 );
moves.addWithOwnership( rotamer );
// Minimise only the sidechains
Protocol::DualFFMinimiser eval(ff, ffs, PickSidechains() );
eval.SDPreMinSteps = 31;
eval.StericMinSteps = 501;
eval.Steps = 501;
eval.StepSize = 2E1;
//eval.!OutputLevel = true;
eval.UpdateScr = 50;
//eval.UpdateTra = 1;
//eval.UpdateMon = 10;
eval.run();
// Perform a montecarlo procedure
Protocol::MonteCarlo mc( eval, moves );
mc.Steps = 10;
mc.UpdateTra = 1;
mc.UpdateScr = 1;
mc.UpdateTraAcc = true;
//mc.UpdateTraRej = true;
mc.FinalState = Protocol::MonteCarlo::LowestEpot;
mc.run(); // Pack sidechains using the rotamers
}
int a2_makeTemplates(int pdgId, double metCut, double jetptCut, double ptCut, double ecaloCut, double iasCut, TString region){
sample mc("wjets");
mc.getTree(fileSR,"chiTrackspreselectionNoQCDCutsNoTrigger");
mc.getTreeVariables();
TString filename = Form("templates/IasTemplate_METGt%.0f_JetPtGt%.0f_trackPtGt%.0f_ECaloEq%.0f_pdgId%i.root",metCut,jetptCut,ptCut,ecaloCut,pdgId);
TFile *out = new TFile(filename,"RECREATE");
Double_t xbinsASmi[3] = {0,iasCut,1};
TString histoName = (TString) Form("lepton_bkg_data_Iascut_0p%02.0f",iasCut*100);
cout<<"histoName = "<<histoName<<endl;
mc.histoASmi = new TH1D(histoName, histoName, 2, xbinsASmi);
mc.histoASmi->Sumw2();
mc.Selection(1, pdgId, 0, 0 , 20., 0.0 , 0 , ecaloCut, 1, region);
cout<<"Entries: "<<mc.histoASmi->GetEntries()<<endl;
cout<<"2nd bin: "<<mc.histoASmi->GetBinContent(2)<<" +/- "<<mc.histoASmi->GetBinError(2)<<endl;
// ***** Calculate scaling factor ************************************************************************
mc.histoASmi->Scale(1./mc.histoASmi->Integral());
// ***********************************************************************************************************
out->cd();
mc.histoASmi->Write();
delete mc.histoASmi;
out->Close();
return 0;
}
int main(int argc, char** argv)
{
int (*mypt)(int) = &myfun;
int (&myref)(int) = myfun;
myclass mc(5);
// Call to function
Result<int> r0 = Thread::run(myfun, 0);
std::cout << "retval:" << r0.value() << std::endl;
// Call to function pointer
Result<int> r1 = Thread::run(mypt, 1);
std::cout << "retval:" << r1.value() << std::endl;
// Call to function reference
Result<int> r2 = Thread::run(myref, 2);
std::cout << "retval:" << r2.value() << std::endl;
// Call to functor
Result<int> r3 = Thread::run<int>(mc, 3);
std::cout << "retval:" << r3.value() << std::endl;
// Call to member function pointer
Result<int> r4 = Thread::run(&mc, &myclass::mymember, 4);
std::cout << "retval:" << r4.value() << std::endl;
return 0;
}
uint32_t XUDSMessageEndpoint::consume_part_of_message(void *buf, uint32_t count)
{
XUDSMessageEndpoint::MessageConsumer mc(buf, count, false);
zq_consume(zq, &mc);
lite_assert(mc.out_actual!=(uint32_t)-1);
return mc.out_actual;
}
void WaveformBlockFilter::
test()
{
// It should update a block with cwt transform data.
{
Timer t;
// Tfr::DrawnWaveform waveformdesc;
// Signal::Interval data = waveformdesc.requiredInterval (Signal::Interval(0,4), 0);
Signal::Interval data(0,4);
// Create some data to plot into the block
Signal::pMonoBuffer buffer(new Signal::MonoBuffer(data, data.count ()/4));
float *p = buffer->waveform_data()->getCpuMemory ();
srand(0);
for (unsigned i=0; i<buffer->getInterval ().count (); ++i) {
p[i] = -1.f + 2.f*rand()/RAND_MAX;
}
// Create a block to plot into
BlockLayout bl(4,4, buffer->sample_rate ());
VisualizationParams::ptr vp(new VisualizationParams);
Reference ref = [&]() {
Reference ref;
Position max_sample_size;
max_sample_size.time = 2.f*max(1.f, buffer->length ())/bl.texels_per_row ();
max_sample_size.scale = 1.f/bl.texels_per_column ();
ref.log2_samples_size = Reference::Scale(
floor_log2( max_sample_size.time ),
floor_log2( max_sample_size.scale ));
ref.block_index = Reference::Index(0,0);
return ref;
}();
Heightmap::pBlock block( new Heightmap::Block(ref, bl, vp));
// Create some data to plot into the block
Tfr::ChunkAndInverse cai;
cai.input = buffer;
// Do the merge
Heightmap::MergeChunk::ptr mc( new WaveformBlockFilter );
Update::IUpdateJob::ptr job = mc->prepareUpdate (cai)[0];
EXCEPTION_ASSERT(dynamic_cast<WaveformBlockUpdater::Job*>(job.get ()));
std::queue<Heightmap::Update::UpdateQueue::Job> jobs;
Heightmap::Update::UpdateQueue::Job j;
j.updatejob = job;
j.intersecting_blocks = vector<pBlock>{block};
jobs.push (std::move(j));
WaveformBlockUpdater().processJobs(jobs);
float T = t.elapsed ();
EXCEPTION_ASSERT_LESS(T, 1.0); // this is ridiculously slow
}
}
void CMirrorService::pushMessageToLocalQueue( std::vector<TMessageCarrier>& msgQueue, TServiceId senderId, NLMISC::CMemStream& msg )
{
TMessageCarrier mc( true );
msgQueue.push_back( mc );
msgQueue.back().SenderId = senderId;
msgQueue.back().Msg = msg;
//nldebug( "Received msg from %s for local %s", servStr(senderId).c_str(), servStr(destId).c_str() );
}
void mc_test ( )
/******************************************************************************/
/*
Purpose:
MC_TEST tests MC.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
18 February 2012
Author:
John Burkardt
*/
{
double *conf;
double e;
int m;
double r;
double s0;
int seed;
double sigma;
double t1;
printf ( "\n" );
printf ( "MC_TEST:\n" );
printf ( " A demonstration of the Monte Carlo method\n" );
printf ( " for option valuation.\n" );
s0 = 2.0;
e = 1.0;
r = 0.05;
sigma = 0.25;
t1 = 3.0;
m = 1000000;
seed = 123456789;
printf ( "\n" );
printf ( " The asset price at time 0, S0 = %g\n", s0 );
printf ( " The exercise price E = %g\n", e );
printf ( " The interest rate R = %g\n", r );
printf ( " The asset volatility SIGMA = %g\n", sigma );
printf ( " The expiry date T1 = %g\n", t1 );
printf ( " The number of simulations M = %d\n", m );
conf = mc ( s0, e, r, sigma, t1, m, &seed );
printf ( "\n" );
printf ( " The confidence interval is [%g,%g].\n", conf[0], conf[1] );
return;
}
XUDSMessageEndpoint::~XUDSMessageEndpoint()
{
while (!zq_is_empty(zq))
{
// drop unread messages. Should probably warn loudly when this happens.
XUDSMessageEndpoint::MessageConsumer mc(NULL, 0, true);
zq_consume(zq, &mc);
}
}
void Model::update(wxPoint point, wxBitmap set)
{
wxMemoryDC mc(*img);
mc.DrawBitmap(set,point);
mc.DrawBitmap(player->GetCurrentImage(),player->GetPosition().x,player->GetPosition().y, true);
for(int i = 0; i < monsters.size(); i++)
mc.DrawBitmap(monsters[i]->GetCurrentImage(),monsters[i]->GetPosition().x,monsters[i]->GetPosition().y, true);
//img->SaveFile("Image/Test.png", wxBITMAP_TYPE_PNG);
}
