SAIGE

https://github.com/weizhouumich/saige
Admin
SAIGE is an R package for scalable and accurate genetic association tests in large cohorts,...
Tokens:14,274,292
Snippets:43,693
Trust Score:6.7
License:LGPL-3.0
Update:1 year ago
Show doc for...
Tokens:
Raw
### Boost Statechart Library - Getting Started

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/statechart/doc/index.html

Instructions for getting started with the Boost Statechart Library, including setting up Boost, compiling examples, and running tests.

```bash
bjam --toolset=_your-toolset_
```

--------------------------------

### Verify Boost.Build Installation

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/bbv2/installation.html

Runs a simple build example to verify that Boost.Build has been installed correctly. Navigate to the examples directory (e.g., `_PREFIX_/share/boost-build/examples/hello`), then execute the `b2` command from your terminal.

```shell
PREFIX/bin/b2
```

--------------------------------

### Program Input Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.rst

Example of piping input to a compiled program.

```bash
echo 1 2 3 | example
```

--------------------------------

### Boost.Proto Users' Guide Structure

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/proto/users_guide.html

Details the organization of the Boost.Proto users' guide, starting with getting started and installation, then covering front ends, intermediate forms, back ends, examples, and resources.

```text
This users' guide is organized as follows. After a [Getting Started guide](users_guide.html#boost_proto.users_guide.getting_started "Getting Started"), we'll cover the tools Proto provides for defining and manipulating the three major parts of a compiler:

[Front Ends](users_guide.html#boost_proto.users_guide.front_end "Fronts Ends: Defining Terminals and Non-Terminals of Your EDSL")
How to define the aspects of your EDSL with which your users will interact directly.

[Intermediate Form](users_guide.html#boost_proto.users_guide.intermediate_form "Intermediate Form: Understanding and Introspecting Expressions")
What Proto expression templates look like, how to discover their structure and access their constituents.

[Back Ends](users_guide.html#boost_proto.users_guide.back_end "Back Ends: Making Expression Templates Do Useful Work")
How to define evaluation contexts and transforms that make expression templates do interesting things.

After that, you may be interested in seeing some [Examples](users_guide.html#boost_proto.users_guide.examples "Examples") to get a better idea of how the pieces all fit together.
```

--------------------------------

### Building with bjam

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/regex/doc/html/boost_regex/install.html

This section highlights bjam as the recommended tool for building and installing the library. It suggests consulting the Boost getting started guide for comprehensive instructions.

```html
<p>This is now the preferred method for building and installing this library, please refer to the [getting started guide](../../../../../more/getting_started.html) for more information.</p>
```

--------------------------------

### BoostBook Setup Script for Unix-like Systems

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/boostbook/getting/started.html

This command executes the BoostBook setup script, which automates the download and configuration of necessary tools like DocBook stylesheets, DTDs, and Apache FOP for PDF output. It also configures Boost.Build v2.

```bash
tools/boostbook/setup_boostbook.sh
```

--------------------------------

### Installing Boost.Build

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Steps to build and install the Boost.Build system. This involves running bootstrap.bat, b2 install with a specified prefix, and updating the system's PATH environment variable.

```bash
1. Go to the directory tools\build\v2 \.
2. Run bootstrap.bat
3. Run b2 install --prefix=_PREFIX_ where _PREFIX_ is the directory where you want Boost.Build to be installed
4. Add _PREFIX_\bin to your PATH environment variable.
```

--------------------------------

### Visual C++ Build with Options

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.rst

Example command for building Boost with specific options using Visual C++.

```bash
b2 --build-dir= "C:\Documents and Settings\dave\build-boost" --build-type=complete msvc stage
```

--------------------------------

### Example Program Execution

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.rst

Command to execute a compiled program, redirecting input from a file.

```bash
*path* \ *to* \ *compiled* \example < *path* \ *to* \ jayne.txt
```

--------------------------------

### Install Boost.Build

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.html

Steps to build and install the Boost.Build system. This involves navigating to the build directory, running a bootstrap script, and then installing it to a specified prefix. The bin directory of the installation prefix needs to be added to the PATH.

```bash
cd tools/build/v2/
./bootstrap.sh
./b2 install --prefix=_PREFIX_
export PATH=_PREFIX_/bin:$PATH
```

--------------------------------

### Getting Started with Boost C++ Libraries

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/index.html

Instructions and links for users to get started with Boost C++ Libraries. It covers installation procedures for different scenarios, including pre-built executables and distribution packages.

```text
If Boost hasn't already been installed on your system, follow the [Getting Started Guide](more/getting_started/index.html) to complete the installation. But if you've reached to this point by installing Boost from a Windows pre-build executable or a pre-built Linux and Unix distribution package, that's already been completed. Likewise, if you're reading this on your organization's internal web server, the installation is probably already complete.
```

--------------------------------

### Installing Boost

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.rst

This command installs the Boost libraries and headers to the configured installation prefix after the bootstrap script has been run. Binaries will be in the 'lib/' subdirectory.

```shell
$ ./b2 install
```

--------------------------------

### Boost Directory Structure

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Illustrates the typical directory structure of a Boost installation on Windows, highlighting key directories like 'boost', 'lib', 'libs', and 'tools'.

```text
boost_1_55_0\ ................._The “boost root directory”_
   index.htm ........._A copy of www.boost.org starts here_
   boost ........................._All Boost Header files_
   lib ....................._precompiled library binaries_
   libs ..........._Tests, .cpp_s_, docs, etc., by library_
     index.html ........_Library documentation starts here_
     algorithm 
     any 
     array 
                     _…more libraries…_
   status ........................._Boost-wide test suite_
   tools ..........._Utilities, e.g. Boost.Build, quickbook, bcp_
   more .........................._Policy documents, etc._
   doc ..............._A subset of all Boost library docs_
```

--------------------------------

### Installing Boost

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.html

After configuring and bootstrapping Boost, this command installs the built libraries. It's recommended to use the --prefix option during bootstrap to specify a custom installation path if you lack write permissions in the system's default directories.

```shell
$ ./b2 install
```

--------------------------------

### Compile and Run tut1 Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/filesystem/doc/tutorial.html

Instructions for compiling and running the tut1 example program on Ubuntu Linux and Microsoft Windows. This involves navigating to the example directory, running a setup script, building the program, and then executing it with a file path.

```bash
# Ubuntu Linux
cd _**boost-root**_/libs/filesystem/example/test
./setup
./bld
./tut1
```

```batch
# Microsoft Windows
cd _**boost-root**_\libs\filesystem\example\test
setup
bld
tut1
```

--------------------------------

### Testing the Compiled C++ Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.rst

This command pipes input to the compiled 'example' executable to test its functionality. It demonstrates how to run the program and verify its output.

```shell
echo 1 2 3 | ./example
```

--------------------------------

### Boost Bootstrap Script

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.html

This command initiates the Boost build process. The --help option displays available configuration options. After selecting options, run bootstrap.sh without --help. Use --prefix to specify an installation directory.

```shell
$ cd _path/to/_boost_1_55_0
$ ./bootstrap.sh --help
```

--------------------------------

### Boost Installation and Decompression

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Recommends downloading Boost archives in .7z format for efficient decompression using 7-Zip, avoiding potential slowness with Windows' built-in decompression for large files.

```text
We recommend downloading [boost_1_55_0.7z](http://www.boost.org/users/history/version_1_55_0.html) and using [7-Zip](http://www.7-zip.org) to decompress it. We no longer recommend .zip files for Boost because they are twice as large as the equivalent .7z files. We don't recommend using Windows' built-in decompression as it can be painfully slow for large archives.
```

--------------------------------

### Boost.Build Help and Options

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Shows how to get help and lists key options for customizing Boost builds, such as showing libraries, including/excluding libraries, and selecting build variants.

```bash
b2 --help
b2 --show-libraries
b2 --with-regex
b2 --without-program_options
b2 release
```

--------------------------------

### Compiling a Simple C++ Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.rst

This command compiles a C++ file named 'example.cpp' using the g++ compiler. It includes the Boost root directory in the include path. The output executable is named 'example'.

```cpp
c++ -I |root| example.cpp -o example
```

--------------------------------

### Building Boost.MPI with bjam

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/mpi/getting_started.html

Commands to build the Boost.MPI library using the Boost.Build system (bjam). Includes options for enabling MPI support and specifying installation paths.

```bash
bjam --with-mpi
bjam --with-mpi install
bjam --with-mpi install --prefix=/path/to/install/location
bjam --debug-configuration
```

--------------------------------

### Linking Boost Libraries from Command Prompt (Visual C++)

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Command-line example for compiling and linking a program with Boost libraries using the Visual C++ compiler. It specifies include paths and library paths.

```bash
cl /EHsc /I _path\to\_boost_1_55_0 example.cpp   **/link /LIBPATH:****C:\Program Files\boost\****boost_1_55_0****\lib**
```

--------------------------------

### Linking Boost.Regex Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

A C++ program demonstrating how to link and use the Boost.Regex library to extract subject lines from standard input.

```cpp
#include <boost/regex.hpp>
#include <iostream>
#include <string>

int main()
{
    std::string line;
    boost::regex pat( "^Subject: (Re: |Aw: )\*(.*)" );

    while (std::cin)
    {
        std::getline(std::cin, line);
        boost::smatch matches;
        if (boost::regex_match(line, matches, pat))
            std::cout << matches[2] << std::endl;
    }
}
```

--------------------------------

### Boost.Build Invocation Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Demonstrates how to invoke the b2 build tool with specific build directory, toolset, and build type options. It also shows multi-line command input.

```bash
b2 --build-dir="C:\\Documents and Settings\\dave\\build-boost" --build-type=complete msvc stage
```

--------------------------------

### Boost Library Linking Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.html

Demonstrates how to link against a Boost library, specifically the Boost.Regex library, with a debug, multithreaded configuration for GCC 3.4.

```bash
-L~/boost/stage/lib/ -lboost_regex-gcc34-mt-d-1_36
```

--------------------------------

### Usage, Compilation, and Headers

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/numeric/odeint/doc/html/odeint/indexes/s03.html

This section details the usage, compilation process, and header file requirements for the project. It serves as a foundational guide for getting started with the codebase.

```html
<a href="../../boost_numeric_odeint/getting_started/usage__compilation__headers.html">Usage, Compilation, Headers</a>
```

--------------------------------

### Setting Environment Variables for Shared Libraries

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.html

Provides examples for setting environment variables to help the system locate shared libraries at runtime.

```bash
# For shells like bash, zsh:
$ VARIABLE_NAME=_path/to/lib/directory:${VARIABLE_NAME}
$ export VARIABLE_NAME

# For csh, tcsh:
$ setenv VARIABLE_NAME _path/to/lib/directory:${VARIABLE_NAME}
```

--------------------------------

### Install Boost.Build

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/bbv2/installation.html

Installs the Boost.Build system to a specified directory. Replace `_PREFIX_` with your desired installation path. This command should be run from the root of the unpacked release or the `tools/build/v2` directory if bundled with Boost C++ Libraries.

```shell
./b2 install --prefix=_PREFIX_
```

--------------------------------

### Include Directives for Boost Headers

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Demonstrates how to include Boost headers in C++ code, given the standard Boost directory structure and include path setup.

```cpp
#include <boost/config.hpp>
#include <boost/filesystem.hpp>
```

--------------------------------

### Boost.Lambda Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

A C++ program that reads integers from standard input, multiplies each by three using Boost.Lambda, and writes the results to standard output. It requires the Boost.Lambda library.

```cpp
#include <boost/lambda/lambda.hpp>
#include <iostream>
#include <iterator>
#include <algorithm>

int main()
{
    using namespace boost::lambda;
    typedef std::istream_iterator<int> in;

    std::for_each(
        in(std::cin), in(), std::cout << (_1 * 3) << " ");
}
```

--------------------------------

### Install Docutils

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/mpl/doc/src/README.txt

Installs the Docutils library from its source directory. This is a prerequisite for building the documentation.

```python
python setup.py install
```

--------------------------------

### Example Usage of Grammars

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/proto/users_guide.html

An example `main` function demonstrating the usage of the `input_output` function with different I/O expressions, showcasing how the grammars correctly identify input and output operations.

```cpp
proto::terminal< std::istream & >::type cin_ = { std::cin };
proto::terminal< std::ostream & >::type cout_ = { std::cout };

int main()
{
    int i = 0;
    input_output( cout_ << 1 );
    input_output( cin_ >> i );

    return 0;
}
```

--------------------------------

### Linking Boost.MPI Applications

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/mpi/getting_started.html

Example C++ compilation commands for linking applications that use Boost.MPI and Boost.Serialization. It shows how to include necessary header paths and link against the Boost.MPI and Boost.Serialization libraries, including specific variants for different build configurations (e.g., static, dynamic, debug, multithreaded).

```c++
mpic++ -I/path/to/boost/mpi my_application.cpp -Llibdir \
  -lboost_mpi-gcc-mt-1_35 -lboost_serialization-gcc-d-1_35.a
```

--------------------------------

### Boost.Build Invocation Options

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Provides a reference for common Boost.Build invocation options and their purposes.

```APIDOC
b2 invocation:
  b2 [options] [targets]

Common Options:
  --build-dir=<directory> : Specifies the build directory.
  toolset=<toolset-name>  : Specifies the toolset to use (e.g., msvc, gcc).
  --build-type=<type>     : Specifies the build type (e.g., complete, minimal).
  --stagedir=<directory>  : Specifies the directory to place staged binaries.
  --help                  : Displays help information and available options.
  --show-libraries        : Lists all available Boost libraries.
  --with-<library-name>   : Includes only the specified library.
  --without-<library-name>: Excludes the specified library.
  <variant>               : Adds a build variant (e.g., release, debug).

Example:
  b2 --build-dir=my_build toolset=gcc --build-type=complete stage

Note:
  b2 is case-sensitive. Options and targets should generally be in lowercase.
```

--------------------------------

### Boost.Build Output Redirection

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Illustrates how to redirect the build output to a log file for easier problem diagnosis.

```bash
b2 --build-type=complete stage >build.log 2>&1
```

--------------------------------

### Boost.MPI Testing with LAM/MPI

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/mpi/getting_started.html

Specific instructions for testing Boost.MPI when using LAM/MPI. Requires starting the LAM/MPI daemon before running bjam.

```bash
lamboot
bjam
```

--------------------------------

### Saige Project Tutorial Steps

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/tools/auto_index/doc/html/boost_autoindex/tut.html

Outlines the sequential steps involved in using the Saige project for documentation indexing, from initial build to final refinement.

```html
[Step 1: Build the AutoIndex tool](tut/build.html)
[Step 2: Configure Boost.Build jamfile to use AutoIndex](tut/configure.html)
[Available Indexing Options](tut/configure/options.html)
[Making AutoIndex optional](tut/configure/optional.html)
[Step 3: Add indexes to your documentation](tut/add_indexes.html)
[Step 4: Create the .idx script file - to control what to terms to index](tut/script.html)
[Step 5: Add Manual Index Entries to Docbook XML - Optional](tut/entries.html)
[Step 6: Using XML processing instructions to control what gets indexed.](tut/pis.html)
[Step 7: Build the Docs](tut/build_docs.html)
[Step 8: Iterate - to refine your index](tut/refine.html)
```

--------------------------------

### Getting Started with Program Options

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/program_options/tutorial.html

Demonstrates the basic setup for handling command-line options using Boost.Program_options. It includes declaring options, parsing them, and accessing their values. This example assumes the `boost::program_options` namespace is aliased as `po`.

```cpp
namespace po = boost::program_options;

// Declare the supported options.
po::options_description desc("Allowed options");
desc.add_options()
    ("help", "produce help message")
    ("compression", po::value<int>(), "set compression level")
;

po::variables_map vm;
po::store(po::parse_command_line(ac, av, desc), vm);
po::notify(vm);    

if (vm.count("help")) {
    cout << desc << "\n";
    return 1;
}

if (vm.count("compression")) {
    cout << "Compression level was set to " 
 << vm["compression"].as<int>() << ".\n";
} else {
    cout << "Compression level was not set.\n";
}
```

--------------------------------

### Running Compiled Program

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.rst

Shows how to execute a compiled program after setting the necessary runtime library paths.

```bash
$ path/to/compiled/example < path/to/jayne.txt
```

--------------------------------

### Build from Command Prompt

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.rst

Instructions for opening the Visual Studio command prompt and initiating a build process for the Saige project.

```shell
From your computer's *Start* menu, if you are a Visual
  Studio 2005 user, select

  *All Programs* > *Microsoft Visual Studio 2005*
  > *Visual Studio Tools* > *Visual Studio 2005 Command Prompt*

or, if you're a Visual Studio .NET 2003 user, select

  *All Programs* > *Microsoft Visual Studio .NET 2003*
  > *Visual Studio .NET Tools* > *Visual Studio .NET 2003 Command Prompt*

to bring up a special `command prompt`_ window set up for the
Visual Studio compiler.  In that window, set the `current
directory`_ to a suitable location for creating some temporary
files and type the following command followed by the Return key:

.. parsed-literal::
```

--------------------------------

### Configuring Boost Installation Prefix

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.rst

This command runs the Boost.Build bootstrap script with a custom installation prefix. This is useful when you don't have write permissions to the system's default installation directory (e.g., /usr/local/).

```shell
$ ./bootstrap.sh --prefix= *path* / *to* / *installation* / *prefix*
```

--------------------------------

### Basic Compilation Command

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.rst

A basic compilation command for a C++ file using cl.exe.

```cpp
cl /EHsc /I |root| *path* \ *to* \ *example.cpp
```

--------------------------------

### Command Prompt Basics

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.rst

Explains fundamental Windows command prompt operations, including changing directories and continuing long commands.

```shell
cd *path* \
 *to* \
 *some* \
 *directory*

cd |default-root|
```

--------------------------------

### Boost.MPI Documentation

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/libraries.html

Documentation for the Boost.MPI library, including introduction, getting started guide, tutorial, reference, and Python bindings.

```html
<a href="mpi.html">20. Boost.MPI</a>
<a href="mpi.html#mpi.intro">Introduction</a>
<a href="mpi/getting_started.html">Getting started</a>
<a href="mpi/tutorial.html">Tutorial</a>
<a href="mpi/reference.html">Reference</a>
<a href="mpi/python.html">Python Bindings</a>
```

--------------------------------

### Saige Project Tutorial Navigation

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/chrono/users_guide.html

Provides navigation links to different sections of the Saige project tutorial, covering topics like Hello World, Duration, Clocks, Time Point, Specific Clocks, and I/O.

```text
Hello World!

Tutorial
  Duration
  Clocks
  Time Point
  Specific Clocks
  I/O
```

--------------------------------

### Stepper Algorithms Overview

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/numeric/odeint/doc/html/odeint/indexes/s03.html

An overview of stepper algorithms used in ODE integration, presented as a table within the Boost.Odeint getting started guide.

```APIDOC
Stepper Algorithms Overview:
  Description: Provides a summary of various stepper algorithms for ODE solvers.
  Context: Boost.Odeint getting started guide.
  Related: getting_started.overview.stepper_algorithms
```

--------------------------------

### Bootstrap Boost.Build

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/bbv2/installation.html

Initializes the Boost.Build system. This step prepares the build environment. Use `bootstrap.bat` on Windows and `./bootstrap.sh` on other operating systems.

```batch
.\bootstrap.bat
```

```shell
./bootstrap.sh
```

--------------------------------

### Getting b2 Help and Build Options

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.html

Shows how to access the help information for the b2 build tool to discover available options. It highlights useful options for managing build time and scope, such as '--show-libraries', '--with-library-name', '--without-library-name', and adding 'release' or 'debug' to select specific build variants.

```bash
b2 --help

# Useful options:
# --show-libraries: List available libraries
# --with-library-name: Include a specific library
# --without-library-name: Exclude a specific library
# Adding 'release' or 'debug' to select build variants
```

--------------------------------

### Precompiled Headers in Boost

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Explains that while using Boost with precompiled headers is possible, the provided instructions avoid them to prevent Visual Studio-specific code changes in the examples.

```text
There's no problem using Boost with precompiled headers; these instructions merely avoid precompiled headers because it would require Visual Studio-specific changes to the source code used in the examples.
```

--------------------------------

### Hello, World! Example (Preferred Syntax)

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/signals/tutorial.html

Demonstrates a basic 'Hello, World!' example using Boost.Signals with the preferred syntax. It shows how to define a slot, create a signal, connect the slot to the signal, and invoke the signal to call the slot.

```cpp
struct HelloWorld 
{
  void operator()() const 
  { 
    std::cout << "Hello, World!" << std::endl;
  }
};

// ...

// Signal with no arguments and a void return value
[boost::signal](../boost/signal.html "Class template signal")<void ()> sig;

// Connect a HelloWorld slot
HelloWorld hello;
sig.[connect](../boost/signalN.html#idp60505848-bb)(hello);

// Call all of the slots
sig();
```

--------------------------------

### Visual C++ Build Commands

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.rst

Commands to prepare and invoke the Boost.Build system for compiling Boost libraries with Visual C++.

```bash
bootstrap
./b2
```

--------------------------------

### Running Boost Documentation Build

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/boostbook/getting/started.html

This section provides commands for building Boost documentation using bjam. It covers generating default HTML, single-file HTML, man pages, and multiple formats simultaneously. It also mentions potential warnings during the build process.

```bash
# Build default HTML documentation
bjam

# Build single-file HTML documentation
bjam onehtml

# Build Unix man pages
bjam man

# Build multiple formats (e.g., HTML, man, DocBook)
bjam html man docbook
```

--------------------------------

### Basic Installation and Usage of BGEN Tools

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/README.md

This snippet demonstrates the fundamental steps to download, compile, and test the BGEN library and its associated tools from the command line. It covers fetching the source code, configuring the build, compiling, and running basic tests and utility commands.

```bash
$ # get it
$ wget http://bitbucket.org/gavinband/bgen/get/master.tar.gz
$ cd bgen
$ # compile it
$ ./waf configure
$ ./waf
$ # test it
$ ./build/test/unit/test_bgen
$ ./build/apps/bgenix -g example/example.16bits.bgen -list
```

--------------------------------

### Extracting Boost Distribution

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.rst

This command extracts the Boost distribution archive using bzip2. It assumes you have downloaded the tarball and are in the directory where you want to install Boost.

```shell
tar --bzip2 -xf */path/to/*|boost_ver|.tar.bz2
```

--------------------------------

### Build from Visual Studio IDE

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.rst

Steps to configure a Visual C++ Win32 Console Application project in Visual Studio to build the Saige project, including setting include directories and precompiled header options.

```cpp
In *Configuration Properties* > *C/C++* > *General* > *Additional Include Directories*, enter the path to the Boost root directory, for example

    |default-root|

In *Configuration Properties* > *C/C++* > *Precompiled Headers*, change
  *Use Precompiled Header (/Yu)* to *Not Using Precompiled
  Headers*. [#pch]_
```

--------------------------------

### Building Boost Libraries with Boost.Build

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Commands to build Boost libraries from source using the Boost.Build system. The 'bootstrap' command prepares the build system, and './b2' invokes the build process.

```bash
bootstrap
.\b2
```

--------------------------------

### Implementation of flipped_up_down_view

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/gil/doc/doxygen/design_guide.dox

Example implementation of a view transformation function, specifically `flipped_up_down_view`. It creates a view with negated y-step, starting from the bottom-left pixel of the source view.

```C++
template <typename View>
typename dynamic_y_step_type<View>::type flipped_up_down_view(const View& src) {
    gil_function_requires<ImageViewConcept<View> >();
    typedef typename dynamic_y_step_type<View>::type RView;
    return RView(src.dimensions(),typename RView::xy_locator(src.xy_at(0,src.height()-1),-1));
}
```

--------------------------------

### Boost.Build Configuration for DocBook

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/boostbook/getting/started.html

This snippet illustrates how to configure Boost.Build (BBv2) to use local distributions of DocBook XSL stylesheets and DTDs. This configuration helps in improving the processing time for generating documentation.

```jam
#  BoostBook configuration
using boostbook 
  : DOCBOOK_XSL_DIR
  : DOCBOOK_DTD_DIR
  ;

```

--------------------------------

### Ratio I/O Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/ratio/users_guide.html

Demonstrates how to use `ratio_string` to get the prefix and symbol for SI prefixes and custom ratios. It shows the usage with `char` as the character type for UTF-8 encoding.

```c++
#include <boost/ratio/ratio_io.hpp>
#include <iostream>

int main()
{
    using namespace std;
    using namespace boost;

    cout << "ratio_string<deca, char>::prefix() = "
         <<  ratio_string<deca, char>::prefix() << '\n';
    cout << "ratio_string<deca, char>::symbol() = "
         <<  ratio_string<deca, char>::symbol() << '\n';

    cout << "ratio_string<giga, char>::prefix() = "
         <<  ratio_string<giga, char>::prefix() << '\n';
    cout << "ratio_string<giga, char>::symbol() = "
         <<  ratio_string<giga, char>::symbol() << '\n';

    cout << "ratio_string<ratio<4, 6>, char>::prefix() = "
         <<  ratio_string<ratio<4, 6>, char>::prefix() << '\n';
    cout << "ratio_string<ratio<4, 6>, char>::symbol() = "
         <<  ratio_string<ratio<4, 6>, char>::symbol() << '\n';
}
```

--------------------------------

### Quick Start Sample

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/wave/doc/samples.html

Demonstrates the minimal usage of the Wave preprocessor library. It processes a given input file, outputs textual tokens, and is suitable for beginners without complex configurations.

```bash
quick_start <input_file>
```

--------------------------------

### Boost.Lambda Namespace Conventions

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/lambda/getting_started.html

This section outlines the namespace conventions used within the Boost.Lambda library. It also shows how to use implicit using declarations for common namespaces in code examples.

```C++
// All definitions are placed in the namespace boost::lambda and its subnamespaces.

// In code examples, implicit using declarations are often assumed:
// using namespace std;
// using namespace boost::lambda;
```

--------------------------------

### Documentation and Example Updates

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/statechart/doc/future_and_history.html

This entry details updates to documentation sections, including 'Speed versus scalability tradeoffs', moving 'Incompatible compilers' to index.html, adding explanations for BitMachine & Handcrafted examples, and fixing previously failing builds of single-threaded PingPong examples.

```C++
// Updated the "Speed versus scalability tradeoffs" section.
// Moved the "Incompatible compilers" section to index.html.
// Added explanation for the BitMachine & Handcrafted examples.
// Fixed previously failing builds of single-threaded variants of the PingPong example.
```

--------------------------------

### Testing a Compiled C++ Application

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/windows.html

Instructions for testing a compiled C++ application by providing input via standard input.

```bash
echo 1 2 3 | example
```

--------------------------------

### Linking Boost.MPI Python Bindings

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/mpi/getting_started.html

Example C++ compilation command for linking applications that use Boost.MPI with its Python bindings. It includes linking against the `boost_mpi_python` library, which is necessary for specific Python integration features.

```c++
-lboost_mpi_python-gcc-mt-1_35
```

--------------------------------

### Boost Pool Usage and Installation

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/pool/doc/html/boost_pool/indexes/s04.html

Information on how to use the Boost Pool library, including necessary headers and installation steps. Covers including the library and setting up the build environment.

```APIDOC
Boost Pool Usage:

Headers:
  - <boost/pool/pool_alloc.hpp>
  - <boost/pool/object_pool.hpp>
  - <boost/pool/singleton_pool.hpp>

Installation:
  - Ensure Boost libraries are installed and accessible.
  - Include the relevant Boost Pool headers in your C++ project.
  - Compile your project with the Boost libraries linked.
```

--------------------------------

### Include Directive for Boost Headers

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.html

Example of how to include Boost library headers in a C++ program. It demonstrates the standard convention for referencing Boost headers, typically within the 'boost/' namespace.

```cpp
#include <boost/_whatever_.hpp>

or

#include "boost/_whatever_.hpp"
```

--------------------------------

### Inlining a Parser in Parse Function Call

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/spirit/classic/doc/quick_start.html

This example demonstrates inlining a parser directly into the parse function call. The expression evaluates to a temporary, unnamed parser that is used and then destroyed. This is an alternative to storing the parser in a named rule.

```C++
parse_info<> pi = parse("123,456", real_p >> ch_p(',') >> int_p, space_p);
```

--------------------------------

### Hello, World! Example (Portable Syntax)

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/signals/tutorial.html

Demonstrates a basic 'Hello, World!' example using Boost.Signals with the portable syntax. It shows how to define a slot, create a signal, connect the slot to the signal, and invoke the signal to call the slot.

```cpp
struct HelloWorld 
{
  void operator()() const 
  {
    std::cout << "Hello, World!" << std::endl;
  }
};

// ...

// Signal with no arguments and a void return value
[boost::signal0](../boost/signalN.html "Class template signalN")<void> sig;

// Connect a HelloWorld slot
HelloWorld hello;
sig.[connect](../boost/signalN.html#idp60505848-bb)(hello);

// Call all of the slots
sig();
```

--------------------------------

### Get Coordinate of a Point

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/geometry/doc/html/geometry/reference/access/get/get_1.html

Example demonstrating how to use the Boost.Geometry 'get' function to retrieve the x and y coordinates of a 2D point.

```cpp
#include <iostream>
#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point_xy.hpp>

namespace bg = boost::geometry;

int main()
{
    bg::model::d2::point_xy<double> point(1, 2);

    double x = bg::get<0>(point);
    double y = bg::get<1>(point);

    std::cout << "x=" << x << " y=" << y << std::endl;

    return 0;
}

```

--------------------------------

### Boost.Regex Example Program

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.html

A simple C++ program that utilizes the Boost.Regex library to extract subject lines from standard input. It demonstrates the inclusion of the Boost.Regex header and the usage of `boost::regex` and `boost::regex_match` for pattern matching.

```c++
#include <boost/regex.hpp>
#include <iostream>
#include <string>

int main()
{
    std::string line;
    boost::regex pat( "^Subject: (Re: |Aw: )*(.*)" );

    while (std::cin)
    {
        std::getline(std::cin, line);
        boost::smatch matches;
        if (boost::regex_match(line, matches, pat))
            std::cout << matches[2] << std::endl;
    }
}
```

--------------------------------

### Linking Program with a Specific Boost Library

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/more/getting_started/unix-variants.rst

This command demonstrates linking a C++ program ('example') against a specific Boost library file (libboost_regex-gcc34-mt-d-1_36.a). It uses the '-L' flag to specify the library search path and '-l' to specify the library name.

```cpp
$ c++ -I |root| example.cpp -o example \
   ~/boost/stage/lib/libboost_regex-gcc34-mt-d-1_36.a
```

--------------------------------

### Boost.MPI Testing with MPICH2

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/mpi/getting_started.html

Instructions for testing Boost.MPI with MPICH2. May require creating a machine file and passing specific flags to Boost.Jam.

```bash
# Create a machine file (e.g., machine.conf)
# Example content:
# localhost
# localhost

bjam -sMPIRUN_FLAGS="-machinefile machine.conf"
```

--------------------------------

### Find Maximum Value using Boost Accumulators

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/accumulators/user_s_guide.html

Illustrates how to find the maximum value from a set of samples using the Boost Accumulators library. The `max` accumulator tracks the largest value encountered. This example shows the setup and extraction of the maximum value.

```cpp
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/max.hpp>
#include <boost/test/unit_test.hpp>

// Using namespace for brevity
using namespace boost::accumulators;

// Define an accumulator set with the max tag
accumulator_set<int, stats<tag::max>> acc;

// Add samples
acc(1);
BOOST_CHECK_EQUAL(1, (max)(acc));

acc(0);
BOOST_CHECK_EQUAL(1, (max)(acc));

acc(2);
BOOST_CHECK_EQUAL(2, (max)(acc));
```

--------------------------------

### Boost.IOStreams get Function Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/iostreams/doc/functions/get.html

Illustrates the usage of the 'get' function within a custom input filter definition for converting characters to lowercase.

```cpp
#include <ctype.h>
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/operations.hpp>

using namespace std;
using namespace boost::io;

struct tolower_filter : public input_filter {
    template<typename Source>
    int get(Source& src)
    {
        int c;
        return (c = boost::iostreams::get(src)) != EOF &&
                c != WOULD_BLOCK 
                    ? 
            tolower((unsigned char) c) :
            c;
    }
};
```

--------------------------------

### Boost.Locale Hello World Example (C++)

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/libs/locale/doc/html/examples.html

A basic "Hello, World!" example demonstrating the setup and usage of Boost.Locale for internationalized output.

```cpp
#include <boost/locale.hpp>
#include <iostream>

int main() {
    boost::locale::generator gen;
    std::locale::global(gen("")); // Use default locale
    std::cout.imbue(std::locale());

    std::cout << boost::locale::translate("Hello, World!") << std::endl;

    return 0;
}
```

--------------------------------

### Weighted P-Square Quantile Accumulator Example

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/accumulators/user_s_guide.html

Demonstrates the usage of the weighted_p_square_quantile accumulator for estimating quantiles with weighted samples. It includes setup for random number generation, accumulator initialization with different quantile probabilities, data accumulation, and checks for expected quantile values.

```cpp
#include <boost/accumulators/statistics/weighted_p_square_quantile.hpp>
#include <boost/accumulators/accumulators.hpp>
#include <boost/random/lagged_fibonacci.hpp>
#include <boost/random/normal_distribution.hpp>
#include <cmath>
#include <cstddef>

// For testing purposes, assuming BOOST_CHECK_CLOSE is available
// #define BOOST_CHECK_CLOSE(a, b, c) /* implementation */

// Define the accumulator type
typedef boost::accumulators::accumulator_set<double, boost::accumulators::stats<boost::accumulators::tag::weighted_p_square_quantile>, double> accumulator_t;

// tolerance in %
double epsilon = 1;

// some random number generators
double mu4 = -1.0;
double mu5 = -1.0;
double mu6 = 1.0;
double mu7 = 1.0;
boost::lagged_fibonacci607 rng;
boost::normal_distribution<> mean_sigma4(mu4, 1);
boost::normal_distribution<> mean_sigma5(mu5, 1);
boost::normal_distribution<> mean_sigma6(mu6, 1);
boost::normal_distribution<> mean_sigma7(mu7, 1);
boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal4(rng, mean_sigma4);
boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal5(rng, mean_sigma5);
boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal6(rng, mean_sigma6);
boost::variate_generator<boost::lagged_fibonacci607&, boost::normal_distribution<> > normal7(rng, mean_sigma7);

// Initialize accumulators with different quantile probabilities
accumulator_t acc0(boost::accumulators::quantile_probability = 0.001);
accumulator_t acc1(boost::accumulators::quantile_probability = 0.025);
accumulator_t acc2(boost::accumulators::quantile_probability = 0.975);
accumulator_t acc3(boost::accumulators::quantile_probability = 0.999);

accumulator_t acc4(boost::accumulators::quantile_probability = 0.001);
accumulator_t acc5(boost::accumulators::quantile_probability = 0.025);
accumulator_t acc6(boost::accumulators::quantile_probability = 0.975);
accumulator_t acc7(boost::accumulators::quantile_probability = 0.999);

// Accumulate data
for (std::size_t i=0; i<100000; ++i)
{
    double sample = rng();
    acc0(sample, boost::accumulators::weight = 1.);
    acc1(sample, boost::accumulators::weight = 1.);
    acc2(sample, boost::accumulators::weight = 1.);
    acc3(sample, boost::accumulators::weight = 1.);

    double sample4 = normal4();
    double sample5 = normal5();
    double sample6 = normal6();
    double sample7 = normal7();
    acc4(sample4, boost::accumulators::weight = std::exp(-mu4 * (sample4 - 0.5 * mu4)));
    acc5(sample5, boost::accumulators::weight = std::exp(-mu5 * (sample5 - 0.5 * mu5)));
    acc6(sample6, boost::accumulators::weight = std::exp(-mu6 * (sample6 - 0.5 * mu6)));
    acc7(sample7, boost::accumulators::weight = std::exp(-mu7 * (sample7 - 0.5 * mu7)));
}

// Check results (assuming BOOST_CHECK_CLOSE is defined elsewhere)
// BOOST_CHECK_CLOSE( boost::accumulators::weighted_p_square_quantile(acc0), 0.001, 15 );
// BOOST_CHECK_CLOSE( boost::accumulators::weighted_p_square_quantile(acc1), 0.025, 5 );
// BOOST_CHECK_CLOSE( boost::accumulators::weighted_p_square_quantile(acc2), 0.975, epsilon );
// BOOST_CHECK_CLOSE( boost::accumulators::weighted_p_square_quantile(acc3), 0.999, epsilon );

// check for shifted standard normal distribution ("importance sampling")
// BOOST_CHECK_CLOSE( boost::accumulators::weighted_p_square_quantile(acc4), -3.090232, epsilon );
// BOOST_CHECK_CLOSE( boost::accumulators::weighted_p_square_quantile(acc5), -1.959963, epsilon );
// BOOST_CHECK_CLOSE( boost::accumulators::weighted_p_square_quantile(acc6),  1.959963, epsilon );
// BOOST_CHECK_CLOSE( boost::accumulators::weighted_p_square_quantile(acc7),  3.090232, epsilon );

```

--------------------------------

### Calculate Kurtosis using Boost Accumulators

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/accumulators/user_s_guide.html

Demonstrates how to calculate the kurtosis of a sample distribution using the Boost Accumulators library. Kurtosis measures the 'tailedness' of the probability distribution. This example shows the setup of an accumulator set with the kurtosis tag and how to extract the kurtosis value.

```cpp
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/kurtosis.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/moment.hpp>
#include <boost/test/unit_test.hpp>

// Using namespace for brevity
using namespace boost::accumulators;

// Define the accumulator set with kurtosis, mean, and moments
accumulator_set<int, stats<tag::kurtosis, tag::mean, tag::moment<2>, tag::moment<3>, tag::moment<4>>> acc;

// Add samples to the accumulator
acc(2);
acc(7);
acc(4);
acc(9);
acc(3);

// Verify results using BOOST_CHECK_EQUAL and BOOST_CHECK_CLOSE
BOOST_CHECK_EQUAL( mean(acc), 5 );
BOOST_CHECK_EQUAL( accumulators::moment<2>(acc), 159./5. );
BOOST_CHECK_EQUAL( accumulators::moment<3>(acc), 1171./5. );
BOOST_CHECK_EQUAL( accumulators::moment<4>(acc), 1863 );
BOOST_CHECK_CLOSE( kurtosis(acc), -1.39965397924, 1e-6 );
```

--------------------------------

### Hello World: Expression Template and Evaluation

Source: https://github.com/weizhouumich/saige/blob/master/thirdParty/bgen/3rd_party/boost_1_55_0/doc/html/proto/users_guide.html

A basic example demonstrating how to build an expression template and evaluate it using the proto library. It includes necessary headers and a simple evaluation function.

```cpp
#include <iostream>
#include <boost/proto/core.hpp>
#include <boost/proto/context.hpp>
// This #include is only needed for compilers that use typeof emulation:
#include <boost/typeof/std/ostream.hpp>
namespace proto \= boost::proto;

proto::terminal< std::ostream & \>::type cout_ \= {std::cout};

template< typename Expr >
void evaluate( Expr const & expr )
{
    proto::default_context ctx;
    proto::eval(expr, ctx);
}

int main()
{
    evaluate( cout_ << "hello" << ',' << " world" );
    return 0;
}
```
Tokens:
Raw