geometry within metodu

within - polygon + polygon
Şöyle yaparız.

using Pt = bg::model::d2::point_xy<int>;
using Poly = bg::model::polygon<Pt>;
using Multi = bg::model::multi_polygon<Poly>;

Poly const a {{ { 0,0 }, { 0,3 }, { 3,3 }, { 3,0 }, { 0,0 }} };
Poly const b {{ { 1,1 }, { 1,2 }, { 2,2 }, { 2,1 }, { 1,1 }} };

return bg::intersects(a, b);

within - franklin 

Açıklaması şöyle.

"If a point is located exactly on the border of a geometry, the result depends on the strategy. The default strategy (Winding (coordinate system agnostic)) returns false in that case."

franklin tam üst üste gelen noktalar için true döner. Şöyle yaparız.

Şu satırı dahil ederiz.

#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>
#include <boost/geometry/geometries/polygon.hpp>

#include <boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp>

Elimizde bir polygon olsun.

typedef boost::geometry::model::d2::point_xy<double> point_type;
typedef boost::geometry::model::polygon<point_type> polygon_type;
typedef boost::geometry::model::segment<point_type> seg;
typedef boost::geometry::strategy::within::franklin
  <point_type, point_type, void> fran;

Bu polygon'u dolduralım.

polygon_type poly;

boost::geometry::read_wkt("POLYGON((2 1.3,2.4 1.7,2.8 1.8,3.4 1.2,...))", poly);

point_type p(4, 1);

Şöyle yaparız.

fran fran_;

cout << "within: " << (boost::geometry::within(p, poly,fran_) ? "yes" : "no");

within metodu ile covered_by sanırım aynı şeyi yapıyorlar.

cout << "within: " << (boost::geometry::covered_by(p, poly) ? "yes" : "no");

Örnek
Şöyle yaparız.

bool is_inside(const polygon& convex_polygon, const point p) noexcept
{
  const auto n = convex_polygon.size();

  const auto sense = determine_side(line{convex_polygon[n - 1], convex_polygon[0]}, p);
  if(sense == side::center)
  {
    return false;
  }

  for(auto i = 0u; i + 1 < n; ++i)
  {
    auto new_sense = determine_side(line{convex_polygon[i], convex_polygon[i + 1]}, p);

    if(new_sense != sense)
    {
      return false;
    }
  }
  return true;
}

format

Giriş
Şu satırı dahil ederiz.

#include <boost/format.hpp>

format kütüphanesi kendi içinde bir ostream kullanır. Formatlama için kullanılan indeksler %1%'den başlar.

wformat sınıfı şöyle tanımlıdır.

typedef basic_format<wchar_t > wformat;

Constructor
Elimizde şöyle değişkenler olsun.

unsigned short vendorID =...;
unsigned short productID = ...;

Bu değişkenleri formatlamak için şöyle yaparız.

boost::format fmt("[Vendor= %1%] [Product= %2%]") % vendorID %productID;

Eğer format string'i hatalıysa boost::bad_format_string atılır.

operator %
Kendi sınıfımızı boost::format ile kullanmak için şöyle yaparız.

#include <boost/format.hpp>
#include <iostream>

struct A
{
    int n;

    A() : n() {}

    friend std::ostream &operator<<(std::ostream &oss, const A &a) {
        oss << "[A]: " << a.n;
    }
};

int main() {
    A a;
    boost::format f("%1%");
    std::cout << f % a << std::endl;
}

str metodu
free style str metodu şöyle kullanılır

boost::str(fmt);

Formatlama Seçenekleri
Format string içinde kullanılan formatlama seçenekleri platformadan bağımsızdır.

1. double için
Yuvarlama gerekiyorsa çift rakama doğru yuvarlamak yapılır ("round half to even")

Örnek
Şöyle yaparız. Çıktı olarak 102262 alırız

double nbr = 102262.5;

boost::format("%.0f") % nbr;

Şöyle yaparız. Çıktı olarak 34088 alırız

double nbr = 34087.5;

boost::format("%.0f") % nbr;

Elimizde şöyle bir kod olsun

double d = 0.0009;

Şöyle yaparız. Çıktı olarak  0.0009 alırız

std::string s = (boost::format("%1$.4f") % d).str();

2. float için
Şöyle yaparız.

format f ("%1$.2f");

Şöyle yaparız

boost::str(boost::format("%0.3f") % 5.453)

Şöyle yaparız. %4.3e gibi bir girdi alır.

#include <boost/format.hpp>

std::string FloatToScientificString(float val, int width, int precision)
{
  const std::string fmt = "%" + std::to_string(width) + "." +
    std::to_string(precision) + "e";

  return boost::str(boost::format(fmt) % val);
}

3. integer için
Şöyle yaparız.

boost::format header("%+3d") % i; // Add "+" when is not negative

4. llx seçeneği
64 bit integer için kullanılır. Şöyle yaparız.

boost::format("0x%016llx") % (unsigned long long)(u64)).str();

iostreams mapped_file Sınıfı

Giriş
Açıklaması şöyle.

It is a memory-mapping API for files, and you can open the same file in multiple processes.

Constructor
Şöyle yaparız.

boost::iostreams::mapped_file file("foo.bin");

data metodu
Şöyle yaparız.

Eigen::Map<Eigen::MatrixXf> matrix(reinterpret_cast<float*>(file.data()), rows, columns);

size metodu
Şöyle yaparız.

const std::size_t rows = 163840;
const std::size_t columns = 163840;
if (rows * columns * sizeof(float) > file.size()) {
  ...
}