Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction
Functions Resulting in Collections of Elements
References
All Topics
Computer Science
Software

CGAL Made More Accessible

Profile image of Efi FogelEfi Fogel

2022, arXiv (Cornell University)

https://doi.org/10.48550/ARXIV.2202.13889
visibility

…

description

56 pages

link

1 file

Abstract

We introduce Python bindings that enable the convenient, efficient, and reliable use of software modules of Cgal (The Computational Geometry Algorithms Library), which are written in C++, from within code written in Python. There are different tools that facilitate the creation of such bindings. We present a short study that compares three main tools, which leads to the tool of choice. The implementation of algorithms and data structures in computational geometry presents tremendous difficulties, such as obtaining robust software despite the use of (inexact) floating point arithmetic, found in standard hardware, and meticulous handling of all degenerate cases, which typically are in abundance. The code of Cgal extensively uses function and class templates in order to handle these difficulties, which implies that the programmer has to make many choices that are resolved during compile time (of the C++ modules). While bindings take effect at run time (of the Python code), the type of the C++ objects that are bound must be known when the bindings are generated, that is, when they are compiled. The types of the bound objects are instances (instantiated types) of C++ function and class templates. The number of object types that can potentially be bound, in implementation of generic computational-geometry algorithms, is enormous; thus, the generation of the bindings for all these types in advance is practically impossible. For example, the programmer needs to choose among a dozen types of curves (e.g., line segments, circular arcs, geodesic arcs on a sphere, or polycurves of any curve type) to yield a desired arrangement type; often there are several choices to make, resulting in a prohibitively large number of combinations. We present a system that rapidly generates bindings for desired object types according to user prescriptions, which enables the convenient use of any subset of bound object types concurrently. After many years, in which the usage of these packages was restricted to C++ experts, the introduction of the bindings made them easily accessible to newcomers and practitioners in non-computing fields, as we report in the paper. Additional information can be found at http://acg.cs.tau.ac.il/cgal-python-bindings. The bindings software can be found at https://bitbucket.org/taucgl/cgal-python-bindings.

Related papers

Cronus: A Platform for Parallel Code Generation Based on Computational Geometry Methods (PLEASE REFERENCE IN YOUR PAPERS)
Florina Ciorba

Journal of Systems and …, 2008

This paper describes Cronus, a platform for parallelizing general nested loops. General nested loops contain complex loop bodies (assignments, conditionals, repetitions) and exhibit uniform loop-carried dependencies. The novelty of Cronus is twofold: (1) it determines the optimal scheduling hyperplane using the QuickHull algorithm, which is more efficient than previously used methods, and (2) it implements a simple and efficient dynamic rule (successive dynamic scheduling) for the runtime scheduling of the loop iterations along the optimal hyperplane. This scheduling policy enhances data locality and improves the makespan. Cronus provides an efficient runtime library, specifically designed for communication minimization, that performs better than more generic systems, such as Berkeley UPC. Its performance was evaluated through extensive testing. Three representative case studies are examined: the Floyd–Steinberg dithering algorithm, the Transitive Closure algorithm, and the FSBM motion estimation algorithm. The experimental results corroborate the efficiency of the parallel code. The tests show speedup ranging from 1.18 (out of the ideal 4) to 12.29 (out of the ideal 16) on distributed-systems and 3.60 (out of 4) to 15.79 (out of 16) on shared-memory systems. Cronus outperforms UPC by 5–95% depending on the test case.

View PDFchevron_right
Cronus: A platform for parallel code generation based on computational geometry methods
George Papakonstantinou, Florina Ciorba

2008

This paper describes CRONUS, a platform for parallelizing general nested loops. General nested loops contain complex loop bodies (assignments, conditionals, repetitions) and exhibit uniform loop-carried dependencies. The novelty of CRONUS is twofold: (1) it determines the optimal scheduling hyperplane using the QuickHull algorithm, which is more efficient than previously used methods, and (2) it implements a simple and efficient dynamic rule (successive dynamic scheduling) for the runtime scheduling of the loop iterations along the optimal hyperplane. This scheduling policy enhances data locality and improves the makespan. CRONUS provides an efficient runtime library, specifically designed for communication minimization, that performs better than more generic systems, such as Berkeley UPC. Its performance was evaluated through extensive testing. Three representative case studies are examined: the Floyd-Steinberg dithering algorithm, the Transitive Closure algorithm, and the FSBM motion estimation algorithm. The experimental results corroborate the efficiency of the parallel code. The tests show speedup ranging from 1.18 (out of the ideal 4) to 12.29 (out of the ideal 16) on distributedsystems and 3.60 (out of 4) to 15.79 (out of 16) on shared-memory systems. CRONUS outperforms UPC by 5-95% depending on the test case.

View PDFchevron_right
GOOL: a generic object-oriented language
Spencer Smith

Proceedings of the 2020 ACM SIGPLAN Workshop on Partial Evaluation and Program Manipulation, 2020

We present GOOL, a Generic Object-Oriented Language. GOOL shows that with the right abstractions, a language can capture the essence of object-oriented programs. GOOL generates human-readable, documented and idiomatic code in Python, Java, C#, and C++. In it, we can express common programming idioms and patterns. CCS Concepts • Software and its engineering → Source code generation; Abstraction, modeling and modularity; Object oriented languages.

View PDFchevron_right
C++ and Object Oriented Numeric Computing for Scientists and Engineers
Mohammad Mushfequr Rahman

This is page vii Printer: Opaque this Preface This book is intended to be an easy, concise, but rather complete, introduction to the ISO/ANSI C++ programming language with special emphasis on object-oriented numeric computation for students and professionals in science and engineering. The description of the language is platformindependent. Thus it applies to di erent operating systems such as UNIX, Linux, MacOS, Windows, and DOS, as long as a standard C++ compiler is equipped. The prerequisite of this book is elementary knowledge of calculus and linear algebra. However, this prerequisite is hardly necessary if this book is going to be used as a textbook for teaching C++ and all the sections on numeric methods are skipped. Programming experience in another language such a s F ORT R A N , C , A d a , P ascal, Maple, or Matlab will certainly help, but is not presumed.

View PDFchevron_right
Enabling Code Generation within the Sparse Polyhedral Framework
Michelle Strout

2010

Loop transformation frameworks based on the polyhedral model use libraries such as Polylib, ISL, and Omega to represent and manipulate polyhedra and use tools like CLooG to generate loops that scan the modified polyhedra. Most of these libraries are restricted to iteration space sets and memory/array access functions with affine constraints that preclude the specification of run-time reordering transformations (i.e., inspector/executor strategies) within the existing code generation tools. Automatic generation of inspector and executor code is important for the parallelization and data locality improvements in irregular computations such as those that manipulate sparse data structures. We enable the specification of run-time reordering transformations at compile time in the Sparse Polyhedral Framework (SPF) by representing indirect memory references and run-time generated data and iteration reorderings using uninterpreted function symbols. This paper presents techniques for manipula...

View PDFchevron_right
A Review of Existing Approaches to Increase the Computational Speed of the Python Language
SINI ANNA ALEX

2019

The Python programming language has gained prominence in a wide range of fields, ranging from Computer Science to Medicine and Genetics to Astrophysics and Cosmology. The main reasons for this extensive applicability are Python’s versatility, the availability of robust, built-in libraries for all computations, readability, support for multiple programming paradigms and compatibility with several platforms. However, Python being an interpreted language, is slower than native, compiled languages like C/C++. It is also memory-intensive, due to flexible data types and throws a number of runtime errors, owing to flawed design. Most of the methods that have been developed to overcome Python’s low speed deal with optimizing Just-In-Time (JIT) compilers, specific to the Python language, which compile the interpreted codes on-the-fly. Some techniques describe general methodologies like optimum utilization of GPUs and increasing the efficiency of JIT Virtual Machines for dynamic programming l...

View PDFchevron_right
A Generic Programming Environment for High-Performance Mathematical Libraries
Mircea Marin

Lecture Notes in Computer Science, 2000

We report on a programming environment for the development of generic mathematical libraries based on functors (parameterized modules) that have rigorously speci ed but very abstract interfaces. We focus on the combination of the functor-based programming style with software engineering principles in large development projects. The generated target code is highly e cient and can be easily embedded into foreign application environments.

View PDFchevron_right
Generic programming for high-performance scientific applications
Andrew Lumsdaine

Concurrency and Computation: Practice and Experience, 2005

We present case studies that apply generic programming to the development of high-performance parallel code for solving two archetypal partial differential equations (PDEs). We examine the overall structure of the example scientific codes and consider their generic implementation. With a generic approach it is a straightforward matter to reuse software components from different sources; implementations with components from the Iterative Template Library (ITL), the Matrix Template Library (MTL), Blitz++, A++/P++, and Fortran BLAS are presented. Our newly developed Generic Message Passing library is used for communication. We compare the generic implementations with equivalent implementations developed with alternative libraries and languages and discuss performance as well as software engineering issues.

View PDFchevron_right
An extended type system for OCL supporting templates and transformations
Marcel Kyas

Formal Methods for Open Object-Based Distributed …, 2005

Based on our experience in implementing a type-checker for the Object Constraint Language (OCL), we observed that OCL is not suitable for constraining a system under development, because changes in the underlying class diagram unnecessarily invalidate the type correctness of constraints, while their semantic value does not change. Furthermore, the type system of OCL does not support templates.

View PDFchevron_right
Python 3 types in the wild: a tale of two type systems
Julian Dolby

Proceedings of the 16th ACM SIGPLAN International Symposium on Dynamic Languages

Python 3 is a highly dynamic language, but it has introduced a syntax for expressing types with PEP484. This paper explores how developers use these type annotations, the type system semantics provided by type checking and inference tools, and the performance of these tools. We evaluate the types and tools on a corpus of public GitHub repositories. We review MyPy and PyType, two canonical static type checking and inference tools, and their distinct approaches to type analysis. We then address three research questions: (i) How often and in what ways do developers use Python 3 types? (ii) Which type errors do developers make? (iii) How do type errors from different tools compare? Surprisingly, when developers use static types, the code rarely type-checks with either of the tools. MyPy and PyType exhibit false positives, due to their static nature, but also flag many useful errors in our corpus. Lastly, MyPy and PyType embody two distinct type systems, flagging different errors in many cases. Understanding the usage of Python types can help guide tool-builders and researchers. Understanding the performance of popular tools can help increase the adoption of static types and tools by practitioners, ultimately leading to more correct and more robust Python code. CCS Concepts: • Software and its engineering → Language features; • Theory of computation → Type structures.

View PDFchevron_right

References (36)

  1. D. Abrahams and R. W. Grosse-Kunstleve. Building hybrid systems with boost.python. C/C++ Users Journal, pages 31-39, 2003.
  2. M. H. Austern. Generic Programming and the Stl. Addison-Wesley, Boston, MA, USA, 1999.
  3. A. Baram, E. Fogel, D. Halperin, M. Hemmer, and S. Morr. Exact Minkowski sums of polygons with holes. Computational Geometry: Theory and Applications, 1:01-01, 2015.
  4. S. Behnel, R. Bradshaw, C. Citro, L. Dalcín, D. S. Seljebotn, and K. Smith. Cython: The best of both worlds. Computational Sciences Engineering, 13(2):31-39, 2011.
  5. E. Berberich, E. Fogel, D. Halperin, M. Kerber, and O. Setter. Arrangements on parametric surfaces II: Con- cretizations and applications. Mathematics in Computer Science, 4:67-91, 2010.
  6. E. Berberich, E. Fogel, D. Halperin, K. Mehlhorn, and R. Wein. Arrangements on parametric surfaces I: General framework and infrastructure. Mathematics in Computer Science, 4:45-66, 2010.
  7. J.-D. Boissonnat and M. Yvinec. Triangulations. In Algorithmic Geometry. Cambridge University Press, 1998. Translated by Hervé Brönnimann.
  8. H. Brönnimann, A. Fabri, G.-J. Giezeman, S. Hert, M. Hoffmann, L. Kettner, S. Pion, and S. Schirra. 2D and 3D linear geometry kernel. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  9. M. Caroli, A. Pellé, M. Rouxel-Labbé, and M. Teillaud. 3D periodic triangulations. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  10. M. Caroli and M. Teillaud. Computing 3d periodic triangulations. In Proceedings of the 17th Annual European Symposium on Algorithms (ESA), volume 5757 of LNCS, pages 37-48. Springer-Verlag, 2009.
  11. T. K. F. Da. 2D alpha shapes. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  12. T. K. F. Da, S. Loriot, and M. Yvinec. 3D alpha shapes. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  13. O. Devillers, L. Kettner, S. Pion, M. Seel, and M. Yvinec. Handles and circulators. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  14. E. Flato, D. Halperin, I. Hanniel, O. Nechushtan, and E. Ezra. The design and implementation of planar maps in CGAL. ACM J. Exp. Algorithmics, 5:13, 2000.
  15. E. Fogel, D. Halperin, and R. Wein. Cgal Arrangements and Their Applications, A Step by Step Guide. Springer- Verlag, Berlin Heidelberg, Germany, 2012.
  16. E. Fogel, O. Setter, R. Wein, G. Zucker, B. Zukerman, and D. Halperin. 2D regularized boolean set-operations. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  17. GEOS contributors. GEOS coordinate transformation software library. Open Source Geospatial Foundation, 2021.
  18. D. Halperin, J.-C. Latombe, and R. H. Wilson. A general framework for assembly planning: The motion space approach. Algorithmica, 26:577-601, 2000.
  19. D. Halperin and M. Sharir. Arrangements and their applications in robotics: Recent developments. In K. Gold- bergs, D. Halperin, J.-C. Latombe, and R. Wilson, editors, International Workshop on Algorithmic Foundations of Robotics, pages 495-511. A.K. Peters, Ltd., Boston, MA, 1995.
  20. D. Halperin and M. Sharir. Arrangements. In J. E. Goodman, J. O'Rourke, and C. Tóth, editors, Handbook of Computational Geometry, chapter 28. Chapman & Hall/CRC, 3rd edition, 2017.
  21. H. Har-Gil, Y. Jacobson, A. Prönneke, J. F. Staiger, O. Tomer, D. Halperin, and P. Blinder. Neural collision detection: an open source library to study the three-dimensional interactions of neurons and other tree-like structures. bioRxiv, 2021.
  22. W. Jakob. nanobind - seamless operability between c++17 and python, 2022. https://github.com/wjakob/nanobind.
  23. C. Jamin, S. Pion, and M. Teillaud. 3D triangulations. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  24. N. Kruithof. 2D periodic triangulations. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  25. W. Lavrijsen and A. Dutta. High-performance python-c++ bindings with pypy and cling. In Proceedings of the 6th Workshop on Python, pages 27-35. IEEE Computer Society Press, 2016.
  26. J. W. Martin, A. K. Yan, C. Bailey-Kellogg, P. Zhou, and B. R. Donald. A geometric arrangement algorithm for structure determination of symmetric protein homo-oligomers from noes and rdcs. Journal of Computational Biology, 18(11):1507-1523, 2011.
  27. K. Martin and B. Hoffman. Mastering CMake. Kitware, Inc, 4th edition, 2008.
  28. M. Meyerovitch. Robust, generic and efficient construction of envelopes of surfaces in three-dimensional space. In Proceedings of the 14th Annual European Symposium on Algorithms (ESA), volume 4168 of LNCS, pages 792-803. Springer-Verlag, 2006.
  29. M. Seel. dD geometry kernel. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  30. H. Tangelder and A. Fabri. dD spatial searching. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  31. The Cgal Project. Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  32. M. J. van Kreveld, É. Schramm, and A. Wolff. Algorithms for the placement of diagrams on maps. In Proceedings of the 12th ACM International Workshop Geographic Information Systems, pages 222-231, Washington, DC, USA, 2004. PUB-ACM.
  33. R. Wein, A. Baram, E. Flato, E. Fogel, M. Hemmer, and S. Morr. 2D minkowski sums. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  34. R. Wein, E. Berberich, E. Fogel, D. Halperin, M. Hemmer, O. Salzman, and B. Zukerman. 2D arrangements. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.
  35. R. Wein, E. Fogel, B. Zukerman, and D. Halperin. Advanced programming techniques applied to Cgal's arrange- ment package. Computational Geometry: Theory and Applications, 38(1-2):37-63, 2007.
  36. M. Yvinec. 2D triangulations. In Cgal User and Reference Manual. Cgal Editorial Board, 5.5 edition, 2022.

Related papers

Appendix - Generic Programming and The Cgal Library
Efi Fogel

Effective Computational Geometry for Curves and Surfaces, 2006

View PDFchevron_right
Geometry types for graphics programming
Dietrich Geisler

Proceedings of the ACM on Programming Languages

In domains that deal with physical space and geometry, programmers need to track the coordinate systems that underpin a computation. We identify a class of geometry bugs that arise from confusing which coordinate system a vector belongs to. These bugs are not ruled out by current languages for vector-oriented computing, are difficult to check for at run time, and can generate subtly incorrect output that can be hard to test for. We introduce a type system and language that prevents geometry bugs by reflecting the coordinate system for each geometric object. A value's geometry type encodes its reference frame, the kind of geometric object (such as a point or a direction), and the coordinate representation (such as Cartesian or spherical coordinates). We show how these types can rule out geometrically incorrect operations, and we show how to use them to automatically generate correct-by-construction code to transform vectors between coordinate systems. We implement a language for graphics programming, Gator, that checks geometry types and compiles to OpenGL's shading language, GLSL. Using case studies, we demonstrate that Gator can raise the level of abstraction for shader programming and prevent common errors without inducing significant annotation overhead or performance cost. CCS Concepts: • Computing methodologies → Computer graphics; • Software and its engineering → Data types and structures.

View PDFchevron_right
Code Flexibility and Program Efficiency by Genericity: Improving Cgal's Arrangements
Efi Fogel

2004

Arrangements of planar curves are fundamental structures in computational geometry. We describe the recent developments in the arrangement package of Cgal, the Computational Geometry Algorithms Library, making it easier to use, to extend and to adapt to a variety of applications. This improved flexibility of the code does not come at the expense of efficiency as we mainly use generic-programming techniques, which make dexterous use of the compilation process. To the contrary, we expedited key operations as we demonstrate by experiments.

View PDFchevron_right
Reflection-Based Python-C++ Bindings
Massimo Marino

Lawrence Berkeley National Laboratory, 2004

Python is a flexible, powerful, high-level language with excellent interactive and introspective capabilities and a very clean syntax. As such, it can be a very effective tool for driving physics analysis. Python is designed to be extensible in low-level C-like languages, and its use as a scientific steering language has become quite widespread. To this end, existing and custom-written C or C++ libraries are bound to the Python environment as so-called extension modules. A number of tools for easing the process of creating such bindings exist, such as SWIG and Boost. Python. Yet, the process still requires a considerable amount of effort and expertise. The C++ language has few built-in introspective capabilities, but tools such as LCGDict and CINT add this by providing so-called dictionaries: libraries that contain information about the names, entry points, argument types, etc. of other libraries. The reflection information from these dictionaries can be used for the creation of bin...

View PDFchevron_right
PyRemote: Object mobility in the Python programming language
Petter Häggholm

2007

The current trend in computation is one of concurrency and multiprocessors. Large supercomputers have long been eclipsed in popularity by cheaper clusters of small computers. In recent years, desktop processors with multiple cores have become commonplace. A plethora of languages, tools, and techniques for dealing with concurrency already exist. Where concurrency and multiprocessors meet modern, highly dynamic languages, however, is uncharted territory. Traditional distributed systems, however complex, tend to be simplified by assumptions of type consistency. Even in systems where types and not merely instances and primitive objects can be serialised and distributed, it is usually the case that such types are assumed to be static. The Python programming language, as an example of a modern language with highly dynamic types, presents novel challenges, in that classes may be altered at runtime, both through the addition, removal, or modification of attributes such as member variables a...

View PDFchevron_right

Related topics

  • Computer Science
  • python programming language
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved