Welcome to biicode¶

Which source code files are part of the block’s library¶

BII_LIB_SRC contains all the source code biicode adds to the library (through CMake add_library)

EXAMPLE: Exclude my_file.cpp from being compiled in the block’s library.

# Remove my_file.cpp from being compiled in library
LIST(REMOVE_ITEM BII_LIB_SRC my_file.cpp)

ADD_BII_TARGETS()

EXAMPLE: Include other_file.cpp to be compiled in the block library.

# Include my_file.cpp to be compiled in library
LIST(APPEND BII_LIB_SRC other_file.cpp)

ADD_BII_TARGETS()

ESSENTIAL TIP: If biicode did not add a file needed to your block’s library, you could specify this dependency in the [dependencies] section of the biicode.conf file. Why? This way you wire the dependency (fixing the dependency graph). If someone depends on your library, biicode will also download the missing file and will add it to BII_LIB_SRC automatically. Otherwise file won’t be downloadedm and their build will fail.

Choose STATIC or SHARED library¶

BII_LIB_TYPE value is empty by default (turns out it is STATIC in most cases). It can be either STATIC or SHARED.

EXAMPLE: Making a shared library (.dll, .so):

SET(BII_LIB_TYPE SHARED)

ADD_BII_TARGETS()

Modify which executable targets are made¶

BII_BLOCK_EXES List of executable targets (mains). Each “exe” matches this pattern: path_to_mainfile.

For example, if the block lasote/game has a main.cpp in a folder named “src”, the variable has an element: “src_main”

EXAMPLE: Prevent biicode from creating an EXE target for (examples/src/my_program.cpp):

LIST(REMOVE_ITEM BII_BLOCK_EXES examples_src_my_program)

ADD_BII_TARGETS()

You can also do this by adding !examples_src_my_program line to [mains] section of biicode.conf.

Which source code files are part of each executable¶

BII_exe_name_SRC contains all source code that will be added to the exe. “exe_name” matches this pattern: path_to_mainfile.

For example, if the block lasote/game has a main.cpp in a folder named “src” the variable is: “BII_src_main_SRC“

EXAMPLE: Exclude my_file.cpp from being compiled with examples/main.cpp executable.

LIST(REMOVE_ITEM BII_examples_main_SRC my_file.cpp)

ADD_BII_TARGETS()

Modify which test targets are made¶

BII_BLOCK_TESTS is a subset of BII_BLOCK_EXES and contains the executables specified in [tests] section of biicode.conf file.

EXAMPLE: Exclude tests/one.cpp from tests.

LIST(REMOVE_ITEM BII_BLOCK_TESTS tests_one)

ADD_BII_TARGETS()

Configure library target¶

BII_LIB_TARGET contains the name of the block’s library target. This target may be an INTERFACE target (no source files) if BII_LIB_SRC is empty before ADD_BIICODE_TARGETS call. For this reason we recommend you to always use BII_BLOCK_TARGET.

BII_BLOCK_TARGET: Use this better, instead of BII_LIB_TARGET. Created to ease target configuration. It always exists and it is always a CMake Interface. Represents the whole block, and it is applied to BII_LIB_TARGET and each target executable.

EXAMPLE: Linking with pthread.

# Link against the always existing BII_BLOCK_TARGET
TARGET_LINK_LIBRARIES(${BII_BLOCK_TARGET} INTERFACE pthread)
# or link against the library (if it's not an interface we specify PUBLIC attribute to propagate the configuration)
TARGET_LINK_LIBRARIES(${BII_LIB_TARGET} PUBLIC pthread)

You can also do this by adding pthread to ${BII_LIB_DEPS} before calling ADD_BII_TARGETS()

EXAMPLE: Adding include directories to all targets of this block.

TARGET_INCLUDE_DIRECTORIES(${BII_BLOCK_TARGET} INTERFACE myincludedir)

# You can also add private include directories to the Lib (if existing)
TARGET_INCLUDE_DIRECTORIES(${BII_LIB_TARGET} PRIVATE myincludedir)

You can also do this by adding myincludedir line to [paths] section of biicode.conf.

EXAMPLE: How to activate C++11 for all targets (including lib target).

IF(APPLE)
   TARGET_COMPILE_OPTIONS(${BII_BLOCK_TARGET} INTERFACE "-std=c++11 -stdlib=libc++")
ELSEIF (WIN32 OR UNIX)
   TARGET_COMPILE_OPTIONS(${BII_BLOCK_TARGET} INTERFACE "-std=c++11")
ENDIF(APPLE)

EXAMPLE: Adding compile definitions to all targets (including lib target).

TARGET_COMPILE_DEFINITIONS(${BII_BLOCK_TARGET} PUBLIC "MY_DEFINITION=1")

EXAMPLE: Setting properties to lib target.

SET_TARGET_PROPERTIES(${BII_LIB_TARGET} PROPERTIES COMPILE_DEFINITIONS "IOV_MAX=255")

SET_TARGET_PROPERTIES only allows setting some white-listed properties to BII_BLOCK_TARGET, because it is an interface. Use BII_LIB_TARGET to set target properties.

Configure executable target¶

BII_exe_name_TARGET contains the name of the target for each executable target. Each “exe” matches this pattern: path_to_mainfile.

EXAMPLE: Linking pthread to an executable target (file: examples/one.cpp):

TARGET_LINK_LIBRARIES(${BII_examples_one_TARGET} PUBLIC pthread)

EXAMPLE: Adding compile definitions to an executable target (file: my_main.cpp).

TARGET_COMPILE_DEFINITIONS(${BII_my_main_TARGET} PUBLIC "MY_DEFINITION=1")

When someone depends on your library, biicode only downloads the required files (according to the dependency graph). So you can not assume that ${BII_my_main_TARGET} target will exist. It may seem obvious, but if you reference a target that doesn’t exist build fails. When possible it’s better to not act upon EXE targets. Remember that BII_BLOCK_TARGET will be applied to each target in your block.

It is best to act upon BII_BLOCK_TARGET.

Simple Layout¶

Place your repo’s code directly in your project’s folder. Use bii init -L .

~$ bii init myproject -L

Creates a simple folder structure in which deps/ , build/ and cmake/ folders - all auxiliary folders but bin/ - are inside bii/ folder:

+-- myproject/
|    +-- bii/
|    |    +-- layout.bii
|    |    +-- policies.bii
|    |    +-- settings.bii

in which layout.bii content is:

# Minimal layout, with all auxiliary folders inside "bii" and
# The binary "bin" folder as is, and enabled code edition in the project root
cmake: bii/cmake
lib: bii/lib
build: bii/build

deps: bii/deps
# Setting this to True enables directly editing in the project root
# instead of blocks/youruser/yourblock
# the block will be named as your project folder
auto-root-block: True

For example, this is a project with simple layout :

+-- myproject/
|    +-- bii/
|    |    +-- layout.bii
|    |    +-- policies.bii
|    |    +-- settings.bii
|    |    +-- build/
|    |    +-- cmake/
|    |    +-- deps/
|    +-- bin/
|    +-- src/
|    +-- biicode.conf
|    +-- CMakeLists.txt

A project’s layout is fully customizable via layout.bii file, you can place the auxiliary folders wherever you want, just specify the relative routes to the folders you want to use instead.

TMP Layout¶

Looking for an even cleaner layout? Use bii init -l tmp.

This layout option redirects deps/ , build/ and cmake/ folders to the temporal folder of your system tmp/myproject/ -all aux folders but bin/- and places your repo’s code directly in your project’s folder.

Creates a folder structure in which deps/,build/ and cmake/ folders (all auxiliary folders but bin/ are inside bii/ folder:

+-- myproject/
|    +-- bii/
|    |    +-- layout.bii
|    |    +-- policies.bii
|    |    +-- settings.bii

in which layout.bii content is:

# Layout that redirect aux folders to your tmp/project folder
cmake: $TMP/cmake
lib: $TMP/lib
build: $TMP/build
deps: $TMP/deps
auto-root-block: True

For example, this is a project with TMP layout :

+-- myproject/
|    +-- bii/
|    |    +-- layout.bii
|    |    +-- policies.bii
|    |    +-- settings.bii
|    +-- bin/
|    +-- src/
|    +-- biicode.conf
|    +-- CMakeLists.txt

Classic Layout¶

bii init myproject creates a simple folder structure:

+-- myproject/
|    +-- bii/
|    |    +-- policies.bii
|    |    +-- settings.bii

And executing:

~$ cd myproject
~/myproject$ bii new username/blockname --hello=cpp

creates this structure into myproject:

+-- myproject/
|    +-- bii/
|    |    +-- policies.bii
|    |    +-- settings.bii
|    +-- blocks/
|    |    +-- username/
|    |    |    +-- blockname/
|    |    |    |    +-- main.cpp

Each project follows the same standard structure, for example:

+-- myproject/
|    +-- bii/
|    +-- blocks/
|    |    +-- owner1/
|    |    |    +-- blockA/
|    |    |    |    +-- src/
|    |    |    |    +-- include/
|    |    |    |    +-- test/
|    |    |    |    +-- biicode.conf
|    |    |    |    +-- CMakeLists.txt
|    +-- deps/

This structure empowers consistency between the blocks published in biicode, it also enables working with different owner/blocks at the same time:

+-- myproject/
|    +-- bii/
|    |    +-- policies.bii
|    |    +-- settings.bii
|    +-- blocks/
|    |    +-- owner1/
|    |    |    +-- blockA/
|    |    |    |    +-- src/
|    |    |    |    +-- include/
|    |    |    |    +-- test/
|    |    |    |    +-- biicode.conf
|    |    |    |    +-- CMakeLists.txt
|    |    |    +-- blockB/
|    |    |    |    +-- main.cpp
|    |    |    |    +-- biicode.conf
|    |    |    |    +-- CMakeLists.txt
|    |    +-- owner2/
|    |    |    +-- blockC/
|    |    |    |    +-- tool.h
|    |    |    |    +-- tool.cpp
|    |    |    |    +-- biicode.conf
|    |    |    |    +-- CMakeLists.txt
|    +-- deps/

CLion Layout¶

Use CLion with biicode, just like the regular biicode layout but with a bii/layout.bii to integrate biicode with the C/C++ IDE.

This layout places your repo’s code as usual, in your project_name/blocks/owner/blockname directory:

This working project looks like this:

+-- myproject/
|    +-- bii/
|    |    +-- policies.bii
|    |    +-- settings.bii
|    |    +-- layout.bii
|    +-- blocks/
|    |    +-- owner1/
|    |    |    +-- blockA/
|    |    |    |    +-- src/
|    |    |    |    +-- include/
|    |    |    |    +-- test/
|    |    |    |    +-- biicode.conf
|    |    |    |    +-- CMakeLists.txt
|    +-- deps/

in which layout.bii content is:

# Layout for CLion IDE with root CMakeLists at project root
# This layout DOES NOT allow root-block, as it will overwrite the project CMakeLists
cmake: /

Check our biicode's forum and/or StackOverflow tag for questions and answers. You can also write us for suggestions and feedback.

Working with your own blocks¶

In the Getting Started guide we built a program and reused the sum function. Now it’s time to add new functionality to your published myuser/math block, like a subtract function, and use it in your block myuser/calc.

The layout is:

+-- mycalc
|    +-- blocks
|    |    +-- myuser
|    |    |    +-- calc
|    |    |    |    +-- main.cpp
|    +-- deps
|    |    +-- myuser
|    |    |    +-- math
|    |    |    |    +-- operations.cpp
|    |    |    |    +-- operations.h

Opening your block¶

Open the block myuser/math for editing on the same project, execute:

~/mycalc$ bii open myuser/math

bii open command retrieves the complete block to your blocks folder, and deletes it from your deps folder. In this case, it will open the specific version you depend on.

The resulting layout is:

+-- mycalc
|    +-- blocks
|    |    +-- myuser
|    |    |    +-- calc
|    |    |    |    +-- main.cpp
|    |    |    +-- math
|    |    |    |    +-- main.cpp
|    |    |    |    +-- operations.cpp
|    |    |    |    +-- operations.h
|    +-- deps

Now, add the new function, subtract and use it on your main.cpp

operations.h

#pragma once
int sum(int a, int b);
int subtract(int a, int b);

operations.cpp

#include "operations.h"
int sum(int a, int b) {return a+b;}
int subtract(int a, int b){return a-b;}

main.cpp

#include "google/gtest/gtest.h"
#include "operations.h"

TEST(Sum, Normal) {
 EXPECT_EQ(5, sum(2, 3));
}
TEST(Subtract, Normal) {
 EXPECT_EQ(-1, subtract(2, 3));
}
int main(int argc, char **argv) {
 testing::InitGoogleTest(&argc, argv);
 return RUN_ALL_TESTS();
}

Build, bii build and run your tests myuser_math_main to check everything is working.

Publishing updated code¶

Publish the math block again. As you now have 2 blocks opened (calc, math), specify the name of the block you want to publish:

~/mycalc$ bii publish myuser/math

By default, bii publish uses the DEV tag. Check on your online biicode profile it’s been published.

Using DEV tag, the latest DEV version is overrided, so [parents] section of your biicode.conf remains unmodified:

[parent]
   myuser/math: 0

Closing edited block¶

You can now close myuser/math block, it and it will return, with the code already updated, to your deps folder:

~/mycalc$ bii close myuser/math

Then you can modify the content of your myuser/calc:

main.cpp

#include <iostream>
#include "myuser/math/operations.h"

using namespace std;
int main() {
   cout<<"2 + 3 = "<< sum(2, 3)<<endl;
   cout<<"2 - 3 = "<< subtract(2,3)<<endl;
}

and build it, reusing also the new function:

~/mycalc$ bii build
~/mycalc$ bin\myuser_calc_main
2 + 3 = 5
2 - 3 = -1

Congrats! You just edited your dependencies and updated the changes. You know that we are available at biicode's forum for any problems. You can also write us for suggestions and feedback, they are always welcomed.

Working with any published block¶

To edit a published block, follow the steps below:

Open a block¶

Open a block locally to modify and publish a new version of a block.

~/$ bii init myproject
~/$ cd myproject
~/myproject$ bii open username/blockname:VERSION

Example

Let’s open lasote/json11 block (version=lastest by default) to edit it:

$ bii open lasote/json11

Then you can code on it as if it was yours and changes will be reflected in your code, at build time.

Suppose that you want to open version 1 instead of the latest lasote/json11 version, you should execute:

$ bii open lasote/json:1

Publish the changes¶

Once your changes build, publish your own version of the block.

If the block in edition isn’t yours:

• Rename lasote folder with your username.
• Delete the [parents] section content in your biicode.conf file.

And publish:

$ bii publish

Close the block¶

Then you can close the block to remove it from your blocks folder:

$ bii close user_name/block_name

If you’re following the Example, execute:

$ bii close user_name/json11

Depend on the block you’ve just published¶

Now, if you want to depend on the block you’ve just published:

• Update your #include (s) to the ones referring to your new published version
• If you didn’t publish it as STABLE, do it or update your policies.bii file to accept DEV versions.
• Execute bii find and you’re ready to build as usual. Here’s bii find command documentation.

Check our biicode's forum and/or StackOverflow tag for questions and answers. You can also write us for suggestions and feedback.

Got any doubts? Do not hesitate to contact us visit our forum and feel free to ask any questions.

Override a dependency with block tracks¶

Create a block track when you need a personalized fix over the original library.

Let’s create a block track from diego/glfw block:

• Open the block:

~$ bii init myproject
~$ cd myproject
~/myproject$ bii open diego/glfw

• Code, adjust it to your needs.
• Write the track name between brackets in the [parent] section of the biicode.conf file. Specify version -1 because we want create a new block.

biicode.conf

[parent]
    diego/glfw(myuser/glfw): -1

• Execute bii publish and enter your profile www.biicode.com/myuser to check the new track.

Depend on that new block track:

• Write in your biicode.conf file [requirements] :

  biicode.conf

  [requirements]
    # required blocks (with version)
    diego/glfw(myuser/glfw): 1
  

• Execute bii build and it’s updated.

Publish, share and reuse CMake scripts¶

Now, biicode lets you publish, share and reuse CMake scripts. You can reuse other user’s CMake macros/functions and apply any content in your CMakeLists.txt.

Reusing CMake code is as simple as #including libraries in C++ with biicode.

Edit your CMakeLists.txt file and include the CMake file from the block that you want:

INCLUDE(user/block/path_to_macros_file) # Without .cmake extension
MACRO_NAME_TO_USE() # Macro defined in My_macros.cmake

# Actually create targets: EXEcutables and libraries.
ADD_BII_TARGETS()

And run bii find command:

$ bii find

All CMake dependencies will be downloaded into your project/deps/user/block folder

# Including tools.cmake from biicode/cmake user block
# see https://www.biicode.com/biicode/cmake
INCLUDE(biicode/cmake/tools)

ADD_BII_TARGETS()

# Calling specific macro to activate c++11 flags
ACTIVATE_CPP11(INTERFACE ${BII_BLOCK_TARGET})

$ bii find

Overriding dependencies build options and configuration¶

Sometimes you need to override some configuration of how your dependency libraries are built.

This is the project layout when you have dependencies:

|-- my_project
|    +-- blocks
|    |    +-- my_user
|    |    |    +-- my_block
|    |    |    |    +-- biicode.conf
|    |    |    |    +-- CMakeLists.txt
|    |    |    |    +-- main.cpp
|    +-- deps
|    |    +-- lasote
|    |    |    +-- superlibrary
|    |    |    |    +-- biicode.conf
|    |    |    |    +-- CMakeLists.txt
|    |    |    |    +-- library.h
|    |    |    |    +-- library.cpp
|    |    +-- sara
|    |    |    +-- coollibrary
|    |    |    |    +-- biicode.conf
|    |    |    |    +-- CMakeLists.txt
|    |    |    |    +-- tool.h
|    |    |    |    +-- tool.cpp

You should not edit the source code in deps directory because it will be overwritten by biicode. As can’t change the CMakeLists.txt files of our dependencies directly, here’s a way to override their build configuration.

target_compile_options(lasote_superlibrary_interface INTERFACE -std=c++11)

SET(MY_OPTION OFF CACHE BOOL "MyCoolOption" FORCE)

Publish a new block Track¶

Write the track name between brackets in the [parent] section of the biicode.conf file. Specify version -1 because we want create a new block.

[parent]
    myuser/myblock(track1): -1

Now you have configured a track of your block.

In case you need a personalized fix over the original library from other user, just indicate it in the [parent] section like this:

[parent]
    lasote/libuv(myuser/track1): -1

This way, you have configured a track of other user whitout changing includes.

Execute bii publish and enter your profile www.biicode.com/myuser to check the new track.

Read a bit more about how tracks work, visit our post in the blog about block traks.

Simple Huffman Compression - Uncompression¶

This example demonstrates how to get started using BCL. You’ll learn to compress and uncompress a text file. It is simple to run.

$ bii init bcl_example -L
$ cd bcl_example
$ # Create main.cpp

/* Standard libraries */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Basic Compression Library */
#include "huffman.h"

/* Timing */
#include "systimer.h"


/*************************************************************************
* GetFileSize()
*************************************************************************/

long GetFileSize( FILE *f )
{
  long pos, size;
  pos = ftell( f );
  fseek( f, 0, SEEK_END );
  size = ftell( f );
  fseek( f, pos, SEEK_SET );
  return size;
}


/*************************************************************************
* CompressFile()
*************************************************************************/

int TestFile( )
{
  unsigned int  insize, outsize, bufsize, *work, k, err_count;
  unsigned char *in, *out, *buf;
  FILE          *f;
  double        t0, t1, t_comp, t_uncomp;

  printf( "Compressing MyFile, ");

  /* Open input file */
  f = fopen( "myfile.txt", "rb" );
  if( !f )
  {
    printf( "unable to open!\n" );
    return 0;
  }

  /* Get input size */
  insize = GetFileSize( f );
  printf( "File Size:",f );
  if( insize < 1 )
  {
    printf( "empty file!\n" );
    fclose( f );
    return 0;
  }

  /* Worst case output buffer size */
  bufsize = (insize*104+50)/100 + 384;

  /* Allocate memory */
  in = (unsigned char *) malloc( insize + 2*bufsize );
  if( !in )
  {
    printf( "out of memory!\n" );
    fclose( f );
    return 0;
  }

  /* Pointers to compression buffer and output memory */
  buf = &in[ insize ];
  out = &buf[ bufsize ];

  /* Read and close input file */
  fread( in, 1, insize, f );
  fclose( f );

  /* Compress and decompress */

      t0 = GetTime();
      outsize = Huffman_Compress( in, buf, insize );
      t_comp = GetTime() - t0;
      t1 = GetTime();
      Huffman_Uncompress( buf, out, outsize, insize );
      t_uncomp = GetTime() - t1;

  err_count = 0;
  if(outsize > 0)
  {
    /* Show compression result */
    printf( "\n  Compression: %d/%d bytes (%.1f%%)", outsize, insize,
            100*(float)outsize/(float)insize );

    /* Compare input / output data */
    for( k = 0; k < insize; ++ k )
    {
      if( in[ k ] != out[ k ] )
      {
        if( err_count == 0 ) printf( "\n" );
        if( err_count == 30 ) printf( "    ...\n" );
        else if( err_count < 30 )
        {
            printf( "    %d: %d != %d\n", k, out[ k ], in[ k ] );
        }
        ++ err_count;
      }
    }

    /* Did we have success? */
    if( err_count == 0 )
    {
      printf( " - OK!\n" );
      printf( "    Compression speed: %.1f KB/s (%.2f ms)\n",
              (double) insize / (1024.0 * t_comp), 1000.0 * t_comp );
      printf( "    Uncompression speed: %.1f KB/s (%.2f ms)\n",
              (double) insize / (1024.0 * t_uncomp), 1000.0 * t_uncomp );
    }
    else
    {
      printf( "    *******************************\n" );
      printf( "    ERROR: %d faulty bytes\n", err_count );
      printf( "    *******************************\n" );
    }
  }

  /* Free all memory */
  free( in );

  return (outsize > 0) && (err_count == 0);
}

int main()
{
   FILE * pFile;
   char buffer [100];

   pFile = fopen ("myfile.txt" , "w+");
   fprintf(pFile, "%s %s %s %d", "We", "are", "in", 2014);
   if (pFile == NULL) perror ("Error opening file");
   else
   {
     while ( ! feof (pFile) )
     {
       if ( fgets (buffer , 100 , pFile) == NULL ) break;
       fputs (buffer , stdout);
     }
     fclose (pFile);
   }
   TestFile();
}

$ bii deps
your_user/bcl_example depends on:
      system:
         stdio.h
         stdlib.h
         string.h
      unresolved:
         huffman.h
         systimer.h

[requirements]
    marcus256/bcl: 2

[includes]
    *.h: marcus256/bcl/src

$ bii build
$ cd bin
$ examples_bcl_main

Compressing MyFile, File Size:
  Compression: 20/14 bytes (142.9%) - OK!
    Compression speed: 1246.6 KB/s (0.01 ms)
    Uncompression speed: 4778.7 KB/s (0.00 ms)

Open and build¶

This example is already in biicode: examples/bcl.

To give it a try, create a new project and open the block:

$ bii init bcl_example
$ cd bcl_example
$ bii open examples/bcl

Build the example and execute it:

$ bii build
$ cd bin
$ # Execute it
  Compressing MyFile, File Size:
    Compression: 20/14 bytes (142.9%) - OK!
      Compression speed: 1246.6 KB/s (0.01 ms)
      Uncompression speed: 4778.7 KB/s (0.00 ms)

Any doubts? Do not hesitate to contact us visit our forum and feel free to ask any questions.

Boost.Lambda¶

This is an example about the Boost.Lambda library, extracted from the Boost getting started header-only section.

First create a block for the example:

$ bii new your-account/boost-lambda

Create a source file:

blocks/your-account/boost-lambda/example.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) << " " );
}

biicode sets up a Boost installation inside the biicode environment. This allows to support and switch between multiple Boost versions easily.

#Include the biicode Boost setup script
include(biicode/boost/setup)

ADD_BII_TARGETS()

#Setup Boost and build (if needed) the required Boost components
#Since lambda is header-only, there are no components to build and find
bii_find_boost()

#Add Boost headers to the block include directories
target_include_directories(${BII_BLOCK_TARGET} INTERFACE ${Boost_INCLUDE_DIRS})

bii_find_boost([COMPONENTS component1 component2 ...] [REQUIRED])

$ bii find
$ bii configure
         block your-account/boost-lambda
------------------------------------------------
-- Setting up biicode Boost configuration...
-- Boost version: 1.57.0
...

$ bii build

[requirements]
    biicode/boost(1.56.0)

[requirements]
    biicode/boost(1.56.0)

[parent]
    your-account/boost-lambda(1.56.0): -1, 0, whatever version is available

Boost.Coroutine¶

Boost.Coroutine implements coroutines which can be useful to implement cooperative multitasking, iterators, etc, in a more natural way.

Open the Boost.Coroutine example

$ bii open examples/boost-coroutine

The example source code:

#include <boost/coroutine/all.hpp>
#include <iostream>

using namespace boost::coroutines;

void cooperative(coroutine<void>::push_type &sink)
{
    std::cout << "Hello";
    sink();
    std::cout << "world";
}

int main()
{
    coroutine<void>::pull_type source{cooperative};
    std::cout << ", ";
    source();
    std::cout << "!\n";
}

In the code above, the string “Hello, world!” is written by writing “Hello”, going back to main() which writes the comma, then calling the coroutine again to continue printing “world”, and finally printing ”!” on main().

You can visualize it as:

main()  | cooperative()
--------+--------------
        |   "Hello"
  ", "  |
        |   "world"
  "!"   |

This is the CMakeLists.txt from the example:

include(biicode/boost/setup)

ADD_BII_TARGETS()

set(Boost_USE_STATIC_LIBS ON)
bii_find_boost(COMPONENTS system coroutine context thread REQUIRED)
target_include_directories(${BII_BLOCK_TARGET} INTERFACE ${Boost_INCLUDE_DIRS})
target_link_libraries(${BII_BLOCK_TARGET} INTERFACE ${Boost_LIBRARIES})

if(MSVC)
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")
else()
    target_compile_options(${BII_BLOCK_TARGET} INTERFACE -std=c++11)
endif()

Besides Visual Studio specific configuration (See), the configuration is pretty straightforward:

1. Set the way you want to link against Boost libraries with Boost_USE_STATIC_LIBS as usually when using Boost with CMake. biicode assumes static linking by default.
2. Set up and find the required Boost components with bii_find_boost(). Note the order matters, since it’s the order the libraries are linked together.
3. Add Boost to your target include directories. Again as usual when using Boost with CMake, via taget_include_directories() and Boost_INCLUDE_DIRS variable.
4. Link your target against Boost libraries using the Boost_LIBRARIES variable.

Now just run bii configure, wait until the Boost components are built (If those were not used previously), and then build your project with bii build.

$ bii find
$ bii configure -G "Unix Makefiles"

      examples/boost-corutine
---------------------------------
-- Setting up Biicode Boost...
-- Building Boost 1.57.0 components with toolset gcc-4.9.2...
-- Building system library...
-- Building coroutine library...
-- Building context library...
-- Building thread library...
-- Boost 1.57.0

Found the following Boost libraries
    system
    coroutine
    context
    thread

...

$ bii build

Alternative setup call¶

bii_find_boost() sets up Boost and then calls find_package(Boost) with the components passed to the former. While this setup works in 90% cases, there are some situations when the Boost components you need do not correspond to Boost libraries directly.

If that’s the case, you can call bii_setup_boost() function passing the Boost libraries to build, and then do the classic find_package(Boost COMPONENTS ...) with the components you need.

Take Boost.Log as an example:

examples/boost-log/CMakeLists.txt

include(biicode/boost/setup)

ADD_BII_TARGETS()

set(Boost_USE_STATIC_LIBS OFF)
set(Boost_USE_MULTITHREADED ON)

bii_setup_boost(COMPONENTS system thread filesystem log REQUIRED)
find_package(Boost COMPONENTS system thread filesystem date_time log log_setup REQUIRED)

target_compile_options(${BII_BLOCK_TARGET} INTERFACE -DBOOST_LOG_DYN_LINK)
target_include_directories(${BII_BLOCK_TARGET} INTERFACE ${Boost_INCLUDE_DIRS})
target_link_libraries(${BII_BLOCK_TARGET} INTERFACE  ${Boost_LIBRARIES})

Note how the components required by Log are not exactly the same libraries that should be built.

Extra configuration variables¶

The Boost setup scripts have some extra variables to debug and or customize Boost a bit:

• BII_BOOST_VERBOSE: When is set to on, the setup scripts print some internal info about the current setup being run, and the different steps.
• BII_BOOST_LIBCXX: When using the Clang compiler, enables Boost build using LLVM’s libc++ instead of the default GNU’s stdlibc++ standard library implementation.
• BII_BOOST_BUILD_J: Specifies the number of threads used when building Boost libraries. May be useful to speed up Boost builds in setups where the libraries are always built, like continuous integration builds without cache. For example: bii configure -DBII_BOOST_BUILD_J=16
• BII_BOOST_GLOBAL_USE_STATIC_LIBS: Overrides the Boost_USE_STATIC_LIBS values specified in each CMakeLists.txt and sets a value globally. Useful when you depend on many Boost-related blocks and you may experience issues related to different linkages against Boost in that blocks. Use this variable carefully.

Contribute to the setup scripts¶

The setup scripts are maintained as an open source project on GitHub, you may want to ask about new features, report bugs, etc.

Bounces of a circle falling¶

In this example you will calculate whenever a circle falls from a certain height and bounces at a defined lower limit in the created world.

$ bii init box2d_example -L
$ cd box2d_example
$ # Create main.cpp

#include "Box2D/Box2D.h"
#include <iostream>

using namespace std;

int main(int argc, char** argv)
{
    B2_NOT_USED(argc);
    B2_NOT_USED(argv);

    //**************************************************//
    //                 Creating a World                        //
    //**************************************************//

    // Define the gravity vector.
    b2Vec2 gravity(0.0f,-10.0f);

    // Construct a world object, which will hold and simulate the rigid bodies.
    b2World world(gravity);


    //**************************************************//
    //                 Creating a Ground Box               //
    //**************************************************//

    // Define the ground body.
    b2BodyDef groundBodyDef;
    groundBodyDef.position.Set(0.0f,-10.0f);

    // Call the body factory which allocates memory for the ground body
    // from a pool and creates the ground box shape (also from a pool).
    // The body is also added to the world.
    b2Body* groundBody = world.CreateBody(&groundBodyDef);

    // Define the ground box shape.
    b2PolygonShape groundBox;

    // The extents are the half-widths of the box.
    groundBox.SetAsBox(50.0f, 10.0f);

    // Add the ground fixture to the ground body.
    groundBody->CreateFixture(&groundBox, 0.0f);

    //**************************************************//
    //            Creating a Circle Shape                   //
    //**************************************************//

    b2BodyDef BodyDef;
    BodyDef.type = b2_dynamicBody;
    BodyDef.position = b2Vec2(0.0f, 4.0f);
    BodyDef.userData = (void *) "Circle";
    b2Body* body = world.CreateBody(&BodyDef);

    b2CircleShape circle;
    circle.m_radius = 1.0f;

    b2FixtureDef fixtureDef;
    fixtureDef.density = 1.0f;
    fixtureDef.friction = 2.0f;
    fixtureDef.restitution = 0.5f;

    fixtureDef.shape = &circle;

    body->CreateFixture(&fixtureDef);

    //**************************************************//
    //            Simulating the World (of Box2D)     //
    //**************************************************//

    float32 timeStep = 1.0f / 60.0f;
    int32 velocityIterations = 6;
    int32 positionIterations = 2;

    // This is our little game loop.
    for (int32 i = 0; i < 100; ++i)
    {
        // Instruct the world to perform a single step of simulation.
        // It is generally best to keep the time step and iterations fixed.
        world.Step(timeStep, velocityIterations, positionIterations);

        // Now print the position and angle of the body.
        b2Vec2 position = body->GetPosition();
        float32 angle = body->GetAngle();

        if (position.y - 1.00 <= 0.001)
            cout<< "Ball hits the ground!!" << endl;
        else
            cout<<"X = " << position.x << " Y = " << position.y << endl;
    }
}

$ bii deps
your_user/box2d_example depends on:
      system:
         iostream
      unresolved:
         Box2D/Box2D.h

[requirements]
    erincatto/box2d: 10

[includes]
    Box2D/Box2d.h: erincatto/box2d

$ bii build

~/box2d$ bin/myuser_box2d_example_main
X = 0 Y = 3.99722
X = 0 Y = 3.99167
X = 0 Y = 3.98333
X = 0 Y = 3.97222
X = 0 Y = 3.95833
X = 0 Y = 3.94167
X = 0 Y = 3.92222
Ball hits the ground!!

Open and build¶

This example is already in biicode: examples/box2d.

To give it a try, create a new project and open the block:

$ bii init box2d_example
$ cd box2d_example
$ bii open examples/box2d

Build the example and execute it:

$ bii build
$ cd bin
$ # Execute it
...
 X = 0 Y = 3.95833
 X = 0 Y = 3.94167
 X = 0 Y = 3.92222
 Ball hits the ground!!

Got any doubts? Do not hesitate to contact us, visit our forum and feel free to ask any questions.

Create a new project¶

Open your console and create a new project named “challenge”:

$ bii init challenge
$ cd challenge

Copy the code¶

Download the challenge sources from github or in zipped format from this link. Copy all the files into challenge/blocks/your_user_name/challenge. If you got the sources from github, you need to replace the #include directives as follows: (#include “sparse/cs.h” => #include “tdavis/sparse/cs.h”, #include <eigen/Dense> => #include <eigen/eigen/Dense>, #include “gtest/include/gtest/gtest.h” => #include “google/gtest/include/gtest/gtest.h”)

Now you can check for all the code dependencies of the current project using the bii deps command. Please, note that while most of the dependencies are correctly solved, three of them are not. Theses unresolved dependencies have been highlighted in the following figure:

$ bii deps
Detected 5 files created, 0 updated
Processing project
  Cell your_user_name/challenge/systemsolver.h is implemented by set([\'your_user_name/challenge/systemsolver.cpp\'])

Find resources with include to gtest ['your_user_name/challenge/test1.cpp']

Adding resources to your_user_name/challenge/gtest_main.cc
Saving files on disk
DepTable:
Declarations:
  Resolved
    map
    vector
    iostream
    your_user_name/challenge/systemsolver.h
    fstream
  Unresolved
    eigen/eigen/Dense
    google/gtest/include/gtest/gtest.h
    tdavis/csparse/include/cs.h
Files deps:
  System
    map
    vector
    iostream
    fstream
  Explicit
    your_user_name/challenge/systemsolver.h
  Implicit
    your_user_name/challenge/test1.cpp
    your_user_name/challenge/systemsolver.cpp

Find and retrieve dependencies¶

Now that we know that our project has some missing dependencies, we’ll show you how easily biicode helps you to automatically retrieve all of them. You only need to write the bii find command. You’ll be asked to provide your biicode password, and the client will find and retrieve from our servers any missing dependencies:

$ bii find
Finding missing dependencies in server
Password for your_user_name:
Looking for eigen/eigen...
  >> Block candidate: eigen/eigen(eigen/master)
  >> Version eigen/eigen(eigen/master): 0 (STABLE) valid due your policy!
  Found blocks: eigen/eigen(eigen/master): 0
Looking for tdavis/csparse...
  >> Block candidate: tdavis/csparse(tdavis/master)
  >> Version tdavis/csparse(tdavis/master): 0 (STABLE) valid due your policy!
  Found blocks: tdavis/csparse(tdavis/master): 0
Looking for google/gtest...
  >> Block candidate: google/gtest(google/master)
  >> Version google/gtest(google/master): 2 (STABLE) valid due your policy!
  >> Version google/gtest(google/master): 1 (STABLE) valid due your policy!
  >> Version google/gtest(google/master): 0 (DEV) discarded due your policy!
  Found blocks: google/gtest(google/master): 2
  Found blocks: google/gtest(google/master): 1
Analyzing compatibility for found dependencies...
  Resolved block!
  Resolved block!
  Resolved block!
Dependencies resolved in server:
Find resolved new dependencies:
        eigen/eigen(eigen/master): 0
        google/gtest(google/master): 2
        tdavis/csparse(tdavis/master): 0
All dependencies resolved
Saving files on disk
Computing dependencies
Retrieving resources from server
Retrieving resources from server
Retrieving resources from server
Retrieving resources from server
Saving dependences on disk

At this point, you’ll find some new folders and files in your challenge/dep folder. These are the blocks that biicode considers as needed for compiling the project.

Build and run¶

The final step is to actually compile and run the app. You can accomplish this task with the bii build command and run the executable inside the bin folder:

$ bii build

...

$ cd bin
$ #run solver executable
*************** SPARSE ***************
0: 1
1: 0.5
2: 0.333333
3: 0.25
4: 0.2
5: 0.166667
6: 0.142857
7: 0.125
8: 0.111111
9: 0.1
*************** DENSE ***************
0: 1
1: 0.5
2: 0.333333
3: 0.25
4: 0.2
5: 0.166667
6: 0.142857
7: 0.125
8: 0.111111
9: 0.1

Running the tests is really easy too. Note that in this case one of the tests fails due to sparse solver accuracy, but the execution of the test itself works just fine!.

$ cd bin
$ #run test executable
[==========] Running 2 tests from 1 test case.
[----------] Global test environment set-up.
[----------] 2 tests from Solver
[ RUN      ] Solver.BasicDiagonalSparse
challenge/blocks/your_user_name/challenge/test1.cpp:21: Failure
Value of: 1./(i+1)
  Actual: 0.5
Expected: sol[i]
Which is: 0.5
challenge/blocks/your_user_name/challenge/test1.cpp:21: Failure
Value of: 1./(i+1)
  Actual: 0.333333
Expected: sol[i]
Which is: 0.333333
[  FAILED  ] Solver.BasicDiagonalSparse (0 ms)
[ RUN      ] Solver.BasicDiagonalDense
[       OK ] Solver.BasicDiagonalDense (1 ms)
[----------] 2 tests from Solver (1 ms total)

[----------] Global test environment tear-down
[==========] 2 tests from 1 test case ran. (1 ms total)
[  PASSED  ] 1 test.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] Solver.BasicDiagonalSparse

1 FAILED TEST

Tron game¶

This is a classic Tron game that shows how to load and manipulate images with Cimg library in a simple way.

Let’s try it out!

$ bii init tron_example -L
$ cd tron_example
$ # Create tron.cpp and copy the code

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

/*
 #
 #  File        : tron.cpp
 #                ( C++ source file )
 #
 #  Description : A clone of the famous (and very simple) Tron game.
 #                This file is a part of the CImg Library project.
 #                ( http://cimg.sourceforge.net )
 #
 #  Copyright   : David Tschumperle
 #                ( http://tschumperle.users.greyc.fr/ )
 #
 #  License     : CeCILL v2.0
 #                ( http://www.cecill.info/licences/Licence_CeCILL_V2-en.html )
 #
 #  This software is governed by the CeCILL  license under French law and
 #  abiding by the rules of distribution of free software.  You can  use,
 #  modify and/ or redistribute the software under the terms of the CeCILL
 #  license as circulated by CEA, CNRS and INRIA at the following URL
 #  "http://www.cecill.info".
 #
 #  As a counterpart to the access to the source code and  rights to copy,
 #  modify and redistribute granted by the license, users are provided only
 #  with a limited warranty  and the software's author,  the holder of the
 #  economic rights,  and the successive licensors  have only  limited
 #  liability.
 #
 #  In this respect, the user's attention is drawn to the risks associated
 #  with loading,  using,  modifying and/or developing or reproducing the
 #  software by the user in light of its specific status of free software,
 #  that may mean  that it is complicated to manipulate,  and  that  also
 #  therefore means  that it is reserved for developers  and  experienced
 #  professionals having in-depth computer knowledge. Users are therefore
 #  encouraged to load and test the software's suitability as regards their
 #  requirements in conditions enabling the security of their systems and/or
 #  data to be ensured and,  more generally, to use and operate it in the
 #  same conditions as regards security.
 #
 #  The fact that you are presently reading this means that you have had
 #  knowledge of the CeCILL license and that you accept its terms.
 #
*/

#include "CImg.h"

using namespace cimg_library;

// Main procedure
//----------------
int main(int argc, char **argv) {

  // Print usage, help and retrieve command line options
  //-----------------------------------------------------
  cimg_usage("A very simple Tron game, using the CImg Library");
  cimg_help("--- Quick help ----------------------------\n"
            " Player 1 (blue) :\n"
            " Use keys 'W' (up), 'S' (down), 'A' (left)\n"
            "     and 'D' (right) to control your player.\n"
            "     Right 'CONTROL' key enables turbospeed\n"
            " Player 2 (red) : \n"
            "     Use arrow keys to control your player.\n"
            "     'TAB' key enables turbospeed.\n"
            "-------------------------------------------");

  const char *geom      = cimg_option("-g","300x300","Size of the game board");
  const int delay       = cimg_option("-s",10,"Game speed (lower value means faster)");
  const bool twoplayers = !cimg_option("-1",false,"One player only");
  const int zoom        = cimg_option("-z",1,"Zoom factor");
  const bool full       = cimg_option("-f",false,"Fullscreen mode");
  unsigned int W = 400, H = 400;
  std::sscanf(geom,"%u%*c%u",&W,&H);

  // Define game colors and variables
  //----------------------------------
  const unsigned char blue[] = { 128,200,255}, red[] = { 255,0,0 }, white[] = { 255,255,255 };
  int score1=0, score2=0, round_over=0, ix1=-1, iy1=-1, x1=0, y1=0, u1=0, v1=0, ix2=-1, iy2=-1, x2=0, y2=0, u2=0, v2=0;
  bool start_round = true, turbo1 = false, turbo2 = false;

  // Create background image
  //--------------------------
  CImg<unsigned char> background, img;
  background.assign(64,64,1,3,0).noise(60).draw_plasma().resize(W,H).blur(2).normalize(0,128).draw_rectangle(0,0,W-1,H-1,white,1.0f,~0U);

  // Open display window
  //---------------------
  CImgDisplay disp(background,"* CImg-Tron *");
  if (zoom>1) disp.resize(-100*zoom,-100*zoom);
  if (full) disp.toggle_fullscreen().display(background);

  // Start main game loop
  //----------------------
  while (!disp.is_closed() && !disp.is_keyESC()) {

    // Init new game round if necessary
    //----------------------------------
    if (start_round) {

      // Init game variables
      round_over = 0;
      ix1=-1; iy1=-1; x1 = 10;   y1 = 10;   u1 = 1;  v1 = 0; turbo1 = false;
      ix2=-1; iy2=-1; x2 = W-11; y2 = H-11; u2 = -1; v2 = 0; turbo2 = false;
      img = background;
      start_round = false;

      // Display a simple pre-round page
      CImg<unsigned char> logo, pressakey;
      logo.draw_text(0,0," CImg-Tron ",white,0,1,33).resize(-100,-100,1,3);
      CImg<unsigned char> tmp = (+background).draw_image((W-logo.width())/2,(H-logo.height())/2-20,logo,logo.get_channel(0).dilate(6).normalize(0,1)).
        draw_text(W/2-60,H/2+10,"Blue ( %u )",blue,0,1,13,score1).
        draw_text(W/2+10,H/2+10,"Red ( %u )",red,0,1,13,score2);
      pressakey.draw_text(0,0,"* Press a key to start round *",white);
      for (float i = 0; i<1; i+=0.05f) ((+tmp)*=i).display(disp.wait(20));
      disp.flush();
      for (unsigned long t = 0; !disp.key() && !disp.is_closed(); ++t) {
        if (!(t%10)) { if (t%20) disp.display(tmp); else disp.display((+tmp).draw_image(W/2-70,H/2+50,pressakey,pressakey,1,255)); }
    if (disp.wait(20).is_resized()) disp.resize(disp);
      }
      if (disp.is_keyESC()) disp.flush();
    }

    // Test collision between players and borders
    if (x1<0 || x1>=img.width() || y1<0 || y1>=img.height() ||
        img(x1,y1,0)!=background(x1,y1,0) ||
        img(x1,y1,1)!=background(x1,y1,1) ||
        img(x1,y1,2)!=background(x1,y1,2) ||
        ((ix1>=0 || iy1>=0) && (img(ix1,iy1,0)!=background(ix1,iy1,0) ||  // Collision test for turbo mode
                                img(ix1,iy1,1)!=background(ix1,iy1,1) ||
                                img(ix1,iy1,2)!=background(ix1,iy1,2)))) { round_over=1; score2++; }
    if (twoplayers) {
      if (x2<0 || x2>=img.width() || y2<0 || y2>=img.height() ||
          img(x2,y2,0)!=background(x2,y2,0) ||
          img(x2,y2,1)!=background(x2,y2,1) ||
          img(x2,y2,2)!=background(x2,y2,2) ||
          ((ix2>=0 || iy2>=0) && (img(ix2,iy2,0)!=background(ix2,iy2,0) ||  // Collision test for turbo mode
                                  img(ix2,iy2,1)!=background(ix2,iy2,1) ||
                                  img(ix2,iy2,2)!=background(ix2,iy2,2)))) { round_over=2; score1++; }
    }

    // Draw new players positions
    img.draw_point(x1,y1,blue);
    if (ix1>=0 && iy1>=0) img.draw_point(ix1,iy1,blue);
    if (twoplayers) {
      img.draw_point(x2,y2,red);
      if (ix2>=0 && iy2>=0) img.draw_point(ix2,iy2,red);
    }
    if (disp.is_resized()) disp.resize(disp);
    img.display(disp);

    // Update players positions
    x1+=u1; y1+=v1;
    if (turbo1) { ix1 = x1; iy1 = y1; x1+=u1; y1+=v1; } else { ix1 = iy1 = -1; }
    if (twoplayers) {
      x2+=u2; y2+=v2;
      if (turbo2) { ix2 = x2; iy2 = y2; x2+=u2; y2+=v2; } else { ix2 = iy2 = -1; }
    }

    // Test keyboard events
    int nu1 = u1, nv1 = v1, nu2 = u2, nv2 = v2;
    if (disp.is_keyARROWLEFT())  { nu1 = -1; nv1 = 0; }
    if (disp.is_keyARROWRIGHT()) { nu1 = 1; nv1 = 0; }
    if (disp.is_keyARROWUP())    { nu1 = 0; nv1 = -1; }
    if (disp.is_keyARROWDOWN())  { nu1 = 0; nv1 = 1; }
    turbo1 = disp.is_keyCTRLRIGHT();
    if (twoplayers) {
      if (disp.is_keyA()) { nu2 = -1; nv2 = 0; }
      if (disp.is_keyD()) { nu2 = 1; nv2 = 0; }
      if (disp.is_keyW()) { nu2 = 0; nv2 = -1; }
      if (disp.is_keyS()) { nu2 = 0; nv2 = 1; }
      turbo2 = disp.is_keyTAB();
    }
    if (nu1!=-u1 && nv1!=-v1) { u1 = nu1; v1 = nv1; }
    if (nu2!=-u2 && nv2!=-v2) { u2 = nu2; v2 = nv2; }

    // Check if round is over.
    if (round_over) {
      const int xc = round_over==1?x1:x2, yc = round_over==1?y1:y2;
      for (int r=0; r<50; r+=3) img.draw_circle(xc,yc,r,round_over==1?blue:red,r/300.0f).display(disp.wait(20));
      for (int rr=0; rr<50; rr+=3)
        ((+img)*=(50-rr)/50.0f).draw_circle(xc,yc,(50+rr),round_over==1?blue:red,1/6.0f).display(disp.wait(20));
      start_round = true;
    }

    // Wait a small amount of time
    disp.wait(delay);
  }
  return 0;
}

$ bii deps
INFO: Processing changes...
your_user/cimg_example depends on:
      unresolved:
         CImg.h

[requirements]
    tschumperle/cimg: 4

[includes]
    CImg.h: tschumperle/cimg

$ sudo apt-get install libx11-dev

include(${CMAKE_HOME_DIRECTORY}/biicode.cmake)

ADD_BII_TARGETS()

IF(APPLE)
   FIND_PACKAGE(X11)
   TARGET_LINK_LIBRARIES(${BII_BLOCK_TARGETS} PUBLIC ${X11_LIBRARIES})
   INCLUDE_DIRECTORIES(/opt/X11/include)
ENDIF()

IF(UNIX)
    IF(NOT APPLE)
        TARGET_LINK_LIBRARIES(${BII_BLOCK_TARGETS} PUBLIC X11)
    ENDIF()
ENDIF()

$ bii build
$ cd bin
$ # Run the executable

Open and build¶

This example is already in biicode: examples/cimg. Give it a try, just open a new project and open the block.

$ bii init cimg_example
$ cd cimg_example
$ bii open examples/cimg
$ bii build
$ cd bin
$ # Run the generated executable
$ ./examples_cimg_tron # on linux
$ examples_cimg_tron.exe # on windows

Any doubts? Do not hesitate to contact us visit our forum and feel free to ask any questions.

Encrypt a message¶

The following example shows how to encrypt a message with SHA1 code.

$ bii init cryptopp_example -L
$ cd cryptopp_example
$ # Create main_cryptopp.cpp
$ # Copy the code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include "sha.h"
#include "filters.h"
#include "hex.h"
#include <iostream>
#include <string>

int main() {
	CryptoPP::SHA1 sha1;
	std::string source = "Hello";  //This will be randomly generated somehow
	std::string hash = "";
	CryptoPP::StringSource(source, true, new CryptoPP::HashFilter(sha1, new CryptoPP::HexEncoder(new CryptoPP::StringSink(hash))));
	std::cout << hash;
}

$ bii deps
INFO: Processing changes...
your_user/cryptopp depends on:
      system:
         iostream
         string
      unresolved:
         filters.h
         hex.h
         sha.h

[requirements]
    cryptopp/cryptopp: 8

[includes]
    *.h: cryptopp/cryptopp

$ bii build
$ cd bin
$ # run executable
F7FF9E8B7BB2E09B70935A5D785E0CC5D9D0ABF0

Open and build¶

You can find this example in the biicode crypto samples block. See how it works in a few steps here.

Create a project:

$ bii init cryptopp_example
$ cd cryptopp_example
$ bii open examples/cryptopp

You will see next console output after executing the command:

$ ./bin/examples_cryptopp_main_crypto
F7FF9E8B7BB2E09B70935A5D785E0CC5D9D0ABF0

Read a matrix and solve a linear system¶

With this example you can read a matrix saved in a file and solve a linear system.

You need cs_demo.h and cs_demo.c to encampsule some functions to use in the example and a matrix file t1. Then, cs_demo2.c implements the main function. Let’s do it!

Create a new project¶

$ bii init csparse_example -L
$ cd csparse_example
$ # copy the files below

cs_demo.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#include "cs.h"

typedef struct problem_struct
{
    cs *A ;
    cs *C ;
    csi sym ;
    double *x ;
    double *b ;
    double *resid ;
} problem ;

problem *get_problem (FILE *f, double tol) ;
csi demo2 (problem *Prob) ;
csi demo3 (problem *Prob) ;
problem *free_problem (problem *Prob) ;

cs_demo.c

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289

#include "cs_demo.h"
#include <time.h>
/* 1 if A is square & upper tri., -1 if square & lower tri., 0 otherwise */
static csi is_sym (cs *A)
{
    csi is_upper, is_lower, j, p, n = A->n, m = A->m, *Ap = A->p, *Ai = A->i ;
    if (m != n) return (0) ;
    is_upper = 1 ;
    is_lower = 1 ;
    for (j = 0 ; j < n ; j++)
    {
        for (p = Ap [j] ; p < Ap [j+1] ; p++)
        {
            if (Ai [p] > j) is_upper = 0 ;
            if (Ai [p] < j) is_lower = 0 ;
        }
    }
    return (is_upper ? 1 : (is_lower ? -1 : 0)) ;
}

/* true for off-diagonal entries */
static csi dropdiag (csi i, csi j, double aij, void *other) { return (i != j) ;}

/* C = A + triu(A,1)' */
static cs *make_sym (cs *A)
{
    cs *AT, *C ;
    AT = cs_transpose (A, 1) ;          /* AT = A' */
    cs_fkeep (AT, &dropdiag, NULL) ;    /* drop diagonal entries from AT */
    C = cs_add (A, AT, 1, 1) ;          /* C = A+AT */
    cs_spfree (AT) ;
    return (C) ;
}

/* create a right-hand side */
static void rhs (double *x, double *b, csi m)
{
    csi i ;
    for (i = 0 ; i < m ; i++) b [i] = 1 + ((double) i) / m ;
    for (i = 0 ; i < m ; i++) x [i] = b [i] ;
}

/* infinity-norm of x */
static double norm (double *x, csi n)
{
    csi i ;
    double normx = 0 ;
    for (i = 0 ; i < n ; i++) normx = CS_MAX (normx, fabs (x [i])) ;
    return (normx) ;
}

/* compute residual, norm(A*x-b,inf) / (norm(A,1)*norm(x,inf) + norm(b,inf)) */
static void print_resid (csi ok, cs *A, double *x, double *b, double *resid)
{
    csi i, m, n ;
    if (!ok) { printf ("    (failed)\n") ; return ; }
    m = A->m ; n = A->n ;
    for (i = 0 ; i < m ; i++) resid [i] = -b [i] ;  /* resid = -b */
    cs_gaxpy (A, x, resid) ;                        /* resid = resid + A*x  */
    printf ("resid: %8.2e\n", norm (resid,m) / ((n == 0) ? 1 :
        (cs_norm (A) * norm (x,n) + norm (b,m)))) ;
}

static double tic (void) { return (clock () / (double) CLOCKS_PER_SEC) ; }
static double toc (double t) { double s = tic () ; return (CS_MAX (0, s-t)) ; }

static void print_order (csi order)
{
    switch (order)
    {
        case 0: printf ("natural    ") ; break ;
        case 1: printf ("amd(A+A')  ") ; break ;
        case 2: printf ("amd(S'*S)  ") ; break ;
        case 3: printf ("amd(A'*A)  ") ; break ;
    }
}

/* read a problem from a file; use %g for integers to avoid csi conflicts */
problem *get_problem (FILE *f, double tol)
{
    cs *T, *A, *C ;
    csi sym, m, n, mn, nz1, nz2 ;
    problem *Prob ;
    Prob = cs_calloc (1, sizeof (problem)) ;
    if (!Prob) return (NULL) ;
    T = cs_load (f) ;                   /* load triplet matrix T from a file */
    Prob->A = A = cs_compress (T) ;     /* A = compressed-column form of T */
    cs_spfree (T) ;                     /* clear T */
    if (!cs_dupl (A)) return (free_problem (Prob)) ; /* sum up duplicates */
    Prob->sym = sym = is_sym (A) ;      /* determine if A is symmetric */
    m = A->m ; n = A->n ;
    mn = CS_MAX (m,n) ;
    nz1 = A->p [n] ;
    cs_dropzeros (A) ;                  /* drop zero entries */
    nz2 = A->p [n] ;
    if (tol > 0) cs_droptol (A, tol) ;  /* drop tiny entries (just to test) */
    Prob->C = C = sym ? make_sym (A) : A ;  /* C = A + triu(A,1)', or C=A */
    if (!C) return (free_problem (Prob)) ;
    printf ("\n--- Matrix: %g-by-%g, nnz: %g (sym: %g: nnz %g), norm: %8.2e\n",
            (double) m, (double) n, (double) (A->p [n]), (double) sym,
            (double) (sym ? C->p [n] : 0), cs_norm (C)) ;
    if (nz1 != nz2) printf ("zero entries dropped: %g\n", (double) (nz1 - nz2));
    if (nz2 != A->p [n]) printf ("tiny entries dropped: %g\n",
            (double) (nz2 - A->p [n])) ;
    Prob->b = cs_malloc (mn, sizeof (double)) ;
    Prob->x = cs_malloc (mn, sizeof (double)) ;
    Prob->resid = cs_malloc (mn, sizeof (double)) ;
    return ((!Prob->b || !Prob->x || !Prob->resid) ? free_problem (Prob) : Prob) ;
}

/* free a problem */
problem *free_problem (problem *Prob)
{
    if (!Prob) return (NULL) ;
    cs_spfree (Prob->A) ;
    if (Prob->sym) cs_spfree (Prob->C) ;
    cs_free (Prob->b) ;
    cs_free (Prob->x) ;
    cs_free (Prob->resid) ;
    return (cs_free (Prob)) ;
}

/* solve a linear system using Cholesky, LU, and QR, with various orderings */
csi demo2 (problem *Prob)
{
    cs *A, *C ;
    double *b, *x, *resid,  t, tol ;
    csi k, m, n, ok, order, nb, ns, *r, *s, *rr, sprank ;
    csd *D ;
    if (!Prob) return (0) ;
    A = Prob->A ; C = Prob->C ; b = Prob->b ; x = Prob->x ; resid = Prob->resid;
    m = A->m ; n = A->n ;
    tol = Prob->sym ? 0.001 : 1 ;               /* partial pivoting tolerance */
    D = cs_dmperm (C, 1) ;                      /* randomized dmperm analysis */
    if (!D) return (0) ;
    nb = D->nb ; r = D->r ; s = D->s ; rr = D->rr ;
    sprank = rr [3] ;
    for (ns = 0, k = 0 ; k < nb ; k++)
    {
        ns += ((r [k+1] == r [k]+1) && (s [k+1] == s [k]+1)) ;
    }
    printf ("blocks: %g singletons: %g structural rank: %g\n",
        (double) nb, (double) ns, (double) sprank) ;
    cs_dfree (D) ;
    for (order = 0 ; order <= 3 ; order += 3)   /* natural and amd(A'*A) */
    {
        if (!order && m > 1000) continue ;
        printf ("QR   ") ;
        print_order (order) ;
        rhs (x, b, m) ;                         /* compute right-hand side */
        t = tic () ;
        ok = cs_qrsol (order, C, x) ;           /* min norm(Ax-b) with QR */
        printf ("time: %8.2f ", toc (t)) ;
        print_resid (ok, C, x, b, resid) ;      /* print residual */
    }
    if (m != n || sprank < n) return (1) ;      /* return if rect. or singular*/
    for (order = 0 ; order <= 3 ; order++)      /* try all orderings */
    {
        if (!order && m > 1000) continue ;
        printf ("LU   ") ;
        print_order (order) ;
        rhs (x, b, m) ;                         /* compute right-hand side */
        t = tic () ;
        ok = cs_lusol (order, C, x, tol) ;      /* solve Ax=b with LU */
        printf ("time: %8.2f ", toc (t)) ;
        print_resid (ok, C, x, b, resid) ;      /* print residual */
    }
    if (!Prob->sym) return (1) ;
    for (order = 0 ; order <= 1 ; order++)      /* natural and amd(A+A') */
    {
        if (!order && m > 1000) continue ;
        printf ("Chol ") ;
        print_order (order) ;
        rhs (x, b, m) ;                         /* compute right-hand side */
        t = tic () ;
        ok = cs_cholsol (order, C, x) ;         /* solve Ax=b with Cholesky */
        printf ("time: %8.2f ", toc (t)) ;
        print_resid (ok, C, x, b, resid) ;      /* print residual */
    }
    return (1) ;
} 

/* free workspace for demo3 */
static csi done3 (csi ok, css *S, csn *N, double *y, cs *W, cs *E, csi *p)
{
    cs_sfree (S) ;
    cs_nfree (N) ;
    cs_free (y) ;
    cs_spfree (W) ;
    cs_spfree (E) ;
    cs_free (p) ;
    return (ok) ;
}

/* Cholesky update/downdate */
csi demo3 (problem *Prob)
{
    cs *A, *C, *W = NULL, *WW, *WT, *E = NULL, *W2 ;
    csi n, k, *Li, *Lp, *Wi, *Wp, p1, p2, *p = NULL, ok ;
    double *b, *x, *resid, *y = NULL, *Lx, *Wx, s,  t, t1 ;
    css *S = NULL ;
    csn *N = NULL ;
    if (!Prob || !Prob->sym || Prob->A->n == 0) return (0) ;
    A = Prob->A ; C = Prob->C ; b = Prob->b ; x = Prob->x ; resid = Prob->resid;
    n = A->n ;
    if (!Prob->sym || n == 0) return (1) ;
    rhs (x, b, n) ;                             /* compute right-hand side */
    printf ("\nchol then update/downdate ") ;
    print_order (1) ;
    y = cs_malloc (n, sizeof (double)) ;
    t = tic () ;
    S = cs_schol (1, C) ;                       /* symbolic Chol, amd(A+A') */
    printf ("\nsymbolic chol time %8.2f\n", toc (t)) ;
    t = tic () ;
    N = cs_chol (C, S) ;                        /* numeric Cholesky */
    printf ("numeric  chol time %8.2f\n", toc (t)) ;
    if (!S || !N || !y) return (done3 (0, S, N, y, W, E, p)) ;
    t = tic () ;
    cs_ipvec (S->pinv, b, y, n) ;               /* y = P*b */
    cs_lsolve (N->L, y) ;                       /* y = L\y */
    cs_ltsolve (N->L, y) ;                      /* y = L'\y */
    cs_pvec (S->pinv, y, x, n) ;                /* x = P'*y */
    printf ("solve    chol time %8.2f\n", toc (t)) ;
    printf ("original: ") ;
    print_resid (1, C, x, b, resid) ;           /* print residual */
    k = n/2 ;                                   /* construct W  */
    W = cs_spalloc (n, 1, n, 1, 0) ;
    if (!W) return (done3 (0, S, N, y, W, E, p)) ;
    Lp = N->L->p ; Li = N->L->i ; Lx = N->L->x ;
    Wp = W->p ; Wi = W->i ; Wx = W->x ;
    Wp [0] = 0 ;
    p1 = Lp [k] ;
    Wp [1] = Lp [k+1] - p1 ;
    s = Lx [p1] ;
    srand (1) ;
    for ( ; p1 < Lp [k+1] ; p1++)
    {
        p2 = p1 - Lp [k] ;
        Wi [p2] = Li [p1] ;
        Wx [p2] = s * rand () / ((double) RAND_MAX) ;
    }
    t = tic () ;
    ok = cs_updown (N->L, +1, W, S->parent) ;   /* update: L*L'+W*W' */
    t1 = toc (t) ;
    printf ("update:   time: %8.2f\n", t1) ;
    if (!ok) return (done3 (0, S, N, y, W, E, p)) ;
    t = tic () ;
    cs_ipvec (S->pinv, b, y, n) ;               /* y = P*b */
    cs_lsolve (N->L, y) ;                       /* y = L\y */
    cs_ltsolve (N->L, y) ;                      /* y = L'\y */
    cs_pvec (S->pinv, y, x, n) ;                /* x = P'*y */
    t = toc (t) ;
    p = cs_pinv (S->pinv, n) ;
    W2 = cs_permute (W, p, NULL, 1) ;           /* E = C + (P'W)*(P'W)' */
    WT = cs_transpose (W2,1) ;
    WW = cs_multiply (W2, WT) ;
    cs_spfree (WT) ;
    cs_spfree (W2) ;
    E = cs_add (C, WW, 1, 1) ;
    cs_spfree (WW) ;
    if (!E || !p) return (done3 (0, S, N, y, W, E, p)) ;
    printf ("update:   time: %8.2f (incl solve) ", t1+t) ;
    print_resid (1, E, x, b, resid) ;           /* print residual */
    cs_nfree (N) ;                              /* clear N */
    t = tic () ;
    N = cs_chol (E, S) ;                        /* numeric Cholesky */
    if (!N) return (done3 (0, S, N, y, W, E, p)) ;
    cs_ipvec (S->pinv, b, y, n) ;               /* y = P*b */
    cs_lsolve (N->L, y) ;                       /* y = L\y */
    cs_ltsolve (N->L, y) ;                      /* y = L'\y */
    cs_pvec (S->pinv, y, x, n) ;                /* x = P'*y */
    t = toc (t) ;
    printf ("rechol:   time: %8.2f (incl solve) ", t) ;
    print_resid (1, E, x, b, resid) ;           /* print residual */
    t = tic () ;
    ok = cs_updown (N->L, -1, W, S->parent) ;   /* downdate: L*L'-W*W' */
    t1 = toc (t) ;
    if (!ok) return (done3 (0, S, N, y, W, E, p)) ;
    printf ("downdate: time: %8.2f\n", t1) ;
    t = tic () ;
    cs_ipvec (S->pinv, b, y, n) ;               /* y = P*b */
    cs_lsolve (N->L, y) ;                       /* y = L\y */
    cs_ltsolve (N->L, y) ;                      /* y = L'\y */
    cs_pvec (S->pinv, y, x, n) ;                /* x = P'*y */
    t = toc (t) ;
    printf ("downdate: time: %8.2f (incl solve) ", t1+t) ;
    print_resid (1, C, x, b, resid) ;           /* print residual */
    return (done3 (1, S, N, y, W, E, p)) ;
}