python numpy ndarray Sınıfı

Giriş
Şu satırları dahil ederiz.

#include <boost/python.hpp>
#include <boost/python/numpy.hpp>

#include <iostream>

namespace bpy = boost::python;
namespace bnp = boost::python::numpy;

Bu sınıf boost::python::object sınıfından kalıtır.

Dinamik linklemek için şöyle yaparız.

-lboost_numpy

Static linklemek için şöyle yaparız.

#define BOOST_LIB_NAME "boost_numpy"
#include <boost/config/auto_link.hpp>

Açıklaması şöyle

That will automatically determine the appropriate library name for your build configuration (such as libboost_numpy-vc120-mt-1_63.lib) and jam in the appropriate #pragma in there to ask the linker to include the library automatically.

This code should probably have been included in boost/python/numpy.hpp and the omission may be a bug there.

constructor - boost::python::list
Şöyle yaparız.

vector<string> strings = {"a","aa","aaa","aaaa"};
bpy::list py_list;
for(auto& s: strings){
  py_list.append(s);
}
bnp::ndarray py_array = bnp::array(py_list);

constructor - tuple
Şöyle yaparız.

bpy::object tu = bpy::make_tuple('a', 'b', 'c');
bnp::ndarray const example_tuple = bnp::array(tu);

Diğer
initialize metodu
Bu metod aslında sınıfın bir parçası değil. Sınıfı kullanmadan önce şöyle yaparız.

bnp::initialize();




spirit lex lexer Sınıfı

Giriş
Şu satırı dahil ederiz.

#include <boost/spirit/include/lex_lexer.hpp>
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/include/lex.hpp>

Şu satırı dahil ederiz.

#include <boost/spirit/include/lex_lexertl.hpp>

Tanımlama
Örnek 1
Token'a bir sayı verir. Şöyle yaparız

// Token ids
enum token_ids {
    ID_EOL= 100
};

// Token definition
template <typename Lexer>
struct var_replace_tokens : boost::spirit::lex::lexer<Lexer> {
  var_replace_tokens() {
    this->self.add ("\n", ID_EOL); // newline characters
  }
};

Örnek 2
Şöyle yaparız.

namespace lex = boost::spirit::lex;

template <typename... T>
struct Lexer : lex::lexer<T...> {
  Lexer() {
    
    // adding it to the lexer
    this->self += ...;
  }
  ...
};

parameter

Giriş
named parameter için sanırım bir çok yöntem geliştirilmiş. Burada yarısını bile anlamadığım değişik bir yazı var.

BOOST_PARAMETER_FUNCTION
Şu satırı dahil ederiz.

#include <boost/parameter/preprocessor.hpp>

named parameter kullanmak içindir. Şöyle yaparız.

namespace graphs
{
  BOOST_PARAMETER_FUNCTION(
      (void),                // 1. parenthesized return type
      depth_first_search,    // 2. name of the function template

      tag,                   // 3. namespace of tag types

      (required (graph, *) ) // 4. one required parameter, and

      (optional              //    four optional parameters, with defaults
        (visitor,           *, boost::dfs_visitor<>())
        (root_vertex,       *, *vertices(graph).first)
        (index_map,         *, get(boost::vertex_index,graph))
        (in_out(color_map), *,
          default_color_map(num_vertices(graph), index_map) )
      )
  )
  {
      // ... body of function goes here...
      // use graph, visitor, index_map, and color_map
  }
}

serialization BOOST_SERIALIZATION_SPLIT_MEMBER

Giriş
Eğer bu macro'yu kullanırsak serialize metodunu ikiye ayırabiliriz. Şu satırı dahil ederiz.

#include <boost/serialization/split_member.hpp>

İstersek şu satırı dahil ederiz.

#include <boost/serialization/access.hpp>

Örnek 1
Normalde şöyle yaparız.

class MyClass {

private:
  double value;

  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int){
    ar & value;
  }
};

Ayırmak için şöyle yaparız.

class MyClass {

private:
  double value;

  friend class boost::serialization::access;
  template<class Archive>
  void save(Archive & ar, const unsigned int) const {
   ar & val;
  }
  template<class Archive>
  void load(Archive & ar, const unsigned int) const {
    ar & value;
  }

  BOOST_SERIALIZATION_SPLIT_MEMBER()
};

Örnek 2
Bu sefer macro an alt yerine en üstte. Şöyle yaparız.

struct values
{
  
  BOOST_SERIALIZATION_SPLIT_MEMBER();

  template<class Archive>
  void save(Archive & ar, const unsigned int version) const
  {
    ...
  }
  template<class Archive>
  void load(Archive & ar, const unsigned int version)
  {
    ...
  }
};

asio linkleme

Giriş
asio header only bir kütüphane. Dolayısıyla boost_asio.so diye şöyle bir kütüphane yok. Şu kod çalışmaz.

$ g++ ... -lboost_system -lboost_date_time -lboost_thread -lboost_asio
/usr/bin/ld: cannot find -lboost_asio
collect2: error: ld returned 1 exit status

Ancak bu kütüphanenin harici bağımlılıklar var.

Gcc
Şöyle yaparız.

g++ ... 
 -lpthread -lboost_system

Eğer OpenSSL kullanıyorsak şu satırlar da dahil edilir.

-lssl -lcrypto -ldl

Visual Studio
Eğer OpenSSL kullanıyorsak şu satırlar da dahil edilir.

-llibeay32 -llibssleay32




graph boost::get metodu

Giriş
Bu metod bir PropertyMap döndürür. Açıklaması burada.

get - Property Tag + graph
Birinci parametre property tag'idir. İkinci parametre Graph nesnesidir. C++11 kullanıyorsak auto değişken tanımlamak en kolayı. Şöyle yaparız.

auto vertexNameMap = boost::get (&boost::vertex_name, g);

Eğer kullanmıyorsak şöyle yaparız.

property_map<Graph, vertex_name_t>::type 
    vertexNameMap = boost::get(&boost::vertex_name, g);

Şöyle yaparız. Önce bir vertex nesnesi elde ederiz. Şöyle yaparız.

typedef boost::graph_traits <...>::vertex_descriptor SV; //Vertex type
SV v = boost::add_vertex (...,...); //We have a vertex now

Daha sonra bu map ile vertex veya edge'lerin property alanlarına erişilebilir. Şöyle yaparız.

vertexNameMap [v] == ...; //Access a property of vertex

get - Property Tag + graph + edge
Elimizde şöyle bir yapı olsun.

struct Edge {
  ...
  //boundary coordinates
  vector<cv::Point> boundary;
  ...

};

0 ve 1 vertex'leri arasındaki edge'e nokta eklemek için şöyle yaparız.

auto& boundary = boost::get(&Edge::boundary, g, boost::edge(0, 1, g));
boundary.emplace_back(2,2);

geometry subtract_point metodu

Giriş
İmzası şöyle

template<typename Point1, typename Point2>
void subtract_point(Point1 & p1, Point2 const & p2)

Şöyle yaparız.

using point = boost::geometry::model::point<int, 2, bg::cs::cartesian>
point p1 (2, 3);
point p2 (5, 7);

subtract_point(p2, p1);

p2 (3,4) değerini alır. Çıktı olarak şunu alırız.

(5,7) - (2,3) = (3,4)