Home » Blog » Categories » News

News

CGAL 4.3 Released, Computational Geometry Algorithms Library

By Laurent Rineau | Oct 21, 2013 09:27 AM | Tags: None

cgal_front_page_2013.pngThe CGAL Open Source Project is pleased to announce the release 4.3 of CGAL, the Computational Geometry Algorithms Library.

Besides fixes to existing packages, the following has changed since CGAL 4.2:

  • The CGAL Manual generated with Doxygen

    The documentation of CGAL is now generated with Doxygen: http://doc.cgal.org/4.3

    The conversion to Doxygen from our home-made tools was not completely smooth. Please report any documentation bug you may discover to our Inria Forge bug tracker.

  • 2D Periodic Triangulations (new package)

    This package allows to build and handle triangulations of point sets in the two dimensional flat torus. Triangulations are built incrementally and can be modified by insertion or removal of vertices. They offer point location facilities. The package provides Delaunay triangulations and offers nearest neighbor queries and primitives to build the dual Voronoi diagrams.

See http://www.cgal.org/releases.html for a complete list of changes.

The CGAL project is a collaborative effort to develop a robust, easy-to-use, and efficient C++ software library of geometric data structures and algorithms, such as:

  • triangulations (2D constrained triangulations, Delaunay triangulations and periodic triangulations in 2D and 3D),
  • Voronoi diagrams (for 2D and 3D points, 2D additively weighted Voronoi diagrams, and segment Voronoi diagrams),
  • Boolean operations on polygons and polyhedra,
  • regularized Boolean operations on polygons with curved arcs
  • arrangements of curves,
  • mesh generation (2D, 3D and surface mesh generation, surface mesh subdivision and parametrization),
  • alpha shapes (in 2D and 3D),
  • convex hull algorithms (in 2D, 3D and dD),
  • operations on polygons (straight skeleton and offset polygon),
  • search structures (kd trees for nearest neighbor search, and range and segment trees),
  • interpolation (natural neighbor interpolation and placement of streamlines),
  • optimization algorithms (smallest enclosing sphere of points or spheres, smallest enclosing ellipsoid of points, principal component analysis),
  • kinetic data structures.

Some modules are distributed under the terms of the LGPL Open Source license (GNU Lesser General Public License v3 or later versions). Most modules are distributed under the terms of the GPL Open Source license (GNU General Public License v3 or later versions). If your intended usage does not meet the criteria of the aforementioned licenses, a commercial license can be purchased from GeometryFactory.

For further information and for downloading the library and its documentation, please visit the CGAL web site.

C++11 and Boost

By Meeting C++ | Oct 17, 2013 10:11 AM | Tags: intermediate experimental c++11 boost advanced

What issues arise when combining C++11 and (older) Boost code that has pre-standard versions of C++11 features?

C++11 and Boost

by Jens Weller

From the article:

Some parts of the Standard Library in C++11 are predated in boost. When playing around with C++11, you get used to using some parts in the Standard Library that are used in C++03 with their boost counterpart. Also, there is some libraries now occuring, which are C++11 based, so interfacing with either boost or C++11 code is soon an issue.

No Runtime Overhead -- Bulldozer00

By Blog Staff | Oct 16, 2013 07:24 AM | Tags: basics

sharedunique.pngA little nugget about the free-as-in-no-overhead-ness of unique_ptr and std::move:

No Runtime Overhead

by Bulldozer00

From the article:

Unless I really need shared ownership of a dynamically allocated object, which I haven’t so far, I stick to the slimmer and more performant std::unique_ptr. ...

Out Parameters, Move Semantics, and Stateful Algorithms -- Eric Niebler

By Blog Staff | Oct 15, 2013 06:35 AM | Tags: intermediate efficiency c++11

In this article, Eric Niebler discusses an issue of API design regarding the age-old question of out parameters versus return-by-value, this time in light of move semantics. He uses std::getline as his example.

Out Parameters, Move Semantics, and Stateful Algorithms

by Eric Niebler

From the article:

I think getline is a curious example because what looks at first blush like a pure out parameter is, in fact, an in/out parameter; on the way in, getline uses the passed-in buffer’s capacity to make it more efficient. This puts getline into a large class of algorithms that work better when they have a chance to cache or precompute something.

 

Double-Checked Locking Is Fixed in C++11 -- Jeff Preshing

By hendrixjl | Oct 10, 2013 06:28 AM | Tags: performance intermediate efficiency concurrency

preshing.PNGJeff Preshing gives a nice overview of the on-again/off-again/on-again status of a common approach to lazy initialization.

[Ed: Note that DCLP is not just for thread-safe singletons, that's just a handy example. It's for lazy initialization in general.]

Double-Checked Locking Is Fixed in C++11

by Jeff Preshing

From the article:

The double-checked locking pattern (DCLP) is a bit of a notorious case study in lock-free programming. Up until 2004, there was no safe way to implement it in Java. Before C++11, there was no safe way to implement it in portable C++.

As the pattern gained attention for the shortcomings it exposed in those languages, people began to write about it. In 2000, a group of high-profile Java developers got together and signed a declaration entitled “Double-Checked Locking Is Broken”. In 2004, Scott Meyers and Andrei Alexandrescu published an article entitled “C++ and the Perils of Double-Checked Locking”. Both papers are great primers on what DCLP is, and why, at the time, those languages were inadequate for implementing it.

All of that’s in the past. Java now has a revised memory model, with new semantics for the volatile keyword, which makes it possible to implement DCLP safely. Likewise, C++11 has a shiny new memory model and atomic library which enable a wide variety of portable DCLP implementations. C++11, in turn, inspired Mintomic, a small library I released earlier this year which makes it possible to implement DCLP on some older C/C++ compilers as well.

In this post, I’ll focus on the C++ implementations of DCLP...

New "using std::cpp" event in Spain (Spanish only)

By Blog Staff | Oct 9, 2013 12:06 PM | Tags: None

Ready for a full day of C++11/14/17 content in the Spanish language?

using std:cpp

November 26, 2013

University Carlos III of Madrid in Leganés

The site and the event are entirely in Spanish. For convenience, here is an automatic translation of the event page:

Welcome to using std::cpp 2013

using std::cpp 2013 aims to be a forum for exchanging experiences using the C++ language, paying special attention to the recent standard C++11 and the upcoming C++14 and C++17.

Who should attend using std::cpp 2013?

The event is aimed at professional developers using C++ as a language for application development or infrastructure software. It is also aimed at students of last years of career, interested in the use of C++ as a programming language to produce complex computer systems with high performance.

What can I find in using std:cpp 2013?

We have prepared an intensive programme with presentations by leading developers from leading companies in their sectors (Indizen, TCP-SI, BBVA, Telefónica, Digital, INDRA, Biicode, Microsoft, Programming Research Group).

You can refer to the detailed program to see topics you can expect.

When does using std::cpp take place?

using std::cpp 2013 will be held on November 26, 2013 at the School Politécnica Superior of the Universidad Carlos III de Madrid in Leganes and will last for a full day.

Do I need to register?

using std::cpp 2013 attendance is free, but you must register to facilitate the organization of the event. You can register here.

What are the semantics of =delete? -- StackOverflow

By Blog Staff | Oct 9, 2013 11:15 AM | Tags: basics

The question, rephrased: Does =delete mean "make the compiler skip this function and keep looking," or "make this function unusable and make the caller fix their code" -- and why?

What's the exact semantics of a deleted function in C++11?

struct A
{
    A();

    A(const A&);
    A& operator =(const A&);

    A(A&&) = delete;
    A& operator =(A&&) = delete;
};

struct B
{
    B();

    B(const B&);
    B& operator =(const B&);   
};

int main()
{
    A a;
    a = A(); // error C2280

    B b;
    b = B(); // OK
}

My compiler is VC++ 2013 RC.

error C2280: 'A &A::operator =(A &&)' : attempting to reference a deleted function

I just wonder why the compiler doesn't try A& operator =(const A&); when A& operator =(A&&) is deleted?

Is this behavior defined by the C++ standard?

Effective GoF Patterns with C++11 and Boost -- Tobias Darm

By Blog Staff | Oct 9, 2013 08:54 AM | Tags: intermediate boost

tobias-darm.PNGSpeaking of ACCU 2014, here's an excellent talk from ACCU 2013 showing how C++11 (by itself, and/or with Boost) makes expressing many common design patterns far simpler than using traditional pre-C++11 tools. In fat, are there cases where the design patterns even disappear entirely? Watch to find out.

Effective GoF Patterns with C++11 and Boost (slides)

by Tobias Darm

Abstract and bio:

Tobias Darm discusses how some of the GoF patterns can be implemented differently in C++11 using Boost libraries.

Tobias Darm is working with C++ and programming embedded devices used in an intensive care environment at Dräger medical. He likes to learn and teach about software development and does tutorials and workshops in his company encouraging a modern programming style.