Volatility FixedLocalVolSurface::localVolImpl(Time t, Real strike) const {
t = std::min(times_.back(), std::max(t, times_.front()));
const Size idx = std::distance(times_.begin(),
std::lower_bound(times_.begin(), times_.end(), t));
if (close_enough(t, times_[idx])) {
if (strikes_[idx]->front() < strikes_[idx]->back())
return localVolInterpol_[idx](strike, true);
else
return (*localVolMatrix_)[localVolMatrix_->rows()/2][idx];
}
else {
Real earlierStrike = strike, laterStrike = strike;
if (lowerExtrapolation_ == ConstantExtrapolation) {
if (strike < strikes_[idx-1]->front())
earlierStrike = strikes_[idx-1]->front();
if (strike < strikes_[idx]->front())
laterStrike = strikes_[idx]->front();
}
if (upperExtrapolation_ == ConstantExtrapolation) {
if (strike > strikes_[idx-1]->back())
earlierStrike = strikes_[idx-1]->back();
if (strike > strikes_[idx]->back())
laterStrike = strikes_[idx]->back();
}
const Real earlyVol =
(strikes_[idx-1]->front() < strikes_[idx-1]->back())
? localVolInterpol_[idx-1](earlierStrike, true)
: (*localVolMatrix_)[localVolMatrix_->rows()/2][idx-1];
const Real laterVol = localVolInterpol_[idx](laterStrike, true);
return earlyVol
+ (laterVol-earlyVol)/(times_[idx]-times_[idx-1])
*(t-times_[idx-1]);
}
}
Size TimeGrid::index(Time t) const {
Size i = closestIndex(t);
if (close_enough(t,times_[i])) {
return i;
} else {
if (t < times_.front()) {
QL_FAIL("using inadequate time grid: all nodes "
"are later than the required time t = "
<< std::setprecision(12) << t
<< " (earliest node is t1 = "
<< std::setprecision(12) << times_.front() << ")");
} else if (t > times_.back()) {
QL_FAIL("using inadequate time grid: all nodes "
"are earlier than the required time t = "
<< std::setprecision(12) << t
<< " (latest node is t1 = "
<< std::setprecision(12) << times_.back() << ")");
} else {
Size j, k;
if (t > times_[i]) {
j = i;
k = i+1;
} else {
j = i-1;
k = i;
}
QL_FAIL("using inadequate time grid: the nodes closest "
"to the required time t = "
<< std::setprecision(12) << t
<< " are t1 = "
<< std::setprecision(12) << times_[j]
<< " and t2 = "
<< std::setprecision(12) << times_[k]);
}
}
}
static inline GLuint
save_vertex(glb_data *d, const GLfloat * v)
{
int i;
/* Inefficient, but we only do this a few times. Check to see if there's
* an existing vertex which is `close enough' to this one.
*/
for (i = 0; i < d->nr_vertices; ++i)
if (close_enough(v, d->vertices[i]))
return i;
if (d->nr_vertices_allocated <= d->nr_vertices) {
if (d->vertices == 0) {
d->vertices = (vertex *) malloc(INCR(d->nr_vertices_allocated) * sizeof (vertex));
} else {
INCR_ALLOCATION(d->vertices, d->nr_vertices_allocated, vertex);
}
}
d->vertices[d->nr_vertices][0] = v[0];
d->vertices[d->nr_vertices][1] = v[1];
d->vertices[d->nr_vertices][2] = v[2];
return d->nr_vertices++;
}
Real GoldsteinLineSearch::operator()(Problem& P,
EndCriteria::Type& ecType,
const EndCriteria& endCriteria,
const Real t_ini)
{
Constraint& constraint = P.constraint();
succeed_=true;
bool maxIter = false;
Real /*qtold,*/ t = t_ini; // see below, this is never used ?
Size loopNumber = 0;
Real q0 = P.functionValue();
Real qp0 = P.gradientNormValue();
Real tl = 0.0;
Real tr = 0.0;
qt_ = q0;
qpt_ = (gradient_.empty()) ? qp0 : -DotProduct(gradient_,searchDirection_);
// Initialize gradient
gradient_ = Array(P.currentValue().size());
// Compute new point
xtd_ = P.currentValue();
t = update(xtd_, searchDirection_, t, constraint);
// Compute function value at the new point
qt_ = P.value (xtd_);
while ((qt_ - q0) < -beta_*t*qpt_ || (qt_ - q0) > -alpha_*t*qpt_) {
if ((qt_ - q0) > -alpha_*t*qpt_)
tr = t;
else
tl = t;
++loopNumber;
// calculate the new step
if (close_enough(tr, 0.0))
t *= extrapolation_;
else
t = (tl + tr) / 2.0;
// Store old value of the function
// qtold = qt_; // this is never used ?
// New point value
xtd_ = P.currentValue();
t = update(xtd_, searchDirection_, t, constraint);
// Compute function value at the new point
qt_ = P.value (xtd_);
P.gradient (gradient_, xtd_);
// and it squared norm
maxIter = endCriteria.checkMaxIterations(loopNumber, ecType);
if (maxIter)
break;
}
if (maxIter)
succeed_ = false;
// Compute new gradient
P.gradient(gradient_, xtd_);
// and it squared norm
qpt_ = DotProduct(gradient_, gradient_);
// Return new step value
return t;
}
int main() {
static_assert(close_enough(3,3), "...");
static_assert(!close_enough(3.1,3.0), "...");
static_assert(close_enough(3.000000000001,3.0), "...");
}
inline bool close_enough(Real x, Real y) {
return close_enough(x,y,42);
}
int main() {
static_assert(sizeof(double *) == sizeof(std::unique_ptr<double>), "...");
static_assert(close_enough(3, 3), "...");
static_assert(!close_enough(3.1, 3.0), "...");
static_assert(close_enough(3.000000000001, 3.0), "...");
}
constexpr bool close_enough(T a, T b) {
return close_enough(a, b, std::conditional_t<
std::is_floating_point<T>::value, floating_point, exact
>{});
}
/**
* Function ConvertOutlineToPolygon
* build a polygon (with holes) from a DRAWSEGMENT list, which is expected to be
* a outline, therefore a closed main outline with perhaps closed inner outlines.
* These closed inner outlines are considered as holes in the main outline
* @param aSegList the initial list of drawsegments (only lines, circles and arcs).
* @param aPolygons will contain the complex polygon.
* @param aTolerance is the max distance between points that is still accepted as connected (internal units)
* @param aErrorText is a wxString to return error message.
* @param aErrorLocation is the optional position of the error in the outline
*/
bool ConvertOutlineToPolygon( std::vector<DRAWSEGMENT*>& aSegList, SHAPE_POLY_SET& aPolygons,
wxString* aErrorText, unsigned int aTolerance, wxPoint* aErrorLocation )
{
if( aSegList.size() == 0 )
return true;
wxString msg;
// Make a working copy of aSegList, because the list is modified during calculations
std::vector< DRAWSEGMENT* > segList = aSegList;
DRAWSEGMENT* graphic;
wxPoint prevPt;
// Find edge point with minimum x, this should be in the outer polygon
// which will define the perimeter Edge.Cuts polygon.
wxPoint xmin = wxPoint( INT_MAX, 0 );
int xmini = 0;
for( size_t i = 0; i < segList.size(); i++ )
{
graphic = (DRAWSEGMENT*) segList[i];
switch( graphic->GetShape() )
{
case S_SEGMENT:
{
if( graphic->GetStart().x < xmin.x )
{
xmin = graphic->GetStart();
xmini = i;
}
if( graphic->GetEnd().x < xmin.x )
{
xmin = graphic->GetEnd();
xmini = i;
}
}
break;
case S_ARC:
// Freerouter does not yet understand arcs, so approximate
// an arc with a series of short lines and put those
// line segments into the !same! PATH.
{
wxPoint pstart = graphic->GetArcStart();
wxPoint center = graphic->GetCenter();
double angle = -graphic->GetAngle();
double radius = graphic->GetRadius();
int steps = GetArcToSegmentCount( radius, ARC_LOW_DEF, angle / 10.0 );
wxPoint pt;
for( int step = 1; step<=steps; ++step )
{
double rotation = ( angle * step ) / steps;
pt = pstart;
RotatePoint( &pt, center, rotation );
if( pt.x < xmin.x )
{
xmin = pt;
xmini = i;
}
}
}
break;
case S_CIRCLE:
{
wxPoint pt = graphic->GetCenter();
// pt has minimum x point
pt.x -= graphic->GetRadius();
// when the radius <= 0, this is a mal-formed circle. Skip it
if( graphic->GetRadius() > 0 && pt.x < xmin.x )
{
xmin = pt;
xmini = i;
}
}
break;
case S_CURVE:
{
graphic->RebuildBezierToSegmentsPointsList( graphic->GetWidth() );
for( unsigned int jj = 0; jj < graphic->GetBezierPoints().size(); jj++ )
{
wxPoint pt = graphic->GetBezierPoints()[jj];
if( pt.x < xmin.x )
{
xmin = pt;
xmini = i;
}
}
}
break;
case S_POLYGON:
{
const auto poly = graphic->GetPolyShape();
MODULE* module = aSegList[0]->GetParentModule();
double orientation = module ? module->GetOrientation() : 0.0;
VECTOR2I offset = module ? module->GetPosition() : VECTOR2I( 0, 0 );
for( auto iter = poly.CIterate(); iter; iter++ )
{
auto pt = *iter;
RotatePoint( pt, orientation );
pt += offset;
if( pt.x < xmin.x )
{
xmin.x = pt.x;
xmin.y = pt.y;
xmini = i;
}
}
}
break;
default:
break;
}
}
// Grab the left most point, assume its on the board's perimeter, and see if we
// can put enough graphics together by matching endpoints to formulate a cohesive
// polygon.
graphic = (DRAWSEGMENT*) segList[xmini];
// The first DRAWSEGMENT is in 'graphic', ok to remove it from 'items'
segList.erase( segList.begin() + xmini );
// Output the Edge.Cuts perimeter as circle or polygon.
if( graphic->GetShape() == S_CIRCLE )
{
int steps = GetArcToSegmentCount( graphic->GetRadius(), ARC_LOW_DEF, 360.0 );
TransformCircleToPolygon( aPolygons, graphic->GetCenter(), graphic->GetRadius(), steps );
}
else if( graphic->GetShape() == S_POLYGON )
{
MODULE* module = graphic->GetParentModule(); // NULL for items not in footprints
double orientation = module ? module->GetOrientation() : 0.0;
VECTOR2I offset = module ? module->GetPosition() : VECTOR2I( 0, 0 );
aPolygons.NewOutline();
for( auto it = graphic->GetPolyShape().CIterate( 0 ); it; it++ )
{
auto pt = *it;
RotatePoint( pt, orientation );
pt += offset;
aPolygons.Append( pt );
}
}
else
{
// Polygon start point. Arbitrarily chosen end of the
// segment and build the poly from here.
wxPoint startPt = wxPoint( graphic->GetEnd() );
prevPt = graphic->GetEnd();
aPolygons.NewOutline();
aPolygons.Append( prevPt );
// Do not append the other end point yet of this 'graphic', this first
// 'graphic' might be an arc or a curve.
for(;;)
{
switch( graphic->GetShape() )
{
case S_SEGMENT:
{
wxPoint nextPt;
// Use the line segment end point furthest away from
// prevPt as we assume the other end to be ON prevPt or
// very close to it.
if( close_st( prevPt, graphic->GetStart(), graphic->GetEnd() ) )
nextPt = graphic->GetEnd();
else
nextPt = graphic->GetStart();
aPolygons.Append( nextPt );
prevPt = nextPt;
}
break;
case S_ARC:
// We do not support arcs in polygons, so approximate
// an arc with a series of short lines and put those
// line segments into the !same! PATH.
{
wxPoint pstart = graphic->GetArcStart();
wxPoint pend = graphic->GetArcEnd();
wxPoint pcenter = graphic->GetCenter();
double angle = -graphic->GetAngle();
double radius = graphic->GetRadius();
int steps = GetArcToSegmentCount( radius, ARC_LOW_DEF, angle / 10.0 );
if( !close_enough( prevPt, pstart, aTolerance ) )
{
wxASSERT( close_enough( prevPt, graphic->GetArcEnd(), aTolerance ) );
angle = -angle;
std::swap( pstart, pend );
}
wxPoint nextPt;
for( int step = 1; step<=steps; ++step )
{
double rotation = ( angle * step ) / steps;
nextPt = pstart;
RotatePoint( &nextPt, pcenter, rotation );
aPolygons.Append( nextPt );
}
prevPt = nextPt;
}
break;
case S_CURVE:
// We do not support Bezier curves in polygons, so approximate
// with a series of short lines and put those
// line segments into the !same! PATH.
{
wxPoint nextPt;
bool reverse = false;
// Use the end point furthest away from
// prevPt as we assume the other end to be ON prevPt or
// very close to it.
if( close_st( prevPt, graphic->GetStart(), graphic->GetEnd() ) )
nextPt = graphic->GetEnd();
else
{
nextPt = graphic->GetStart();
reverse = true;
}
if( reverse )
{
for( int jj = graphic->GetBezierPoints().size()-1; jj >= 0; jj-- )
aPolygons.Append( graphic->GetBezierPoints()[jj] );
}
else
{
for( size_t jj = 0; jj < graphic->GetBezierPoints().size(); jj++ )
aPolygons.Append( graphic->GetBezierPoints()[jj] );
}
prevPt = nextPt;
}
break;
default:
if( aErrorText )
{
msg.Printf( "Unsupported DRAWSEGMENT type %s.",
BOARD_ITEM::ShowShape( graphic->GetShape() ) );
*aErrorText << msg << "\n";
}
if( aErrorLocation )
*aErrorLocation = graphic->GetPosition();
return false;
}
// Get next closest segment.
graphic = findPoint( prevPt, segList, aTolerance );
// If there are no more close segments, check if the board
// outline polygon can be closed.
if( !graphic )
{
if( close_enough( startPt, prevPt, aTolerance ) )
{
// Close the polygon back to start point
// aPolygons.Append( startPt ); // not needed
}
else
{
if( aErrorText )
{
msg.Printf( _( "Unable to find segment with an endpoint of (%s, %s)." ),
StringFromValue( MILLIMETRES, prevPt.x, true ),
StringFromValue( MILLIMETRES, prevPt.y, true ) );
*aErrorText << msg << "\n";
}
if( aErrorLocation )
*aErrorLocation = prevPt;
return false;
}
break;
}
}
}
while( segList.size() )
{
// emit a signal layers keepout for every interior polygon left...
int hole = aPolygons.NewHole();
graphic = (DRAWSEGMENT*) segList[0];
segList.erase( segList.begin() );
// Both circles and polygons on the edge cuts layer are closed items that
// do not connect to other elements, so we process them independently
if( graphic->GetShape() == S_POLYGON )
{
MODULE* module = graphic->GetParentModule(); // NULL for items not in footprints
double orientation = module ? module->GetOrientation() : 0.0;
VECTOR2I offset = module ? module->GetPosition() : VECTOR2I( 0, 0 );
for( auto it = graphic->GetPolyShape().CIterate(); it; it++ )
{
auto val = *it;
RotatePoint( val, orientation );
val += offset;
aPolygons.Append( val, -1, hole );
}
}
else if( graphic->GetShape() == S_CIRCLE )
{
// make a circle by segments;
wxPoint center = graphic->GetCenter();
double angle = 3600.0;
wxPoint start = center;
int radius = graphic->GetRadius();
int steps = GetArcToSegmentCount( radius, ARC_LOW_DEF, 360.0 );
wxPoint nextPt;
start.x += radius;
for( int step = 0; step < steps; ++step )
{
double rotation = ( angle * step ) / steps;
nextPt = start;
RotatePoint( &nextPt.x, &nextPt.y, center.x, center.y, rotation );
aPolygons.Append( nextPt, -1, hole );
}
}
else
{
// Polygon start point. Arbitrarily chosen end of the
// segment and build the poly from here.
wxPoint startPt( graphic->GetEnd() );
prevPt = graphic->GetEnd();
aPolygons.Append( prevPt, -1, hole );
// do not append the other end point yet, this first 'graphic' might be an arc
for(;;)
{
switch( graphic->GetShape() )
{
case S_SEGMENT:
{
wxPoint nextPt;
// Use the line segment end point furthest away from
// prevPt as we assume the other end to be ON prevPt or
// very close to it.
if( close_st( prevPt, graphic->GetStart(), graphic->GetEnd() ) )
{
nextPt = graphic->GetEnd();
}
else
{
nextPt = graphic->GetStart();
}
prevPt = nextPt;
aPolygons.Append( prevPt, -1, hole );
}
break;
case S_ARC:
// Freerouter does not yet understand arcs, so approximate
// an arc with a series of short lines and put those
// line segments into the !same! PATH.
{
wxPoint pstart = graphic->GetArcStart();
wxPoint pend = graphic->GetArcEnd();
wxPoint pcenter = graphic->GetCenter();
double angle = -graphic->GetAngle();
int radius = graphic->GetRadius();
int steps = GetArcToSegmentCount( radius, ARC_LOW_DEF, angle / 10.0 );
if( !close_enough( prevPt, pstart, aTolerance ) )
{
wxASSERT( close_enough( prevPt, graphic->GetArcEnd(), aTolerance ) );
angle = -angle;
std::swap( pstart, pend );
}
wxPoint nextPt;
for( int step = 1; step <= steps; ++step )
{
double rotation = ( angle * step ) / steps;
nextPt = pstart;
RotatePoint( &nextPt, pcenter, rotation );
aPolygons.Append( nextPt, -1, hole );
}
prevPt = nextPt;
}
break;
case S_CURVE:
// We do not support Bezier curves in polygons, so approximate
// with a series of short lines and put those
// line segments into the !same! PATH.
{
wxPoint nextPt;
bool reverse = false;
// Use the end point furthest away from
// prevPt as we assume the other end to be ON prevPt or
// very close to it.
if( close_st( prevPt, graphic->GetStart(), graphic->GetEnd() ) )
nextPt = graphic->GetEnd();
else
{
nextPt = graphic->GetStart();
reverse = true;
}
if( reverse )
{
for( int jj = graphic->GetBezierPoints().size()-1; jj >= 0; jj-- )
aPolygons.Append( graphic->GetBezierPoints()[jj], -1, hole );
}
else
{
for( size_t jj = 0; jj < graphic->GetBezierPoints().size(); jj++ )
aPolygons.Append( graphic->GetBezierPoints()[jj], -1, hole );
}
prevPt = nextPt;
}
break;
default:
if( aErrorText )
{
msg.Printf( "Unsupported DRAWSEGMENT type %s.",
BOARD_ITEM::ShowShape( graphic->GetShape() ) );
*aErrorText << msg << "\n";
}
if( aErrorLocation )
*aErrorLocation = graphic->GetPosition();
return false;
}
// Get next closest segment.
graphic = findPoint( prevPt, segList, aTolerance );
// If there are no more close segments, check if polygon
// can be closed.
if( !graphic )
{
if( close_enough( startPt, prevPt, aTolerance ) )
{
// Close the polygon back to start point
// aPolygons.Append( startPt, -1, hole ); // not needed
}
else
{
if( aErrorText )
{
msg.Printf( _( "Unable to find segment with an endpoint of (%s, %s)." ),
StringFromValue( MILLIMETRES, prevPt.x, true ),
StringFromValue( MILLIMETRES, prevPt.y, true ) );
*aErrorText << msg << "\n";
}
if( aErrorLocation )
*aErrorLocation = prevPt;
return false;
}
break;
}
}
}
}
return true;
}
inline bool DiscretizedAsset::isOnTime(Time t) const {
const TimeGrid& grid = method()->timeGrid();
return close_enough(grid[grid.index(t)],time());
}
inline void DiscretizedAsset::postAdjustValues() {
if (!close_enough(time(),latestPostAdjustment_)) {
postAdjustValuesImpl();
latestPostAdjustment_ = time();
}
}
