void TileController::didRevalidateTiles() { m_boundsAtLastRevalidate = bounds(); updateTileCoverageMap(); }
IntSize TiledLayerChromium::contentBounds() const { return IntSize(lroundf(bounds().width() * contentsScale()), lroundf(bounds().height() * contentsScale())); }
// CONSTRUCTOR MyTimer(int X,int Y,int W,int H,const char*L=0) : Fl_Chart(X,Y,W,H,L) { type(FL_LINE_CHART); bounds(0,110); Fl::add_timeout(0.25, Timer_CB, (void*)this); }
void Boid3d:: update(const float amount) { // float vec[] = flock(amount);// flockfull(amount); //float * vec = flockfull(amount); // reset acc on begin 2 draw ax = 0; ay = 0; az = 0; float *vec = new float[3]; vec[0] = 0.0f; vec[1] = 0.0f; vec[2] = 0.0f; // flock(amount, vec); flockfull(amount, vec); ax += vec[0];// *amount; ay += vec[1];// *amount; az += vec[2]; delete [] vec; // change this to allow flock flock interaction // accX = vec[0]; // accY = vec[1]; // limit force float distMaxForce = ABS(ax) + ABS(ay) + ABS(az); if (distMaxForce > flockPtr->maxForce) { distMaxForce = flockPtr->maxForce / distMaxForce; ax *= distMaxForce; ay *= distMaxForce; az *= distMaxForce; } vx += ax; vy += ay; vz += az; // limit speed float distMaxSpeed = ABS(vx) + ABS(vy) + ABS(vz); if (distMaxSpeed > flockPtr->maxSpeed) { distMaxSpeed = flockPtr->maxSpeed / distMaxSpeed; vx *= distMaxSpeed; vy *= distMaxSpeed; vz *= distMaxSpeed; } x += vx * amount; y += vy * amount; z += vz * amount; bounds(); // // reset acc on end // ax = 0; // ay = 0; // az = 0; }
/* ============ idFrustum::ProjectionBounds ============ */ bool idFrustum::ProjectionBounds( const idBox &box, idBounds &projectionBounds ) const { int i, p1, p2, pointCull[8], culled, outside; float scale1, scale2; idFrustum localFrustum; idVec3 points[8], localOrigin; idMat3 localAxis, localScaled; idBounds bounds( -box.GetExtents(), box.GetExtents() ); // if the frustum origin is inside the bounds if ( bounds.ContainsPoint( ( origin - box.GetCenter() ) * box.GetAxis().Transpose() ) ) { // bounds that cover the whole frustum float boxMin, boxMax, base; base = origin * axis[0]; box.AxisProjection( axis[0], boxMin, boxMax ); projectionBounds[0].x = boxMin - base; projectionBounds[1].x = boxMax - base; projectionBounds[0].y = projectionBounds[0].z = -1.0f; projectionBounds[1].y = projectionBounds[1].z = 1.0f; return true; } projectionBounds.Clear(); // transform the bounds into the space of this frustum localOrigin = ( box.GetCenter() - origin ) * axis.Transpose(); localAxis = box.GetAxis() * axis.Transpose(); BoxToPoints( localOrigin, box.GetExtents(), localAxis, points ); // test outer four edges of the bounds culled = -1; outside = 0; for ( i = 0; i < 4; i++ ) { p1 = i; p2 = 4 + i; AddLocalLineToProjectionBoundsSetCull( points[p1], points[p2], pointCull[p1], pointCull[p2], projectionBounds ); culled &= pointCull[p1] & pointCull[p2]; outside |= pointCull[p1] | pointCull[p2]; } // if the bounds are completely outside this frustum if ( culled ) { return false; } // if the bounds are completely inside this frustum if ( !outside ) { return true; } // test the remaining edges of the bounds for ( i = 0; i < 4; i++ ) { p1 = i; p2 = (i+1)&3; AddLocalLineToProjectionBoundsUseCull( points[p1], points[p2], pointCull[p1], pointCull[p2], projectionBounds ); } for ( i = 0; i < 4; i++ ) { p1 = 4 + i; p2 = 4 + ((i+1)&3); AddLocalLineToProjectionBoundsUseCull( points[p1], points[p2], pointCull[p1], pointCull[p2], projectionBounds ); } // if the bounds extend beyond two or more boundaries of this frustum if ( outside != 1 && outside != 2 && outside != 4 && outside != 8 ) { localOrigin = ( origin - box.GetCenter() ) * box.GetAxis().Transpose(); localScaled = axis * box.GetAxis().Transpose(); localScaled[0] *= dFar; localScaled[1] *= dLeft; localScaled[2] *= dUp; // test the outer edges of this frustum for intersection with the bounds if ( (outside & 2) && (outside & 8) ) { BoundsRayIntersection( bounds, localOrigin, localScaled[0] - localScaled[1] - localScaled[2], scale1, scale2 ); if ( scale1 <= scale2 && scale1 >= 0.0f ) { projectionBounds.AddPoint( idVec3( scale1 * dFar, -1.0f, -1.0f ) ); projectionBounds.AddPoint( idVec3( scale2 * dFar, -1.0f, -1.0f ) ); } } if ( (outside & 2) && (outside & 4) ) { BoundsRayIntersection( bounds, localOrigin, localScaled[0] - localScaled[1] + localScaled[2], scale1, scale2 ); if ( scale1 <= scale2 && scale1 >= 0.0f ) { projectionBounds.AddPoint( idVec3( scale1 * dFar, -1.0f, 1.0f ) ); projectionBounds.AddPoint( idVec3( scale2 * dFar, -1.0f, 1.0f ) ); } } if ( (outside & 1) && (outside & 8) ) { BoundsRayIntersection( bounds, localOrigin, localScaled[0] + localScaled[1] - localScaled[2], scale1, scale2 ); if ( scale1 <= scale2 && scale1 >= 0.0f ) { projectionBounds.AddPoint( idVec3( scale1 * dFar, 1.0f, -1.0f ) ); projectionBounds.AddPoint( idVec3( scale2 * dFar, 1.0f, -1.0f ) ); } } if ( (outside & 1) && (outside & 2) ) { BoundsRayIntersection( bounds, localOrigin, localScaled[0] + localScaled[1] + localScaled[2], scale1, scale2 ); if ( scale1 <= scale2 && scale1 >= 0.0f ) { projectionBounds.AddPoint( idVec3( scale1 * dFar, 1.0f, 1.0f ) ); projectionBounds.AddPoint( idVec3( scale2 * dFar, 1.0f, 1.0f ) ); } } } return true; }
char num_to_digit_equiv(int ost) { if (bounds(ost, 0, 9)) return ost + '0'; else if (bounds(ost, 10, 15)) return ost - 10 + 'a'; }
void EditorToolbar::HandleSFEvents(std::list<sf::Event>& sfEvents) { bool mouseOverPressed = false; std::list<sf::Event>::iterator itSfEvent = sfEvents.begin(); while (itSfEvent != sfEvents.end()) { switch (itSfEvent->Type) { case sf::Event::MouseMoved: { sf::Vector2f screenSize(background->GetScreenSize()); sf::Vector2f fakePos(background->CalcFakePos()); sf::Rect<float> bounds(fakePos.x - (screenSize.x / 2), fakePos.y - (screenSize.y / 2), fakePos.x + (screenSize.x / 2), fakePos.y + (screenSize.y / 2 )); hover = bounds.Contains(itSfEvent->MouseMove.X, itSfEvent->MouseMove.Y) ? true : false; if (dragging) { float before = toolViewOffsetY; toolViewOffsetY += (itSfEvent->MouseMove.Y - lastMousePressedY); CalcViewOffsetY(); lastMousePressedY += toolViewOffsetY - before; /* mouse leaving window messes up values on _WINDOWS_ * so this still does not solve anything :/ * */ // if (!Game->GetRenderWindow()->GetInput().IsMouseButtonDown(sf::Mouse::Left)) // dragging = false; } } break; case sf::Event::MouseWheelMoved: if (hover && !tools.empty()) { toolViewOffsetY += Game->GetDeltaTime() * WHEELSCROLLSPD * itSfEvent->MouseWheel.Delta; CalcViewOffsetY(); } break; case sf::Event::MouseButtonPressed: if (hover) { if (!tools.empty()) { if (itSfEvent->MouseButton.Button == sf::Mouse::Left) { lastMousePressedY = itSfEvent->MouseButton.Y; dragging = true; } } mouseOverPressed = true; } break; case sf::Event::MouseButtonReleased: dragging = false; break; case sf::Event::Resized: CalcViewOffsetY(); break; default: break; } itSfEvent++; } toolEventID = -2; for (std::vector<EditorToolButton*>::iterator itTool = tools.begin(); itTool != tools.end(); itTool++) { (*itTool)->HandleSFEvents(sfEvents); } if (toolEventID != -2) { for (std::vector<EditorToolButton*>::iterator itTool = tools.begin(); itTool != tools.end(); itTool++) { if ((*itTool)->GetID() != toolEventID) { (*itTool)->SetActive(false); } } toolSelected(toolEventID); activeID = toolEventID; if (toolEventID == -1 && mouseOverPressed) { // if no tool was activated - the event wasn't eaten // but the mouse pressed over the toolbar // then eat it still itSfEvent = sfEvents.begin(); while (itSfEvent != sfEvents.end()) { switch (itSfEvent->Type) { case sf::Event::MouseButtonPressed: itSfEvent = --sfEvents.erase(itSfEvent); break; default: break; } itSfEvent++; } } } }
ProjectWindow::ProjectWindow(BRect frame, Project *project) : DWindow(frame, "Paladin", B_DOCUMENT_WINDOW, B_NOT_ZOOMABLE | B_WILL_ACCEPT_FIRST_CLICK), fErrorWindow(NULL), fFilePanel(NULL), fProject(project), fSourceControl(NULL), fShowingLibs(false), fMenusLocked(false), fBuilder(BMessenger(this)) { AddCommonFilter(new AltTabFilter()); SetSizeLimits(200,30000,200,30000); RegisterWindow(); // This is for our in-program debug menu which comes in handy now and then. // Paladin -d doesn't always get the job done AddShortcut('9', B_COMMAND_KEY | B_SHIFT_KEY | B_CONTROL_KEY, new BMessage(M_TOGGLE_DEBUG_MENU)); if (fProject) { fSourceControl = GetSCM(fProject->SourceControl()); if (fSourceControl) { if (gPrintDebugMode > 0) fSourceControl->SetDebugMode(true); fSourceControl->SetUpdateCallback(SCMOutputCallback); fSourceControl->SetWorkingDirectory(fProject->GetPath().GetFolder()); if (fSourceControl->NeedsInit(fProject->GetPath().GetFolder())) fSourceControl->CreateRepository(fProject->GetPath().GetFolder()); } } BView *top = GetBackgroundView(); BRect bounds(Bounds()); BRect r(bounds); r.bottom = 16; fMenuBar = new BMenuBar(r,"documentbar"); top->AddChild(fMenuBar); r = bounds; r.top = fMenuBar->Frame().bottom + 1; r.right -= B_V_SCROLL_BAR_WIDTH; r.bottom -= B_H_SCROLL_BAR_HEIGHT; fProjectList = new ProjectList(fProject, r,"filelist",B_FOLLOW_ALL); fProjectList->SetInvocationMessage(new BMessage(M_EDIT_FILE)); BScrollView *scrollView = new BScrollView("scrollView",fProjectList, B_FOLLOW_ALL,0,false,true); top->AddChild(scrollView); fProjectList->SetTarget(this); r.top = r.bottom + 1; r.bottom = Bounds().bottom; fStatusBar = new BStringView(r,"statusbar", NULL, B_FOLLOW_LEFT_RIGHT | B_FOLLOW_BOTTOM); top->AddChild(fStatusBar); fStatusBar->SetViewColor(235,235,235); fStatusBar->SetFontSize(10.0); SetupMenus(); if (project) { BString title("Paladin: "); title << project->GetName(); SetTitle(title.String()); for (int32 i = 0; i < project->CountGroups(); i++) { SourceGroup *group = project->GroupAt(i); SourceGroupItem *groupitem = new SourceGroupItem(group); fProjectList->AddItem(groupitem); groupitem->SetExpanded(group->expanded); for (int32 j = 0; j < group->filelist.CountItems(); j++) { SourceFile *file = group->filelist.ItemAt(j); SourceFileItem *fileitem = new SourceFileItem(file,1); // fProjectList->AddUnder(fileitem,groupitem); fProjectList->AddItem(fileitem); BString abspath = file->GetPath().GetFullPath(); if (abspath[0] != '/') { abspath.Prepend("/"); abspath.Prepend(project->GetPath().GetFolder()); } BEntry entry(abspath.String()); if (entry.Exists()) { if (project->CheckNeedsBuild(file,false)) { fileitem->SetDisplayState(SFITEM_NEEDS_BUILD); fProjectList->InvalidateItem(fProjectList->IndexOf(fileitem)); } else file->SetBuildFlag(BUILD_NO); } else { fileitem->SetDisplayState(SFITEM_MISSING); fProjectList->InvalidateItem(fProjectList->IndexOf(fileitem)); } } } } BNode node(fProject->GetPath().GetFullPath()); if (node.ReadAttr("project_frame",B_RECT_TYPE,0,&r,sizeof(BRect)) == sizeof(BRect)) { if (r.Width() < 200) r.right = r.left + 200; if (r.Height() < 200) r.top = r.bottom + 200; MoveTo(r.left,r.top); ResizeTo(r.Width(),r.Height()); } fProjectList->MakeFocus(true); if (gShowFolderOnOpen) { // Duplicated code from MessageReceived::M_SHOW_PROJECT_FOLDER. Doing // it here in combo with snooze() makes it much more likely that the // opened project window is frontmost instead of the project folder's window entry_ref ref; BEntry(fProject->GetPath().GetFolder()).GetRef(&ref); BMessenger msgr("application/x-vnd.Be-TRAK"); BMessage reply; BMessage openmsg(B_REFS_RECEIVED); openmsg.AddRef("refs",&ref); msgr.SendMessage(&openmsg); snooze(50000); } if (gAutoSyncModules) PostMessage(M_SYNC_MODULES); }
void TextField::ContentView::setBackgroundColor(KDColor backgroundColor) { m_backgroundColor = backgroundColor; markRectAsDirty(bounds()); }
void PageOverlay::setNeedsDisplay() { setNeedsDisplay(bounds()); }
void PopUpController::ContentView::drawRect(KDContext * ctx, KDRect rect) const { ctx->fillRect(bounds(), KDColorBlack); }
Bounds line_bounds(const Vector2D& origin, const Matrix2D& m, const Vector2D& p1, const Vector2D& p2) { Bounds bounds(origin + p1 * m); bounds.update(origin + p2 * m); return bounds; }
/** * Try the direct path. * @return True if we took the direct path */ PRBool gfxXlibNativeRenderer::DrawDirect(gfxContext *ctx, nsIntSize size, PRUint32 flags, Screen *screen, Visual *visual) { cairo_t *cr = ctx->GetCairo(); /* Check that the target surface is an xlib surface. */ cairo_surface_t *target = cairo_get_group_target (cr); if (cairo_surface_get_type (target) != CAIRO_SURFACE_TYPE_XLIB) { NATIVE_DRAWING_NOTE("FALLBACK: non-X surface"); return PR_FALSE; } cairo_matrix_t matrix; cairo_get_matrix (cr, &matrix); double device_offset_x, device_offset_y; cairo_surface_get_device_offset (target, &device_offset_x, &device_offset_y); /* Draw() checked that the matrix contained only a very-close-to-integer translation. Here (and in several other places and thebes) device offsets are assumed to be integer. */ NS_ASSERTION(PRInt32(device_offset_x) == device_offset_x && PRInt32(device_offset_y) == device_offset_y, "Expected integer device offsets"); nsIntPoint offset(NS_lroundf(matrix.x0 + device_offset_x), NS_lroundf(matrix.y0 + device_offset_y)); int max_rectangles = 0; if (flags & DRAW_SUPPORTS_CLIP_RECT) { max_rectangles = 1; } if (flags & DRAW_SUPPORTS_CLIP_LIST) { max_rectangles = MAX_STATIC_CLIP_RECTANGLES; } /* The client won't draw outside the surface so consider this when analysing clip rectangles. */ nsIntRect bounds(offset, size); bounds.IntersectRect(bounds, nsIntRect(0, 0, cairo_xlib_surface_get_width(target), cairo_xlib_surface_get_height(target))); PRBool needs_clip = PR_TRUE; nsIntRect rectangles[MAX_STATIC_CLIP_RECTANGLES]; int rect_count = 0; /* Check that the clip is rectangular and aligned on unit boundaries. */ /* Temporarily set the matrix for _get_rectangular_clip. It's basically the identity matrix, but we must adjust for the fact that our offset-rect is in device coordinates. */ cairo_identity_matrix (cr); cairo_translate (cr, -device_offset_x, -device_offset_y); PRBool have_rectangular_clip = _get_rectangular_clip (cr, bounds, &needs_clip, rectangles, max_rectangles, &rect_count); cairo_set_matrix (cr, &matrix); if (!have_rectangular_clip) return PR_FALSE; /* Stop now if everything is clipped out */ if (needs_clip && rect_count == 0) return PR_TRUE; /* Check that the screen is supported. Visuals belong to screens, so, if alternate visuals are not supported, then alternate screens cannot be supported. */ PRBool supports_alternate_visual = (flags & DRAW_SUPPORTS_ALTERNATE_VISUAL) != 0; PRBool supports_alternate_screen = supports_alternate_visual && (flags & DRAW_SUPPORTS_ALTERNATE_SCREEN); if (!supports_alternate_screen && cairo_xlib_surface_get_screen (target) != screen) { NATIVE_DRAWING_NOTE("FALLBACK: non-default screen"); return PR_FALSE; } /* Check that there is a visual */ Visual *target_visual = cairo_xlib_surface_get_visual (target); if (!target_visual) { NATIVE_DRAWING_NOTE("FALLBACK: no Visual for surface"); return PR_FALSE; } /* Check that the visual is supported */ if (!supports_alternate_visual && target_visual != visual) { // Only the format of the visual is important (not the GLX properties) // for Xlib or XRender drawing. XRenderPictFormat *target_format = cairo_xlib_surface_get_xrender_format (target); if (!target_format || (target_format != XRenderFindVisualFormat (DisplayOfScreen(screen), visual))) { NATIVE_DRAWING_NOTE("FALLBACK: unsupported Visual"); return PR_FALSE; } } /* we're good to go! */ NATIVE_DRAWING_NOTE("TAKING FAST PATH\n"); cairo_surface_flush (target); nsRefPtr<gfxASurface> surface = gfxASurface::Wrap(target); nsresult rv = DrawWithXlib(static_cast<gfxXlibSurface*>(surface.get()), offset, rectangles, needs_clip ? rect_count : 0); if (NS_SUCCEEDED(rv)) { cairo_surface_mark_dirty (target); return PR_TRUE; } return PR_FALSE; }
bool WKCACFLayerRenderer::createRenderer() { if (m_d3dDevice || !m_mightBeAbleToCreateDeviceLater) return m_d3dDevice; m_mightBeAbleToCreateDeviceLater = false; D3DPRESENT_PARAMETERS parameters = initialPresentationParameters(); if (!d3d() || !::IsWindow(m_hostWindow)) return false; // D3D doesn't like to make back buffers for 0 size windows. We skirt this problem if we make the // passed backbuffer width and height non-zero. The window will necessarily get set to a non-zero // size eventually, and then the backbuffer size will get reset. RECT rect; GetClientRect(m_hostWindow, &rect); if (rect.left-rect.right == 0 || rect.bottom-rect.top == 0) { parameters.BackBufferWidth = 1; parameters.BackBufferHeight = 1; } D3DCAPS9 d3dCaps; if (FAILED(d3d()->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dCaps))) return false; DWORD behaviorFlags = D3DCREATE_FPU_PRESERVE; if ((d3dCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) && d3dCaps.VertexProcessingCaps) behaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING; else behaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING; COMPtr<IDirect3DDevice9> device; if (FAILED(d3d()->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_hostWindow, behaviorFlags, ¶meters, &device))) { // In certain situations (e.g., shortly after waking from sleep), Direct3DCreate9() will // return an IDirect3D9 for which IDirect3D9::CreateDevice will always fail. In case we // have one of these bad IDirect3D9s, get rid of it so we'll fetch a new one the next time // we want to call CreateDevice. s_d3d->Release(); s_d3d = 0; // Even if we don't have a bad IDirect3D9, in certain situations (e.g., shortly after // waking from sleep), CreateDevice will fail, but will later succeed if called again. m_mightBeAbleToCreateDeviceLater = true; return false; } // Now that we've created the IDirect3DDevice9 based on the capabilities we // got from the IDirect3D9 global object, we requery the device for its // actual capabilities. The capabilities returned by the device can // sometimes be more complete, for example when using software vertex // processing. D3DCAPS9 deviceCaps; if (FAILED(device->GetDeviceCaps(&deviceCaps))) return false; if (!hardwareCapabilitiesIndicateCoreAnimationSupport(deviceCaps)) return false; m_d3dDevice = device; D3DXMATRIXA16 projection; D3DXMatrixOrthoOffCenterRH(&projection, rect.left, rect.right, rect.top, rect.bottom, -1.0f, 1.0f); m_d3dDevice->SetTransform(D3DTS_PROJECTION, &projection); m_renderer = CARenderOGLNew(&kCARenderDX9Callbacks, m_d3dDevice.get(), 0); if (IsWindow(m_hostWindow)) m_rootLayer->setBounds(bounds()); return true; }
void ShowImageWindow::_Print(BMessage* msg) { status_t st; if (msg->FindInt32("status", &st) != B_OK || st != B_OK) return; _SavePrintOptions(); BPrintJob printJob(fImageView->Image()->name); if (fPrintSettings) printJob.SetSettings(new BMessage(*fPrintSettings)); if (printJob.ConfigJob() == B_OK) { delete fPrintSettings; fPrintSettings = printJob.Settings(); // first/lastPage is unused for now int32 firstPage = printJob.FirstPage(); int32 lastPage = printJob.LastPage(); BRect printableRect = printJob.PrintableRect(); if (firstPage < 1) firstPage = 1; if (lastPage < firstPage) lastPage = firstPage; BBitmap* bitmap = fImageView->Bitmap(); float imageWidth = bitmap->Bounds().Width() + 1.0; float imageHeight = bitmap->Bounds().Height() + 1.0; float width; switch (fPrintOptions.Option()) { case PrintOptions::kFitToPage: { float w1 = printableRect.Width() + 1; float w2 = imageWidth * (printableRect.Height() + 1) / imageHeight; if (w2 < w1) width = w2; else width = w1; } break; case PrintOptions::kZoomFactor: width = imageWidth * fPrintOptions.ZoomFactor(); break; case PrintOptions::kDPI: width = imageWidth * 72.0 / fPrintOptions.DPI(); break; case PrintOptions::kWidth: case PrintOptions::kHeight: width = fPrintOptions.Width(); break; default: // keep compiler silent; should not reach here width = imageWidth; } // TODO: eventually print large images on several pages printJob.BeginJob(); fImageView->SetScale(width / imageWidth); // coordinates are relative to printable rectangle BRect bounds(bitmap->Bounds()); printJob.DrawView(fImageView, bounds, BPoint(0, 0)); fImageView->SetScale(1.0); printJob.SpoolPage(); printJob.CommitJob(); } }
void TextField::ContentView::setTextColor(KDColor textColor) { m_textColor = textColor; markRectAsDirty(bounds()); }
int main(int argc, char* argv[]) { Teuchos::GlobalMPISession mpiSession(&argc, &argv); // This little trick lets us print to std::cout only if a (dummy) command-line argument is provided. int iprint = argc - 1; Teuchos::RCP<std::ostream> outStream; Teuchos::oblackholestream bhs; // outputs nothing if (iprint > 0) outStream = Teuchos::rcp(&std::cout, false); else outStream = Teuchos::rcp(&bhs, false); int errorFlag = 0; try { /**********************************************************************************************/ /************************* CONSTRUCT ROL ALGORITHM ********************************************/ /**********************************************************************************************/ // Get ROL parameterlist std::string filename = "input_01.xml"; Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() ); Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() ); Teuchos::ParameterList list = *parlist; /**********************************************************************************************/ /************************* CONSTRUCT SOL COMPONENTS *******************************************/ /**********************************************************************************************/ // Build vectors unsigned dim = 4; Teuchos::RCP<std::vector<RealT> > x_rcp = Teuchos::rcp( new std::vector<RealT>(dim,0.0) ); Teuchos::RCP<ROL::Vector<RealT> > x = Teuchos::rcp(new ROL::StdVector<RealT>(x_rcp)); Teuchos::RCP<std::vector<RealT> > d_rcp = Teuchos::rcp( new std::vector<RealT>(dim,0.0) ); Teuchos::RCP<ROL::Vector<RealT> > d = Teuchos::rcp(new ROL::StdVector<RealT>(d_rcp)); setRandomVector(*d_rcp); // Build samplers int nSamp = 1000; unsigned sdim = dim + 2; std::vector<RealT> tmp(2,0.); tmp[0] = -1.; tmp[1] = 1.; std::vector<std::vector<RealT> > bounds(sdim,tmp); Teuchos::RCP<ROL::BatchManager<RealT> > bman = Teuchos::rcp(new ROL::BatchManager<RealT>()); Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler = Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(nSamp,bounds,bman,false,false,100)); // Build risk-averse objective function Teuchos::RCP<ROL::ParametrizedObjective<RealT> > pObj = Teuchos::rcp(new ParametrizedObjectiveEx1<RealT>); // Build bound constraints std::vector<RealT> l(dim,0.0); std::vector<RealT> u(dim,1.0); Teuchos::RCP<ROL::BoundConstraint<RealT> > bnd = Teuchos::rcp( new ROL::StdBoundConstraint<RealT>(l,u) ); bnd->deactivate(); // Test parametrized objective functions *outStream << "Check Derivatives of Parametrized Objective Function\n"; pObj->setParameter(sampler->getMyPoint(0)); pObj->checkGradient(*x,*d,true,*outStream); pObj->checkHessVec(*x,*d,true,*outStream); /**********************************************************************************************/ /************************* MEAN VALUE *********************************************************/ /**********************************************************************************************/ *outStream << "\nMEAN VALUE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Mean Value"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* RISK NEUTRAL *******************************************************/ /**********************************************************************************************/ *outStream << "\nRISK NEUTRAL\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Neutral"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS DEVIATION ************************************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS DEVIATION\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation"); list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation").set("Deviation Type","Absolute"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS VARIANCE *************************************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS VARIANCE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance"); list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance").set("Deviation Type","Absolute"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS DEVIATION FROM TARGET ************************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS DEVIATION FROM TARGET\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation From Target"); list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation From Target").set("Deviation Type","Absolute"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS VARIANCE FROM TARGET *************************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS VARIANCE FROM TARGET\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance From Target"); list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance From Target").set("Deviation Type","Absolute"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS SEMIDEVIATION ********************************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS SEMIDEVIATION\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation"); list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation").set("Deviation Type","Upper"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS SEMIVARIANCE *********************************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS SEMIVARIANCE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance"); list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance").set("Deviation Type","Upper"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS SEMIDEVIATION FROM TARGET ********************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS SEMIDEVIATION FROM TARGET\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation From Target"); list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation From Target").set("Deviation Type","Upper"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS SEMIVARIANCE FROM TARGET *********************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS SEMIVARIANCE FROM TARGET\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance From Target"); list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance From Target").set("Deviation Type","Upper"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS CVAR *****************************************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS CONDITIONAL VALUE AT RISK\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","CVaR"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS HMCR *****************************************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS HIGHER MOMENT COHERENT RISK\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","HMCR"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* SMOOTHED CVAR QUADRANGLE *******************************************/ /**********************************************************************************************/ *outStream << "\nQUANTILE-BASED QUADRANGLE RISK MEASURE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Quantile-Based Quadrangle"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MIXED-QUANTILE QUADRANGLE ******************************************/ /**********************************************************************************************/ *outStream << "\nMIXED-QUANTILE QUADRANGLE RISK MEASURE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Mixed-Quantile Quadrangle"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* SUPER QUANTILE QUADRANGLE ******************************************/ /**********************************************************************************************/ *outStream << "\nSUPER QUANTILE QUADRANGLE RISK MEASURE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Super Quantile Quadrangle"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* CHEBYSHEV 1 KUSUOKA ************************************************/ /**********************************************************************************************/ *outStream << "\nCHEBYSHEV 1 KUSUOKA RISK MEASURE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Chebyshev-Kusuoka"); list.sublist("SOL").sublist("Risk Measure").sublist("Chebyshev-Kusuoka").set("Weight Type",1); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* CHEBYSHEV 2 KUSUOKA ************************************************/ /**********************************************************************************************/ *outStream << "\nCHEBYSHEV 2 KUSUOKA RISK MEASURE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Chebyshev-Kusuoka"); list.sublist("SOL").sublist("Risk Measure").sublist("Chebyshev-Kusuoka").set("Weight Type",2); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* CHEBYSHEV 3 KUSUOKA ************************************************/ /**********************************************************************************************/ *outStream << "\nCHEBYSHEV 3 KUSUOKA RISK MEASURE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Chebyshev-Kusuoka"); list.sublist("SOL").sublist("Risk Measure").sublist("Chebyshev-Kusuoka").set("Weight Type",3); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* CHEBYSHEV 3 KUSUOKA ************************************************/ /**********************************************************************************************/ *outStream << "\nSINGLETON KUSUOKA RISK MEASURE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Singleton Kusuoka"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* MEAN-VARIANCE QUADRANGLE *******************************************/ /**********************************************************************************************/ *outStream << "\nMEAN-VARIANCE QUADRANGLE RISK MEASURE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Mean-Variance Quadrangle"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* QUANTILE-RANGE QUADRANGLE ******************************************/ /**********************************************************************************************/ *outStream << "\nQUANTILE-RADIUS QUADRANGLE RISK MEASURE\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Quantile-Radius Quadrangle"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* CHI-SQUARED DIVERGENCE *********************************************/ /**********************************************************************************************/ *outStream << "\nCHI-SQUARED DIVERGENCE DISTRIBUTIONALLY ROBUST\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Chi-Squared Divergence"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* KL DIVERGENCE ******************************************************/ /**********************************************************************************************/ *outStream << "\nKL DIVERGENCE DISTRIBUTIONALLY ROBUST\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","KL Divergence"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* COHERENT EXPONENTIAL UTILITY FUNCTION ******************************/ /**********************************************************************************************/ *outStream << "\nCOHERENT EXPONENTIAL UTILITY FUNCTION\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Coherent Exponential Utility"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* EXPONENTIAL UTILITY FUNCTION ***************************************/ /**********************************************************************************************/ *outStream << "\nEXPONENTIAL UTILITY FUNCTION\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Exponential Utility"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); /**********************************************************************************************/ /************************* CONVEX COMBINATION OF RISK MEASURES ********************************/ /**********************************************************************************************/ *outStream << "\nCONVEX COMBINATION OF RISK MEASURES\n"; list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse"); list.sublist("SOL").sublist("Risk Measure").set("Name","Convex Combination Risk Measure"); setRandomVector(*x_rcp); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); } catch (std::logic_error err) { *outStream << err.what() << "\n"; errorFlag = -1000; }; // end try if (errorFlag != 0) std::cout << "End Result: TEST FAILED\n"; else std::cout << "End Result: TEST PASSED\n"; return 0; }
void TextField::ContentView::setAlignment(float horizontalAlignment, float verticalAlignment) { m_horizontalAlignment = horizontalAlignment; m_verticalAlignment = verticalAlignment; markRectAsDirty(bounds()); }
/* * Allocate I/O arrays for a problem. * * This is the default routine that can be overridden by the user in * complicated cases. */ void problem_alloc(bench_problem *p) { int ilb, iub, olb, oub; int isz, osz; bounds(p, &ilb, &iub, &olb, &oub); isz = iub - ilb; osz = oub - olb; if (p->kind == PROBLEM_COMPLEX) { bench_complex *in, *out; p->iphyssz = isz; p->inphys = in = (bench_complex *) bench_malloc(isz * sizeof(bench_complex)); p->in = in - ilb; if (p->in_place) { p->out = p->in; p->outphys = p->inphys; p->ophyssz = p->iphyssz; } else { p->ophyssz = osz; p->outphys = out = (bench_complex *) bench_malloc(osz * sizeof(bench_complex)); p->out = out - olb; } } else if (p->kind == PROBLEM_R2R) { bench_real *in, *out; p->iphyssz = isz; p->inphys = in = (bench_real *) bench_malloc(isz * sizeof(bench_real)); p->in = in - ilb; if (p->in_place) { p->out = p->in; p->outphys = p->inphys; p->ophyssz = p->iphyssz; } else { p->ophyssz = osz; p->outphys = out = (bench_real *) bench_malloc(osz * sizeof(bench_real)); p->out = out - olb; } } else if (p->kind == PROBLEM_REAL && p->sign < 0) { /* R2HC */ bench_real *in; bench_complex *out; p->iphyssz = p->in_place ? (isz > osz*2 ? isz : osz*2) : isz; p->inphys = in = (bench_real *) bench_malloc(p->iphyssz * sizeof(bench_real)); p->in = in - ilb; if (p->in_place) { p->out = p->in; p->outphys = p->inphys; p->ophyssz = p->iphyssz / 2; } else { p->ophyssz = osz; p->outphys = out = (bench_complex *) bench_malloc(osz * sizeof(bench_complex)); p->out = out - olb; } } else if (p->kind == PROBLEM_REAL && p->sign > 0) { /* HC2R */ bench_real *out; bench_complex *in; p->ophyssz = p->in_place ? (osz > isz*2 ? osz : isz*2) : osz; p->outphys = out = (bench_real *) bench_malloc(p->ophyssz * sizeof(bench_real)); p->out = out - olb; if (p->in_place) { p->in = p->out; p->inphys = p->outphys; p->iphyssz = p->ophyssz / 2; } else { p->iphyssz = isz; p->inphys = in = (bench_complex *) bench_malloc(isz * sizeof(bench_complex)); p->in = in - ilb; } } else { BENCH_ASSERT(0); /* TODO */ } }
int main(int argc, char* argv[]) { Teuchos::GlobalMPISession mpiSession(&argc, &argv); Teuchos::RCP<const Teuchos::Comm<int> > commptr = Teuchos::DefaultComm<int>::getComm(); // This little trick lets us print to std::cout only if a (dummy) command-line argument is provided. int iprint = argc - 1; Teuchos::RCP<std::ostream> outStream; Teuchos::oblackholestream bhs; // outputs nothing if (iprint > 0 && commptr->getRank()==0) outStream = Teuchos::rcp(&std::cout, false); else outStream = Teuchos::rcp(&bhs, false); int errorFlag = 0; try { /**********************************************************************************************/ /************************* CONSTRUCT ROL ALGORITHM ********************************************/ /**********************************************************************************************/ // Get ROL parameterlist std::string filename = "input_07.xml"; Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() ); Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() ); Teuchos::ParameterList list = *parlist; // Build ROL algorithm Teuchos::RCP<ROL::Algorithm<RealT> > algo; /**********************************************************************************************/ /************************* CONSTRUCT SOL COMPONENTS *******************************************/ /**********************************************************************************************/ // Build vectors const unsigned dim = 4; Teuchos::RCP<std::vector<RealT> > x_rcp = Teuchos::rcp(new std::vector<RealT>(dim)); Teuchos::RCP<std::vector<RealT> > d_rcp = Teuchos::rcp(new std::vector<RealT>(dim)); Teuchos::RCP<ROL::Vector<RealT> > x = Teuchos::rcp(new ROL::StdVector<RealT>(x_rcp)); Teuchos::RCP<ROL::Vector<RealT> > d = Teuchos::rcp(new ROL::StdVector<RealT>(d_rcp)); setRandomVector(*x_rcp,commptr); setRandomVector(*d_rcp,commptr); // Build samplers const RealT zero(0), one(1); const int nSamp = 1000; const unsigned sdim = dim + 2; std::vector<RealT> tmp = {-one, one}; std::vector<std::vector<RealT> > bounds(sdim,tmp); Teuchos::RCP<ROL::BatchManager<RealT> > bman = Teuchos::rcp(new ROL::StdTeuchosBatchManager<RealT,int>(commptr)); Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler = Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(nSamp,bounds,bman,false,false,100)); // Build risk-averse objective function Teuchos::RCP<ROL::ParametrizedObjective<RealT> > pObj = Teuchos::rcp(new ParametrizedObjectiveEx7<RealT>); // Build bound constraints std::vector<RealT> l(dim,zero); std::vector<RealT> u(dim,one); Teuchos::RCP<ROL::BoundConstraint<RealT> > bnd = Teuchos::rcp( new ROL::StdBoundConstraint<RealT>(l,u) ); bnd->deactivate(); // Test parametrized objective functions *outStream << "Check Derivatives of Parametrized Objective Function\n"; pObj->setParameter(sampler->getMyPoint(0)); pObj->checkGradient(*x,*d,true,*outStream); pObj->checkHessVec(*x,*d,true,*outStream); /**********************************************************************************************/ /************************* MEAN PLUS HMCR *****************************************************/ /**********************************************************************************************/ *outStream << "\nMEAN PLUS HIGHER MOMENT COHERENT RISK MEASURE\n"; setRandomVector(*x_rcp,commptr); setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream); printSolution(*x_rcp,*outStream); } catch (std::logic_error err) { *outStream << err.what() << "\n"; errorFlag = -1000; }; // end try if (errorFlag != 0) std::cout << "End Result: TEST FAILED\n"; else std::cout << "End Result: TEST PASSED\n"; return 0; }
// Return the convex hull of two points; the smallest bounds that contains both. static LatLngBounds hull(const LatLng& a, const LatLng& b) { LatLngBounds bounds(a, a); bounds.extend(b); return bounds; }
void CComPropertySheet::OnActivated(CPropertyPage* pPage) { if(!pPage) return; CRect bounds(30000,30000,-30000,-30000); CRect wr, cr; GetWindowRect(wr); GetClientRect(cr); CSize ws = wr.Size(), cs = cr.Size(); CRect twr, tcr; CTabCtrl* pTC = (CTabCtrl*)GetDlgItem(AFX_IDC_TAB_CONTROL); pTC->GetWindowRect(twr); pTC->GetClientRect(tcr); CSize tws = twr.Size(), tcs = tcr.Size(); if(CWnd* pChild = pPage->GetWindow(GW_CHILD)) { pChild->ModifyStyle(WS_CAPTION|WS_THICKFRAME, 0); pChild->ModifyStyleEx(WS_EX_DLGMODALFRAME, WS_EX_CONTROLPARENT); for(CWnd* pGrandChild = pChild->GetWindow(GW_CHILD); pGrandChild; pGrandChild = pGrandChild->GetNextWindow()) { if(!(pGrandChild->GetStyle()&WS_VISIBLE)) continue; CRect r; pGrandChild->GetWindowRect(&r); pChild->ScreenToClient(r); bounds |= r; } } bounds |= CRect(0,0,0,0); bounds.SetRect(0, 0, bounds.right + max(bounds.left, 4), bounds.bottom + max(bounds.top, 4)); CRect r = CRect(CPoint(0,0), bounds.Size()); pTC->AdjustRect(TRUE, r); r.SetRect(twr.TopLeft(), twr.TopLeft() + r.Size()); ScreenToClient(r); pTC->MoveWindow(r); pTC->ModifyStyle(TCS_MULTILINE, TCS_SINGLELINE); CSize diff = r.Size() - tws; if(!bounds.IsRectEmpty()) { if(CWnd* pChild = pPage->GetWindow(GW_CHILD)) pChild->MoveWindow(bounds); CRect r = twr; pTC->AdjustRect(FALSE, r); ScreenToClient(r); pPage->MoveWindow(CRect(r.TopLeft(), bounds.Size())); } int _afxPropSheetButtons[] = { IDOK, IDCANCEL, ID_APPLY_NOW, IDHELP }; for(int i = 0; i < countof(_afxPropSheetButtons); i++) { if(CWnd* pWnd = GetDlgItem(_afxPropSheetButtons[i])) { pWnd->GetWindowRect(r); ScreenToClient(r); pWnd->MoveWindow(CRect(r.TopLeft() + diff, r.Size())); } } MoveWindow(CRect(wr.TopLeft(), ws + diff)); Invalidate(); }
void ResAtlasGeneric::loadAtlas2(CreateResourceContext& context) { _current = 0; pugi::xml_node node = context.walker.getNode(); int w = node.attribute("width").as_int(defaultAtlasWidth); int h = node.attribute("height").as_int(defaultAtlasHeight); const char* format = node.attribute("format").as_string("8888"); loadBase(node); atlas_data ad; TextureFormat tf = string2TextureFormat(format); bool compressed = false; std::vector<ResAnim*> anims; while (true) { XmlWalker walker = context.walker.next(); if (walker.empty()) break; pugi::xml_node child_node = walker.getNode(); const char* name = child_node.name(); if (strcmp(name, "image")) continue; std::string id = child_node.attribute("id").value(); std::string file = child_node.attribute("file").value(); if (file.empty()) { createEmpty(walker, context); continue; } bool trim = child_node.attribute("trim").as_bool(true); bool extend = child_node.attribute("extend").as_bool(true); Point offset = extend ? Point(2, 2) : Point(0, 0); MemoryTexture mt; ImageData im; int columns = 0; int rows = 0; int frame_width = 0; int frame_height = 0; float frame_scale = 1.0f; bool loaded = false; file::buffer bf; file::read(walker.getPath("file"), bf); mt.init(bf, true, tf); im = mt.lock(); if (im.w) { rows = child_node.attribute("rows").as_int(); frame_width = child_node.attribute("frame_width").as_int(); columns = child_node.attribute("cols").as_int(); frame_height = child_node.attribute("frame_height").as_int(); if (!rows) rows = 1; if (!columns) columns = 1; if (frame_width) columns = im.w / frame_width; else frame_width = im.w / columns; if (frame_height) rows = im.h / frame_height; else frame_height = im.h / rows; } if (columns) { animationFrames frames; int frames_count = rows * columns; frames.reserve(frames_count); ResAnim* ra = new ResAnim(this); anims.push_back(ra); for (int y = 0; y < rows; ++y) { for (int x = 0; x < columns; ++x) { Rect frameRect; frameRect.pos = Point(x * frame_width, y * frame_height); frameRect.size = Point(frame_width, frame_height); ImageData srcImage_ = im.getRect(frameRect); HitTestData adata; ImageData src; Rect bounds(0, 0, im.w, im.h); if (trim) makeAlpha(srcImage_, bounds, _hitTestBuffer, adata, walker.getAlphaHitTest()); src = srcImage_.getRect(bounds); Rect dest(0, 0, 0, 0); if (!ad.texture) { std::string atlas_id = getName(); nextAtlas(w, h, tf, ad, atlas_id.c_str()); } bool s = ad.atlas.add(&ad.mt, src, dest, offset); if (s == false) { applyAtlas(ad, _linearFilter, _clamp2edge); nextAtlas(w, h, tf, ad, walker.getCurrentFolder().c_str()); s = ad.atlas.add(&ad.mt, src, dest, offset); OX_ASSERT(s); } //extend = false; if (extend) { //duplicate image edges MemoryTexture& mt = ad.mt; ImageData tmp; if (bounds.getY() == 0 && dest.pos.y != 0) { tmp = mt.lock(Rect(dest.pos.x, dest.pos.y - 1, src.w, 1)); operations::copy(src.getRect(Rect(0, 0, src.w, 1)), tmp); } if (bounds.getHeight() == im.h && dest.getBottom() != mt.getHeight()) { tmp = mt.lock(Rect(dest.pos.x, dest.pos.y + src.h, src.w, 1)); operations::copy(src.getRect(Rect(0, src.h - 1, src.w, 1)), tmp); } if (bounds.getX() == 0 && dest.pos.x != 0) { tmp = mt.lock(Rect(dest.pos.x - 1, dest.pos.y, 1, src.h)); operations::copy(src.getRect(Rect(0, 0, 1, src.h)), tmp); } if (bounds.getWidth() == im.w && dest.getRight() != mt.getWidth()) { tmp = mt.lock(Rect(dest.pos.x + src.w, dest.pos.y, 1, src.h)); operations::copy(src.getRect(Rect(src.w - 1, 0, 1, src.h)), tmp); } } //operations::copy(src.getRect(Rect(0, 0, 1, 1)), mt.lock(&Rect(dest.pos.x - 1, dest.pos.y - 1, 1, 1))); //operations::copy(src.getRect(Rect(src.w - 1, 0, 1, 1)), mt.lock(&Rect(dest.pos.x + src.w, dest.pos.y - 1, 1, 1))); //operations::copy(src.getRect(Rect(0, src.h - 1, 1, 1)), mt.lock(&Rect(dest.pos.x - 1, dest.pos.y + src.h, 1, 1))); //operations::copy(src.getRect(Rect(src.w - 1, src.h - 1, 1, 1)), mt.lock(&Rect(dest.pos.x + src.w, dest.pos.y + src.h, 1, 1))); float iw = 1.0f; float ih = 1.0f; RectF srcRect(dest.pos.x * iw, dest.pos.y * ih, dest.size.x * iw, dest.size.y * ih); Vector2 sizeScaled = Vector2((float)dest.size.x, (float)dest.size.y) * walker.getScaleFactor(); RectF destRect(bounds.pos.cast<Vector2>(), sizeScaled); AnimationFrame frame; Diffuse df; df.base = ad.texture; df.premultiplied = true;//!Renderer::getPremultipliedAlphaRender(); Vector2 fsize = Vector2((float)frame_width, (float)frame_height) * walker.getScaleFactor(); frame.init2(ra, x, y, df, srcRect, destRect, fsize); frame.setHitTestData(adata); frames.push_back(frame); } } init_resAnim(ra, file, child_node); ra->init(frames, columns, walker.getScaleFactor(), 1.0f / walker.getScaleFactor()); ra->setParent(this); context.resources->add(ra, context.options->_shortenIDS); } } applyAtlas(ad, _linearFilter, _clamp2edge); for (std::vector<ResAnim*>::iterator i = anims.begin(); i != anims.end(); ++i) { ResAnim* rs = *i; int num = rs->getTotalFrames(); for (int n = 0; n < num; ++n) { AnimationFrame& frame = const_cast<AnimationFrame&>(rs->getFrame(n)); float iw = 1.0f / frame.getDiffuse().base->getWidth(); float ih = 1.0f / frame.getDiffuse().base->getHeight(); RectF rect = frame.getSrcRect(); rect.pos.x *= iw; rect.pos.y *= ih; rect.size.x *= iw; rect.size.y *= ih; frame.setSrcRect(rect); HitTestData ad = frame.getHitTestData(); if (ad.pitch) { ad.data = &_hitTestBuffer[reinterpret_cast<size_t>(ad.data)]; frame.setHitTestData(ad); } } } }
bool ModelOBJ::import(const char *pszFilename, bool rebuildNormals) { FILE *pFile = fopen(pszFilename, "r"); if (!pFile) return false; // Extract the directory the OBJ file is in from the file name. // This directory path will be used to load the OBJ's associated MTL file. m_directoryPath.clear(); std::string filename = pszFilename; std::string::size_type offset = filename.find_last_of('\\'); if (offset != std::string::npos) { m_directoryPath = filename.substr(0, ++offset); } else { offset = filename.find_last_of('/'); if (offset != std::string::npos) m_directoryPath = filename.substr(0, ++offset); } // Import the OBJ file. importGeometryFirstPass(pFile); rewind(pFile); importGeometrySecondPass(pFile); fclose(pFile); // Perform post import tasks. buildMeshes(); bounds(m_center, m_width, m_height, m_length, m_radius); // Build vertex normals if required. if (rebuildNormals) { generateNormals(); } else { if (!hasNormals()) generateNormals(); } // Build tangents is required. for (int i = 0; i < m_numberOfMaterials; ++i) { if (!m_materials[i].bumpMapFilename.empty()) { generateTangents(); break; } } return true; }
void LayerManagerComposite::Render() { PROFILER_LABEL("LayerManagerComposite", "Render", js::ProfileEntry::Category::GRAPHICS); if (mDestroyed) { NS_WARNING("Call on destroyed layer manager"); return; } /** Our more efficient but less powerful alter ego, if one is available. */ nsRefPtr<Composer2D> composer2D = mCompositor->GetWidget()->GetComposer2D(); // Set LayerScope begin/end frame LayerScopeAutoFrame frame(PR_Now()); // Dump to console if (gfxPrefs::LayersDump()) { this->Dump(); } // Dump to LayerScope Viewer if (LayerScope::CheckSendable()) { // Create a LayersPacket, dump Layers into it and transfer the // packet('s ownership) to LayerScope. auto packet = MakeUnique<layerscope::Packet>(); layerscope::LayersPacket* layersPacket = packet->mutable_layers(); this->Dump(layersPacket); LayerScope::SendLayerDump(Move(packet)); } if (!mTarget && composer2D && composer2D->TryRender(mRoot, mWorldMatrix, mGeometryChanged)) { if (mFPS) { double fps = mFPS->mCompositionFps.AddFrameAndGetFps(TimeStamp::Now()); if (gfxPrefs::LayersDrawFPS()) { printf_stderr("HWComposer: FPS is %g\n", fps); } } mCompositor->EndFrameForExternalComposition(mWorldMatrix); // Reset the invalid region as compositing is done mInvalidRegion.SetEmpty(); return; } { PROFILER_LABEL("LayerManagerComposite", "PreRender", js::ProfileEntry::Category::GRAPHICS); if (!mCompositor->GetWidget()->PreRender(this)) { return; } } nsIntRegion invalid; if (mTarget) { invalid = mTargetBounds; } else { invalid = mInvalidRegion; // Reset the invalid region now that we've begun compositing. mInvalidRegion.SetEmpty(); } nsIntRect clipRect; Rect bounds(mRenderBounds.x, mRenderBounds.y, mRenderBounds.width, mRenderBounds.height); Rect actualBounds; CompositorBench(mCompositor, bounds); if (mRoot->GetClipRect()) { clipRect = *mRoot->GetClipRect(); WorldTransformRect(clipRect); Rect rect(clipRect.x, clipRect.y, clipRect.width, clipRect.height); mCompositor->BeginFrame(invalid, &rect, mWorldMatrix, bounds, nullptr, &actualBounds); } else { gfx::Rect rect; mCompositor->BeginFrame(invalid, nullptr, mWorldMatrix, bounds, &rect, &actualBounds); clipRect = nsIntRect(rect.x, rect.y, rect.width, rect.height); } if (actualBounds.IsEmpty()) { mCompositor->GetWidget()->PostRender(this); return; } // Allow widget to render a custom background. mCompositor->GetWidget()->DrawWindowUnderlay(this, nsIntRect(actualBounds.x, actualBounds.y, actualBounds.width, actualBounds.height)); // Render our layers. RootLayer()->Prepare(clipRect); RootLayer()->RenderLayer(clipRect); if (!mRegionToClear.IsEmpty()) { nsIntRegionRectIterator iter(mRegionToClear); const nsIntRect *r; while ((r = iter.Next())) { mCompositor->ClearRect(Rect(r->x, r->y, r->width, r->height)); } } // Allow widget to render a custom foreground. mCompositor->GetWidget()->DrawWindowOverlay(this, nsIntRect(actualBounds.x, actualBounds.y, actualBounds.width, actualBounds.height)); // Debugging RenderDebugOverlay(actualBounds); { PROFILER_LABEL("LayerManagerComposite", "EndFrame", js::ProfileEntry::Category::GRAPHICS); mCompositor->EndFrame(); mCompositor->SetFBAcquireFence(mRoot); } mCompositor->GetWidget()->PostRender(this); RecordFrame(); }
void LayerManagerComposite::Render() { PROFILER_LABEL("LayerManagerComposite", "Render", js::ProfileEntry::Category::GRAPHICS); if (mDestroyed) { NS_WARNING("Call on destroyed layer manager"); return; } // At this time, it doesn't really matter if these preferences change // during the execution of the function; we should be safe in all // permutations. However, may as well just get the values onces and // then use them, just in case the consistency becomes important in // the future. bool invertVal = gfxPrefs::LayersEffectInvert(); bool grayscaleVal = gfxPrefs::LayersEffectGrayscale(); float contrastVal = gfxPrefs::LayersEffectContrast(); bool haveLayerEffects = (invertVal || grayscaleVal || contrastVal != 0.0); // Set LayerScope begin/end frame LayerScopeAutoFrame frame(PR_Now()); // Dump to console if (gfxPrefs::LayersDump()) { this->Dump(); } // Dump to LayerScope Viewer if (LayerScope::CheckSendable()) { // Create a LayersPacket, dump Layers into it and transfer the // packet('s ownership) to LayerScope. auto packet = MakeUnique<layerscope::Packet>(); layerscope::LayersPacket* layersPacket = packet->mutable_layers(); this->Dump(layersPacket); LayerScope::SendLayerDump(Move(packet)); } /** Our more efficient but less powerful alter ego, if one is available. */ nsRefPtr<Composer2D> composer2D; // We can't use composert2D if we have layer effects, so only get it // when we don't have any effects. if (!haveLayerEffects) { composer2D = mCompositor->GetWidget()->GetComposer2D(); } if (!mTarget && composer2D && composer2D->TryRender(mRoot, mWorldMatrix, mGeometryChanged)) { if (mFPS) { double fps = mFPS->mCompositionFps.AddFrameAndGetFps(TimeStamp::Now()); if (gfxPrefs::LayersDrawFPS()) { printf_stderr("HWComposer: FPS is %g\n", fps); } } mCompositor->EndFrameForExternalComposition(mWorldMatrix); // Reset the invalid region as compositing is done mInvalidRegion.SetEmpty(); return; } { PROFILER_LABEL("LayerManagerComposite", "PreRender", js::ProfileEntry::Category::GRAPHICS); if (!mCompositor->GetWidget()->PreRender(this)) { return; } } nsIntRegion invalid; if (mTarget) { invalid = mTargetBounds; } else { invalid = mInvalidRegion; // Reset the invalid region now that we've begun compositing. mInvalidRegion.SetEmpty(); } nsIntRect clipRect; Rect bounds(mRenderBounds.x, mRenderBounds.y, mRenderBounds.width, mRenderBounds.height); Rect actualBounds; CompositorBench(mCompositor, bounds); if (mRoot->GetClipRect()) { clipRect = *mRoot->GetClipRect(); WorldTransformRect(clipRect); Rect rect(clipRect.x, clipRect.y, clipRect.width, clipRect.height); mCompositor->BeginFrame(invalid, &rect, mWorldMatrix, bounds, nullptr, &actualBounds); } else { gfx::Rect rect; mCompositor->BeginFrame(invalid, nullptr, mWorldMatrix, bounds, &rect, &actualBounds); clipRect = nsIntRect(rect.x, rect.y, rect.width, rect.height); } if (actualBounds.IsEmpty()) { mCompositor->GetWidget()->PostRender(this); return; } // Allow widget to render a custom background. mCompositor->GetWidget()->DrawWindowUnderlay(this, nsIntRect(actualBounds.x, actualBounds.y, actualBounds.width, actualBounds.height)); RefPtr<CompositingRenderTarget> previousTarget; if (haveLayerEffects) { previousTarget = PushGroupForLayerEffects(); } else { mTwoPassTmpTarget = nullptr; } // Render our layers. RootLayer()->Prepare(RenderTargetPixel::FromUntyped(clipRect)); RootLayer()->RenderLayer(clipRect); if (!mRegionToClear.IsEmpty()) { nsIntRegionRectIterator iter(mRegionToClear); const nsIntRect *r; while ((r = iter.Next())) { mCompositor->ClearRect(Rect(r->x, r->y, r->width, r->height)); } } if (mTwoPassTmpTarget) { MOZ_ASSERT(haveLayerEffects); PopGroupForLayerEffects(previousTarget, clipRect, grayscaleVal, invertVal, contrastVal); } // Allow widget to render a custom foreground. mCompositor->GetWidget()->DrawWindowOverlay(this, nsIntRect(actualBounds.x, actualBounds.y, actualBounds.width, actualBounds.height)); // Debugging RenderDebugOverlay(actualBounds); { PROFILER_LABEL("LayerManagerComposite", "EndFrame", js::ProfileEntry::Category::GRAPHICS); mCompositor->EndFrame(); mCompositor->SetFBAcquireFence(mRoot); } mCompositor->GetWidget()->PostRender(this); RecordFrame(); }
void expand_node_t::do_calc_bounds( const render::context_t& context) { Imath::Box2i bounds( ImathExt::intersect( input_as<image_node_t>()->bounds(), format())); set_bounds( bounds); }
void drawScene() { glPushMatrix(); //Set the animation control variables. if (!paused) frame++; int ticks = frame % 1440; if (frame % 1440 == 0) { ticks = 0; //Reset animation object positions and rotations. planePriorX = 0, planePriorY = 0, planePriorZ = 0; planePostX = 0, planePostY = 0, planePostZ = 0; planeRotX = 0, planeRotY = 0, planeRotZ = 0; eaglePriorX = -0.5, eaglePriorY = 0.03, eaglePriorZ = -0.1; eaglePostX = 0, eaglePostY = 0, eaglePostZ = 0; eagleRotX = 0, eagleRotY = 0, eagleRotZ = 0; } //Apply scene transformations. glRotatef(30, 0, 1, 0); glTranslatef(0, 0, -1500 * frame * SCALE_FACTOR); //Make sure angles are in bounds. bounds(planeRotX); bounds(planeRotY); bounds(planeRotZ); bounds(eagleRotX); bounds(eagleRotY); bounds(eagleRotZ); if (!paused) { //Airplane transformation events. //Constant swaying. planeRotZ -= 0.5 * cos(ticks * 2 * PI / 180); planePostY -= 0.01 * cos(ticks * PI / 180); //Spin upside-down. if (ticks >= 180 && ticks < 360) planeRotZ -= PI * 0.5 * sin(ticks * PI / 180); //Spin back round. if (ticks >= 360 && ticks < 540) planeRotZ += PI * 0.5 * sin(ticks * PI / 180); //Dive. if (ticks >= 720 && ticks < 900) { planeRotX -= 0.25 * PI * sin(ticks * 2 * PI / 180); planePriorY -= 0.005 * PI * sin(ticks * PI / 180); planePriorZ -= 0.01 * PI * sin(ticks * 0.5 * PI / 180); } //Loop-the-loop if (ticks >= 900 && ticks < 1220) { planeRotX += 1; planePriorY += 0.015 * PI * sin((ticks - 180) * PI / 180); planePriorZ -= 0.015 * PI * cos((ticks - 180) * PI / 180); } //Reset position. if (ticks >= 1220 && ticks < 1440) { // These values were found by minimising errors using binary division. planeRotX -= 0.1262345 * PI * sin(ticks * PI / 180); planePriorY -= 0.002379563 * PI * sin(ticks * 0.5 * PI / 180); planePriorZ -= 0.003826425 * PI * sin(ticks * 0.5 * PI / 180); } //Eagle transformation events. //Set default position. eaglePriorX = -1; eaglePriorZ = 0.4; //Set start position over left wing. if (ticks >= 0 && ticks < 180) { eaglePriorX = -0.5; eaglePriorY = 0.03; eaglePriorZ = -0.1; } //Move a little with the wing. if (ticks >= 0 && ticks < 90) { eagleRotZ -= cos(ticks * 2 * PI / 180); eaglePostY -= 0.009 * sin(ticks * 2 * PI / 180); } //Move back, up and left. if (ticks >= 90 && ticks < 180) { eaglePriorX -= (float)0.5 / 90 * (ticks - 90); eaglePriorZ += (float)0.5 / 90 * (ticks - 90); eaglePostY += 0.009 * sin((ticks - 90) * 2 * PI / 180); } //Swaying. if (ticks >= 90 && ticks < 1350) { eagleRotZ -= 0.6 * cos((ticks + 90) * PI / 180); eaglePostY -= 0.01 * cos((ticks + 90) * 2 * PI / 180); } //Avoid plane collision. if (ticks >= 360 && ticks < 540) eagleRotZ += 0.25 * PI * sin(ticks * 2 * PI / 180); //Glide from side to side. if (ticks >= 720 && ticks < 1080) eaglePriorX += 0.4 * PI * sin(ticks * 0.5 * PI / 180); //Move back to start position. if (ticks >= 1350 && ticks < 1440) { eaglePriorX += (float)0.5 / 90 * (ticks - 1350); eaglePriorZ -= (float)0.5 / 90 * (ticks - 1350); } //Avoid plane collision. if (ticks >= 1400 && ticks < 1420) eaglePriorY += 0.01; if (ticks >= 1420 && ticks < 1440) eaglePriorY -= 0.01; } //Apply the transformations then draw the airplane. glPushMatrix(); glTranslatef(planePriorX, planePriorY, planePriorZ); glRotatef(planeRotX, 1, 0, 0); glRotatef(planeRotY, 0, 1, 0); glRotatef(planeRotZ, 0, 0, 1); glTranslatef(planePostX, planePostY, planePostZ); drawAirplane(); glPopMatrix(); //Apply the transformations then draw the eagle. glPushMatrix(); glTranslatef(eaglePriorX, eaglePriorY, eaglePriorZ); glRotatef(eagleRotX, 1, 0, 0); glRotatef(eagleRotY, 0, 1, 0); glRotatef(eagleRotZ, 0, 0, 1); glTranslatef(eaglePostX, eaglePostY, eaglePostZ); drawEagle(); glPopMatrix(); glPopMatrix(); }
int LbfgsbOptimizer::solve() { // Solution vector ap::real_1d_array x0; x0.setbounds(1, x.dim); // copy current x into x0 for(size_t i = 0; i < x.dim; i++) { x0(i+1) = x.val[i]; } ap::integer_1d_array nbd; ap::real_1d_array l; ap::real_1d_array u; nbd.setbounds(1, x.dim); l.setbounds(1, x.dim); u.setbounds(1, x.dim); // Set bounds if(binary) { bounds_binary(nbd, l, u); } else { bounds(nbd, l, u); } // Lancelot: gamma_bar = 0.1 double gamma_bar = 0.1; // < 1 : // Lancelot: tau = 0.1 double tau = 0.1; // # < 1 // Lancelot: alpha_eta = 0.1 double alpha_eta = 0.01; // # min(1, self._alpha_omega) //Lancelot: beta_eta = 0.9 double beta_eta = 0.9; // # min(1, self._beta_omega) //Lancelot: alpha_omega = 1.0 double alpha_omega = 4.0; //Lancelot: beta_omega = 1.0 double beta_omega = 4.0; // Lancelot: omega_bar = firtsg/pow(std::min(mu, gamma_bar), alpha_omega); double omega_bar = 0.5; // Lancelot: eta_bar = firtsc/pow(std::min(mu, gamma_bar), alpha_eta); double eta_bar = 1.0; double mu_bar = 0.9; // must be <= 1 mu = mu_bar; // Lancelot: alpha = min(mu, gamma_bar) double alpha = std::min(mu, gamma_bar); // Lancelot: eta = max(etamin, eta_bar*pow(alpha, alpha_eta)) // svnvish: BUGBUG what is etamin? // etamin is the minimum norm of the constraint violation double eta = eta_bar*pow(alpha, alpha_eta); // Lancelot: omega = max(omemin, omega_bar*pow(alpha, alpha_omega)) // svnvish: BUGBUG what is omemin? // omemin is the tolerance for kkt gap double omega = omega_bar*pow(alpha, alpha_omega); DenseVector W; W.val = x.val; W.dim = num_weak_learners; for(size_t iteration = 0; iteration < LBFGSB::max_iterations; iteration++) { double epsg = omega; double epsf = 0; double epsx = 0; int info; lbfgsbminimize(x.dim, std::min(x.dim, LBFGSB::lbfgsb_m), x0, epsg, epsf, epsx, LBFGSB::lbfgsb_max_iterations, nbd, l, u, (void*) this, info); // copy current solution into x for(size_t i = 0; i < x.dim; i++) { x.val[i] = x0(i+1); } const double w_gap = sum(W) - 1.0; // std::cout << "info: " << info << std::endl; // assert(info > 0); assert(info == 4); if(std::abs(w_gap) < eta) { if(std::abs(w_gap) < Optimizer::wt_sum_tol) { if(duality_gap_met()) { // // svnvish: BUGBUG // // Extra gradient computation happening here // // Better to use norm gaps // dvec gradk = grad(); // if(converged(grad())){ report_statistics(); break; } } lambda = lambda - (w_gap/mu); //mu = mu; alpha = mu; eta = eta*pow(alpha, beta_eta); omega = omega*pow(alpha, beta_omega); } else { //lambda = lambda; mu *= tau; alpha = mu*gamma_bar; eta = eta_bar*pow(alpha, beta_eta); omega = omega_bar*pow(alpha, beta_omega); } } // end of "for each iteration" // This is not a memory leak! W.val = NULL; W.dim = 0; return 0; } // end of LbfgsbOptimizer::solve()
/* * Q P r o b l e m B _ i n i t */ int_t QProblemB_init( int_t handle, SymmetricMatrix* H, real_t* g, const real_t* const lb, const real_t* const ub, int_t nWSRin, real_t maxCpuTimeIn, const double* const x0, Options* options, int_t nOutputs, mxArray* plhs[], const double* const guessedBounds, const double* const _R ) { int_t nWSRout = nWSRin; real_t maxCpuTimeOut = (maxCpuTimeIn >= 0.0) ? maxCpuTimeIn : INFTY; /* 1) setup initial QP. */ QProblemB* globalQPB = getQPInstance(handle)->qpb; if ( globalQPB == 0 ) { myMexErrMsgTxt( "ERROR (qpOASES): Invalid handle to QP instance!" ); return -1; } globalQPB->setOptions( *options ); /* 2) Solve initial QP. */ returnValue returnvalue; int_t nV = globalQPB->getNV(); /* 3) Fill the working set. */ Bounds bounds(nV); if (guessedBounds != 0) { for (int_t i = 0; i < nV; i++) { if ( isEqual(guessedBounds[i],-1.0) == BT_TRUE ) { bounds.setupBound(i, ST_LOWER); } else if ( isEqual(guessedBounds[i],1.0) == BT_TRUE ) { bounds.setupBound(i, ST_UPPER); } else if ( isEqual(guessedBounds[i],0.0) == BT_TRUE ) { bounds.setupBound(i, ST_INACTIVE); } else { char msg[MAX_STRING_LENGTH]; snprintf(msg, MAX_STRING_LENGTH, "ERROR (qpOASES): Only {-1, 0, 1} allowed for status of bounds!"); myMexErrMsgTxt(msg); return -1; } } } returnvalue = globalQPB->init( H,g,lb,ub, nWSRout,&maxCpuTimeOut, x0,0, (guessedBounds != 0) ? &bounds : 0, _R ); /* 3) Assign lhs arguments. */ obtainOutputs( 0,globalQPB,returnvalue,nWSRout,maxCpuTimeOut, nOutputs,plhs,nV,0,handle ); return 0; }