Arénaire is a joint project of CNRS, École Normale Supérieure de Lyon (U. Lyon), INRIA, and Université Claude Bernard de Lyon (U. Lyon). As part of the Laboratoire de l'Informatique du Parallélisme (LIP, UMR 5668), it is located at Lyon in the buildings of the ÉNS.

The Arénaire project aims at elaborating and consolidating knowledge in the field of Computer Arithmetic. Reliability, accuracy, and performance are the major goals that drive our studies. Our goals address various domains such as floating-point numbers, intervals, rational numbers, or finite fields. We study basic arithmetic operators such as adders, dividers, etc. We work on new operators for the evaluation of elementary and special functions ( log, cos, erf, etc.), and also consider the composition of previous operators. In addition to these studies on the arithmetic operators themselves, our research focuses on specific application domains (cryptography, signal processing, linear algebra, lattice basis reduction, etc.) for a better understanding of the impact of the arithmetic choices on solving methods in scientific computing.

We contribute to the improvement of the available arithmetic on computers, processors, dedicated or embedded chips, etc., both at the hardware level and at the software level. Improving computing does not necessarily mean getting more accurate results or getting them faster: we also take into account other constraints such as power consumption, code size, or the reliability of numerical software. All branches of the project focus on algorithmic research and on the development and the diffusion of corresponding libraries, either in hardware or in software. Some distinctive features of our libraries are numerical quality, reliability, and performance.

The study of the number systems and, more generally, of data representations is a first topic of uttermost importance in the project. Typical examples are: the redundant number systems used inside multipliers and dividers; alternatives to floating-point representation for special purpose systems; finite field representations with a strong impact on cryptographic hardware circuits; the performance of an interval arithmetic that heavily depends on the underlying real arithmetic.

Another general objective of the project is to improve the validation of computed data, we mean to provide more guarantees on the quality of the results. For a few years we have been handling those validation aspects in the following three complementary ways: through better qualitative properties and specifications (correct rounding, error bound representation, and portability in floating-point arithmetic); by proposing a development methodology focused on the proven quality of the code; by studying and allowing the cooperation of various kinds of arithmetics such as constant precision, intervals, arbitrary precision and exact numbers.

These goals may be organized in four directions:
*hardware arithmetic*,
*software arithmetic for algebraic and elementary functions*,
*validation and automation*, and
*arithmetics and algorithms for scientific computing*. These directions are not independent and have strong interactions. For example, elementary functions are also studied for hardware
targets, and scientific computing aspects concern most of the components of Arénaire.

*Hardware Arithmetic.*From the mobile phone to the supercomputer, every computing system relies on a small set of computing primitives implemented in hardware. Our goal is to study the
design of such arithmetic primitives, from basic operations such as the addition and the multiplication to more complex ones such as the division, the square root, cryptographic primitives,
and even elementary functions. Arithmetic operators are relatively small hardware blocks at the scale of an integrated circuit, and are best described in a structural manner: a large
operator is assembled from smaller ones, down to the granularity of the bit. This study requires knowledge of the hardware targets (ASICs, FPGAs), their metrics (area, delay, power), their
constraints, and their specific language and tools. The input and output number systems are typically given (integer, fixed-point of floating-point), but internally, non-standard internal
number systems may be successfully used.

*Algebraic and Elementary Functions.*Computer designers still have to implement the basic arithmetic functions for a medium-size precision. Addition and multiplication have been much
studied but their performance may remain critical (silicon area or speed). Division and square root are less critical, however there is still room for improvement (e.g. for division, when
one of the inputs is constant). Research on new algorithms and architectures for elementary functions is also very active. Arénaire has a strong reputation in these domains and will keep
contributing to their expansion. Thanks to past and recent efforts, the semantics of floating-point arithmetic has much improved. The adoption of the IEEE-754 standard for floating-point
arithmetic has represented a key point for improving numerical reliability. Standardization is also related to properties of floating-point arithmetic (invariants that operators or
sequences of operators may satisfy). Our goal is to establish and handle new properties in our developments (correct rounding, error bounds, etc.) and then to have those results integrated
into the future computer arithmetic standards.

*Validation and Automation.*Validation corresponds to some guarantee on the quality of the evaluation. Several directions are considered, for instance the full error (approximation
plus rounding errors) between the exact mathematical value and the computed floating-point result, or some guarantee on the range of a function. Validation also comprises a proof of this
guarantee that can be checked by a proof checker. Automation is crucial since most development steps require specific expertise in floating-point computing that can neither be required from
code developers nor be mobilised manually for every problems.

*Arithmetics and Algorithms.*When conventional floating-point arithmetic does not suffice, we use other kinds of arithmetics. Especially in the matter of error bounds, we work on
interval arithmetic libraries, including arbitrary precision intervals. Here a main domain of application is global optimization. Original algorithms dedicated to this type of arithmetic
must be designed in order to get accurate solutions, or sometimes simply to avoid divergence (e.g., infinite intervals). We also investigate exact arithmetics for computing in algebraic
domains such as finite fields, unlimited precision integers, and polynomials. A main objective is a better understanding of the influence of the output specification (approximate within a
fixed interval, correctly rounded, exact, etc.) on the complexity estimates for the problems (e.g., linear algebra in mathematical computing).

Our work in Arénaire since its creation in 1998, and especially since 2002, provides us a strong expertise in computer arithmetic. This knowledge, together with the technology progress both
in software and hardware, draws the evolution of our objectives towards the
*synthesis of validated algorithms*.

2007 has seen a decisive convergence of the revision of the IEEE-754 standard for floating-point arithmetic, a process begun in 2000. In its current draft, which many consider close to final, the standard advocates correct rounding of elementary functions, which will lead to more accurate results and better reproducibility. This is a result of many years of concerted efforts, covering most of the directions listed above, by members of Arénaire.

As stated above, four major directions in Arénaire are
*hardware arithmetic*,
*algebraic and elementary functions*,
*validation and automation*, and
*arithmetics and algorithms*. For each of those interrelated topics, we describe below the tools and methodologies on which it relies.

A given computing application may be implemented using different technologies, with a large range of trade-offs between the various aspects of performance, unit cost, and non-recurring costs (including development effort).

A software implementation, targeting off-the-shelf microprocessors, is easy to develop and reproduce, but will not always provide the best performance.

For cost or performance reasons, some applications will be implemented as application specific integrated circuits (ASICs). An ASIC provides the best possible performance and may have a very low unit cost, at the expense of a very high development cost.

An intermediate approach is the use of reconfigurable circuits, or field-programmable gate arrays (FPGAs).

In each case, the computation is broken down into elementary operations, executed by elementary hardware elements, or
*arithmetic operators*. In the software approach, the operators used are those provided by the microprocessor. In the ASIC or FPGA approaches, these operators have to be built by the
designer, or taken from libraries. Our goals include studying operators for inclusion in microprocessors and developing hardware libraries for ASICs or FPGAs.

**Operators under study.**Research is active on algorithms for the following operations:

Basic operations (addition, subtraction, multiplication), and their variations (multiplication and accumulation, multiplication or division by constants, etc.);

Algebraic functions (division, inverse, and square root, and in general, powering to an integer, and polynomials);

Elementary functions (sine, cosine, exponential, etc.);

Combinations of the previous operations (norm, for instance).

A hardware implementation may lead to better performance than a software implementation for two main reasons: parallelism and specialization. The second factor, from the arithmetic point of view, means that specific data types and specific operators, which would require costly emulation on a processor, may be used. For example, some cryptography applications are based on modular arithmetic and bit permutations, for which efficient specific operators can be designed. Other examples include standard representations with non-standard sizes, and specific operations such as multiplication by constants.

**Hardware-oriented algorithms.**Many algorithms are available for the implementation of elementary operators (see for instance
). For example, there are two classes of division algorithms: digit-recurrence and function iteration. The choice
of an algorithm for the implementation of an operation depends on, and sometimes imposes, the choice of a number representation. Besides, there are usually technological constraints such as the
area and power budget, and the available low-level libraries.

The choice of the number systems used for the intermediate results is crucial. For example, a redundant system, in which a number may have several encodings, will allow for more design freedom and more parallelism, hence faster designs. However, the hardware cost can be higher. As another example, the power consumption of a circuit depends, among other parameters, on its activity, which in turn depends on the distribution of the values of the inputs, hence again on the number system.

Alternatives exist at many levels in this algorithm exploration. For instance, an intermediate result may be either computed, or recovered from a precomputed table.

**Parameter exploration.**Once an algorithm is chosen, optimizing its implementation for area, delay, accuracy, or energy consumption is the next challenge. The best solution depends on the
requirements of the application and on the target technology. Parameters which may vary include the radix of the number representations, the granularity of the iterations (between many simple
iterations, or fewer coarser ones), the internal accuracies used, the size of the tables (see
for an illustration), etc.

The parameter space quickly becomes huge, and the expertise of the designer has to be automated. Indeed, we do not design operators, but
*operator generators*, programs that take a specification and some constraints as input, and output a synthesizable description of an operator.

**Elementary Functions and Correct Rounding.**Many libraries for elementary functions are currently available. We refer to
for a general insight into the domain. The functions in question are typically those defined by the C99 and LIA-2
standards, and are offered by vendors of processors, compilers or operating systems.

Though the IEEE-754 standard does not deal with these functions, there is some attempt to reproduce some of their mathematical properties, in particular symmetries. For instance,
monotonicity can be obtained for some functions in some intervals as a direct consequence of accurate internal computations or numerical properties of the chosen algorithm to evaluate the
function; otherwise it may be
*very*difficult to guarantee, and the general solution is to provide it through correct rounding. Preserving the range (e.g.,
atan(
x)
[-
/2,
/2]) may also be a goal though it may conflict with correct rounding (when
supported).

Concerning the correct rounding of the result, it is not required by the IEEE-754 standard: during the elaboration of this standard, it was considered that correctly rounded elementary
functions was impossible to obtain at a reasonable cost, because of the so called
*Table Maker's Dilemma*: an elementary function is evaluated to some internal accuracy (usually higher than the target precision), and then rounded to the target precision. What is the
minimum accuracy necessary to ensure that rounding this evaluation is equivalent to rounding the exact result, for all possible inputs? This question cannot be answered in a simple manner,
meaning that correctly rounding elementary functions requires arbitrary precision, which is very slow and resource-consuming.

Indeed, correctly rounded libraries already exist, such as MPFR (
http://
`libmcr`library, released by Sun Microsystems in late 2004. However they have worst-case execution time and memory consumption up to 10,000 worse than usual libraries, which is the main
obstacle to their generalized use.

We have focused in the previous years on computing bounds on the intermediate precision required for correctly rounding some elementary functions in IEEE-754 double precision. This allows us to design algorithms using a tight precision. That makes it possible to offer the correct rounding with an acceptable overhead: we have experimental code where the cost of correct rounding is negligible in average, and less than a factor 10 in the worst case.

It also enables to prove the correct-rounding property, and to show bounds on the worst-case performance of our functions. Such worst-case bounds may be needed in safety critical applications as well as a strict proof of the correct rounding property. Concurrent libraries by IBM and Sun can neither offer a complete proof for correct rounding nor bound the timing because of the lack of worst-case accuracy information. Our work actually shows a posteriori that their overestimates for the needed accuracy before rounding are however sufficient. IBM and Sun for themselves could not provide this information. See also § concerning the proofs for our library.

**Approximation and Evaluation.**The design of a library with correct rounding also requires the study of algorithms in large (but not arbitrary) precision, as well as the study of more
general methods for the three stages of the evaluation of elementary functions: argument reduction, approximation, and reconstruction of the result.

When evaluating an elementary function for instance, the first step consists in reducing this evaluation to the one of a possibly different function on a small real interval. Then, this last function is replaced by an approximant, which can be a polynomial or a rational fraction. Being able to perform those processes in a very cheap way while keeping the best possible accuracy is a key issue . The kind of approximants we can work with is very specific: the coefficients must fulfill some constraints imposed by the targeted application, such as some limits on their size in bits. The usual methods (such as Remez algorithm) do not apply in that situation and we have to design new processes to obtain good approximants with the required form. Regarding to the approximation step, there are currently two main challenges for us. The first one is the computation of excellent approximations that will be stored in hardware or in software and that should be called thousands or millions of times. The second one is the target of automation of computation of good approximants when the function is only known at compile time. A third question concerns the evaluation of such good approximants. To find a best compromise between speed and accuracy, we combine various approaches ranging from numerical analysis (tools like backward and forward error analysis, conditioning, stabilization of algorithms) to computer arithmetic (properties like error-free subtraction, exactly-computable error bounds, etc.). The structure of the approximants must further be taken into account, as well as the degree of parallelism offered by the processor targeted for the implementation.

**Adequation Algorithm/Architecture.**Some special-purpose processors, like DSP cores, may not have floating-point units, mainly for cost reasons. For such integer or fixed-point processors,
it is thus desirable to have software support for floating-point functions, starting with the basic operations. To facilitate the development or porting of numerical applications on such
processors, the emulation in software of floating-point arithmetic should be compliant with the IEEE-754 standard; it should also be very fast. To achieve this twofold goal, a solution is to
exploit as much as possible the characteristics of the target processor (instruction set, parallelism, etc.) when designing algorithms for floating-point operations.

So far, we have successfully applied this “algorithm/architecture adequation” approach to some VLIW processor cores from STMicroelectronics, in particular the ST231; the ST231 cores have integer units only, but for their applications (namely, multimedia applications), being able to perform basic floating-point arithmetic very efficiently was necessary. When various architectures are targeted, this approach should further be (at least partly) automated. The problem now is not only to write some fast and accurate code for one given architecture, but to have this optimized code generated automatically according to various constraints (hardware resources, speed and accuracy requirements).

Validating a code, or generating a validated code, means being able to prove that the specifications are met. To increase the level of reliability, the proof should be checkable by a formal proof checker.

**Specifications of qualitative aspects of floating-point codes.**A first issue is to get a better formalism and specifications for floating-point computations, especially concerning the
following qualitative aspects:

*specification:*typically, this will mean a proven error bound between the value computed by the program and a mathematical value specified by the user in some high-level format;

*tight error bound computation*;

*floating-point issues:*regarding the use of floating-point arithmetic, a frequent concern is the portability of code, and thus the reproducibility of computations; problems can be due
to successive roundings (with different intermediate precisions) or the occurrence of underflows or overflows;

*precision:*the choice of the method (compensated algorithm versus double-double versus quadruple precision for instance) that will yield the required accuracy at given or limited cost
must be studied;

*input domains and output ranges:*the determination of input domain or output range also constitutes a specification/guarantee of a computation;

*other arithmetics, dedicated techniques and algorithms for increased precision:*for studying the quality of the results, most of conception phases will require
*multiple-precision*or
*exact*solutions to various algebraic problems.

**Certification of numerical codes using formal proof.**Certifying a numerical code is error-prone. The use of a proof assistant will ensure the code correctly follows its specification.
This certification work, however, is usually a long and tedious work, even for experts. Moreover, it is not adapted to an incremental development, as a small change to the algorithm may
invalidate the whole formal proof. A promising approach is the use of automatic tools to generate the formal proofs of numerical codes with little help from the user.

Instead of writing code in some programming language and trying to prove it, we can design our own language, well-suited to proofs (e.g., close to a mathematical point of view, and allowing metadata related to the underlying arithmetics such as error bounds, ranges, and so on), and write tools to generate code. Targets can be a programming language without extensions, a programming language with some given library (e.g., MPFR if one needs a well-specified multiple-precision arithmetic), or a language internal to some compiler: the proof may be useful to give the compiler some knowledge, thus helping it to do particular optimizations. Of course, the same proof can hold for several targets.

We worked in particular also on the way of giving a formal proof for our correctly rounded elementary function library. We have always been concerned by a precise proof of our implementations that covers also details of the numerical techniques used. Such proof concern is mostly absent in IBM's and Sun's libraries. In fact, many misroundings were found in their implementations. They seem to be mainly due to coding mistakes that could have been avoided with a formal proof in mind. In CRlibm we have replaced more and more hand-written paper proofs by Gappa verified proof scripts that are partially generated automatically by other scripts. Human error is better prevented.

**Integrated and interoperable automatic tools.**Various automatic components have been independently introduced above, see §
and §
. One of our main objectives is to provide an entire automatic approach taking in input an expression to evaluate (with
possible annotations), and returning an executable validated code. The complete automation with optimal or at least good resulting performance seems to be far beyond the current knowledge.
However, we see our objective as a major step for prototyping future compilers. We thus aim at developing a piece of software that automates the steps described in the previous pages. The
result should be an easy-to-use integrated environment.

When computing a solution to a numerical problem, an obvious question is that of the
*quality*of the produced numbers. One may also require a certain level of quality, such as: approximate with a given error bound, correctly rounded, or –if possible– exact. The question
thus becomes twofold: how to produce such a well-specified output and at what cost? To answer it, we focus on
*polynomial and integer matrix operations*,
*Euclidean lattices*and
*global optimization*, and study the following directions:

We investigate new ways of producing well-specified results by resorting to various arithmetics (intervals, Taylor models, multi-precision floating-point, exact). A first
approach is to
*combine*some of them: for example, guaranteed enclosures can be obtained by mixing Taylor model arithmetic with floating-point arithmetic
. Another approach is to
*adapt*the precision or even
*change*the arithmetic during the course of a computation. Typical examples are iterative refinement techniques or exact results obtained via floating-point basic operations. This
often requires arithmetics with very-well
*specified properties*(like the IEEE-754 standard for floating-point arithmetic).

We also study the impact of certification on algorithmic complexity. A first approach there is to augment existing algorithms with validated error bounds (and not only
error estimates). This leads us to study the (im)possibility of
*computing such bounds*on the fly at a negligible cost. A second approach is to study the
*algorithmic changes*needed to achieve a higher level of quality without, if possible, sacrificing for speed. In exact linear algebra, for example, the fast algorithms recently
obtained in the bit complexity model are far from those obtained decades ago in the algebraic complexity model.

**Numerical Algorithms using Arbitrary Precision Interval Arithmetic.**When validated results are needed, interval arithmetic can be used. New problems can be solved with this arithmetic,
which provides sets instead of numbers. In particular, we target the global optimization of continuous functions. A solution to obviate the frequent overestimation of results is to increase the
precision of computations.

Our work is twofold. On the one hand, efficient software for arbitrary precision interval arithmetic is developed, along with a library of algorithms based on this arithmetic. On the other hand, new algorithms that really benefit from this arithmetic are designed, tested, and compared.

To reduce the overestimation of results, variants of interval arithmetic have been developed, such as Taylor models arithmetic or affine arithmetic. These arithmetics can also benefit from arbitrary precision computations.

**Algorithms for Exact Linear Algebra and Lattice Basis Reduction.**The techniques for exactly solving linear algebra problems have been evolving rapidly in the last few years, substantially
reducing the complexity of several algorithms (see for instance
for an essentially optimal result, or
). Our main focus is on matrices whose entries are integers or univariate polynomials over a field. For such
matrices, our main interest is how to relate the size of the data (integer bit lengths or polynomial degrees) to the cost of solving the problem exactly. A first goal is to design
asymptotically faster algorithms, to reduce problems to matrix multiplication in a systematic way, and to relate bit complexity to algebraic complexity. Another direction is to make these
algorithms fast in practice as well, especially since applications yield very large matrices that are either sparse or structured. Within the LinBox international project, we work on a software
library that corresponds to our algorithmic research on matrices. LinBox is a generic library that allows to plug external components in a plug-and-play fashion. The library is devoted to
sparse or structured exact linear algebra and its applications.

We recently started a direction around lattice basis reduction. Euclidean lattices provide powerful tools in various algorithmic domains. In particular, we investigate applications in computer arithmetic, cryptology, algorithmic number theory and communications theory. We work on improving the complexity estimates of lattice basis reduction algorithms and providing better implementations of them, and on obtaining more reduced bases. The above recent progress in linear algebra may provide new insights.

**Certified Computing.**Most of the algorithmic complexity questions that we investigate concern algebraic or bit-complexity models for exact computations. Much less seems to be known in
approximate computing, especially for the complexity of computing (certified) error bounds, and for establishing bridges between exact, interval, and constant precision complexity estimates. We
are developing this direction both for a theoretical impact, and for the design and implementation of algorithm synthesis tools for arithmetic operators, and mathematical expression
evaluation.

Our expertise covers application domains for which the quality, such as the efficiency or safety, of the arithmetic operators is an issue. On the one hand, it can be applied to hardware oriented developments, for example to the design of arithmetic primitives which are specifically optimized for the target application and support. On the other hand, it can also be applied to software programs, when numerical reliability issues arise: these issues can consist in improving the numerical stability of an algorithm, computing guaranteed results (either exact results or certified enclosures) or certifying numerical programs.

The application domains of hardware arithmetic operators are
**digital signal processing**,
**image processing**,
**embedded applications**and
**cryptography**.

Developments of
**correctly rounded elementary functions**is critical to the
**reproducibility**of floating-point computations. Exponentials and logarithms, for instance, are routinely used in accounting systems for interest calculation, where roundoff errors
have a financial meaning. Our current focus is on bounding the worst-case time for such computations, which is required to allow their use in
**safety critical**applications, and in proving the correct rounding property for a complete implementation.

Certifying a numerical application usually requires bounds on rounding errors and ranges of variables. Our automatic tool (see §
) computes or verifies such bounds. For increased confidence in the numerical applications, it also generates formal
proofs of the arithmetic properties. These proofs can then be used and machine-checked by proof assistants like
**Coq**.

Arbitrary precision interval arithmetic can be used in two ways to
**validate a numerical result**. To
**quickly check the accuracy**of a result, one can replace the floating-point arithmetic of the numerical software that computed this result by high-precision interval arithmetic and
measure the width of the interval result: a tight result corresponds to good accuracy. When
**getting a guaranteed enclosure**of the solution is an issue, then more sophisticated procedures, such as those we develop, must be employed: this is the case of global optimization
problems.

The design of faster algorithms for matrix polynomials provides faster solutions to various problems in
**control theory**, especially those involving multivariable linear systems.

Lattice reduction algorithms have direct applications in public-key cryptography. They also naturally arise in computer algebra. A new and promising field of applications is communications theory.

Arénaire proposes various software and hardware realizations that are accessible from the web page
http://

The CRlibm project aims at developing a mathematical library (
`libm`) which provides implementations of the double precision C99 standard elementary functions,

correctly rounded in the four IEEE-754 rounding modes,

with a comprehensive proof of both the algorithms used and their implementation,

sufficiently efficient in average time, worst-case time, and memory consumption to replace existing
`libm`s transparently.

In 2007, we released the versions 0.17beta1, 0.18beta1 and 1.0beta1 with 7 more functions:
sin(
x),
cos(
x)
tan(
x)and their inverse functions, and the power function
x^{y}. We also have published our algorithm for correctly-rounded logarithms
.

The library includes a documentation which makes an extensive tutorial on elementary function software development.

The library has been downloaded more than 3500 times. Its focus on performance and correctness has enabled acceptance of correct rounding as a goal of the revised floating-point standard IEEE-754R. It is also considered for inclusion in the GNU compiler collection.

**Status:**
Beta release /
**Target:**
ia32, ia64, Sparc, PPC /
**License:**
LGPL /
**OS:**
Unix /
**Programming Language:**
C /
**URL:**
http://

Sollya aims at providing a safe, user-friendly, all-in-one environment for manipulating numerical functions. Sollya provides both safe and efficient algorithms: certified infinite norm, multiple-precision faithful-rounding evaluator of composed functions, efficient numerical approximate algorithms for searching approximations of the zeros of a function, finding a polynomial approximation, etc.

Sollya comes with an interpreter for the Sollya scripting language. Existing Sollya primitives can be extended with dynamically-linked user code.

Sollya used to be a small software project called
*arenaireplot*. In 2007, it has been highly improved (quicker implementation of existing algorithms and implementation of new features such as the programming language).

Sollya has been used for implementing the polynomial evaluation inside the CRlibm functions added in 2007, along with their Gappa proofs.

**Status:**
Release scheduled for December 2007 /
**Target:**
ia32, ia64, PPC, ia32-64, other /
**License:**
CeCILL-C /
**OS:**
Unix /
**Programming Language:**
C /
**URL:**
http://

FPLibrary is a VHDLlibrary that describes arithmetic operators (addition, subtraction, multiplication, division, and square root) for two formats of representation of real numbers: floating-point, and logarithmic number system (LNS). These formats are parametrized in precision and range. FPLibrary is the first hardware library to offer parametrized hardware architectures for elementary functions in addition to the basic operations. In 2007, an efficient floating-point accumulator has been added.

FPLibrary is being used by tens of academic or industrial organizations in the world. In 2007, its trigonometric operators have been included in a standard set of benchmarks defined by the Altera corporation and the university of Berkeley.

**Status:**
Stable /
**Target:**
FPGA /
**License:**
GPL/LGPL /
**OS:**
Unix, Linux, Windows /
**Programming Language:**
VHDL /
**URL:**
http://

The purpose of the FloPoCo project is to explore the many ways in which the flexibility of the FPGA target can be exploited in the arithmetic realm. FloPoCo is a generator of operators written in C++ and outputting synthesizable VHDL. The first release of FloPoCo, in 2007, include multipliers of an integer or a floating-point number by a constant, and a generalization of the long accumulator introduced by Kulisch.

**Status:**
Beta release /
**Target:**
FPGA /
**License:**
GPL/LGPL /
**OS:**
Unix, Linux, Windows /
**Programming Language:**
C++ /
**URL:**
http://

Library in C for interval arithmetic using arbitrary precision (arithmetic and algebraic operations, elementary functions, operations on sets). Modifications made this year mainly concern the correction of bugs.

**Status:**
Beta release /
**Target:**
any /
**License:**
LGPL /
**OS:**
Unix, Linux, Windows (Cygwin) /
**Programming Language:**
C /
**URL:**
http://

This software library is developed within a national initiative Ministry Grant ACI “New interfaces of mathematics” (see § ).

MEPLib is a library for automatic generation of polynomial approximations of functions under various constraints, imposed by the user, on the coefficients of the polynomials. The constraints may be on the size in bits of the coefficients or the values of these coefficients or the form of these coefficients. It relies on the linear programming tool PIP and interacts with the Sollya library. It should be useful to engineers or scientists for software and hardware implementations.

**Status:**
Beta release /
**Target:**
various processors, DSP, ASIC, FPGA /
**License:**
GPL /
**OS:**
Unix, Linux, Windows (Cygwin) /
**Programming Language:**
C /
**URL:**
http://

Given a logical property involving interval enclosures of mathematical expressions, Gappa tries to verify this property and generates a formal proof of its validity. This formal proof can be machine-checked by an independent tool like the Coq proof-checker, so as to reach a high level of confidence in the certification.

Since these mathematical expressions can contain rounding operators in addition to usual arithmetic operators, Gappa is especially well suited to prove properties that arise when certifying a numerical application, be it floating-point or fixed-point. Gappa makes it easy to compute ranges of variables and bounds on absolute or relative roundoff errors.

Gappa is being used in several projects, including CRlibm, FLIP, Sollya, and CGal .

In 2007, the syntax of user rules was extended in order to formally prove a wider set of properties. The accessibility of Gappa was improved when starting new proofs. The support library was extended with new results on floating-point arithmetic and relative errors.

**Status:**
Beta release /
**Target:**
any /
**License:**
GPL, CeCILL /
**OS:**
any /
**Programming Language:**
C++ /
**URL:**
http://

FLIP is a C library for efficient software support of single precision floating-point arithmetic on processors without floating-point hardware units, such as VLIW or DSP processors for embedded applications. The current target architecture is the VLIW ST200 family from STMicroelectronics (especially the ST231 cores).

In 2007 we have completely rewritten the code for add, sub, square, multiply, and for the most basic algebraic functions: square root, inverse square root, reciprocal, division. This resulted in substantial speed-ups compared to the previous codes. The tools used for the design include Gappa (§ ) and Sollya (§ ). Our approach to computing square roots is described in .

**Status:**
Beta release /
**Target:**
VLIW processors (ST200 family from STMicroelectronics) /
**License:**
LGPL /
**OS:**
Linux, Windows /
**Programming Language:**
C /
**URL:**
http://

MPFR is a multiple-precision floating-point library with correct rounding developed by the Arénaire and Cacao projects. The computation is both efficient and has a well-defined semantics. It copies the good ideas from the IEEE-754 standard. MPFR 2.3.0 was released on 29 August 2007.

The main changes done in 2007 are: new functions, improved tests (they allowed to find bugs in very particular cases), better documentation, bug fixes (which mainly consisted in completing the implementation of some functions on particular cases).

Several software systems use MPFR, for example: the KDE calculator Abakus by Michael Pyne; the ALGLIB.NET project; CGAL (Computational Geometry Algorithms Library) developed by the Geometrica team (INRIA Sophia-Antipolis); the Fluctuat tool developed and used internally at the CEA; Gappa (§ ); Genius Math Tool and the GEL language, by Jiri Lebl; GCC; Giac/Xcas, a free computer algebra system, by Bernard Parisse; the iRRAM exact arithmetic implementation from Norbert Müller (University of Trier, Germany); the Magma computational algebra system; MPFI (§ ); the mpfs library, an experiment in stochastic lazy floating-point arithmetic, from Keith Briggs; SAGE; the Wcalc calculator by Kyle Wheeler.

**Status:**
stable /
**Target:**
any /
**License:**
LGPL /
**OS:**
Unix, Windows (Cygwin or MinGW) /
**Programming Language:**
C /
**URL:**
http://

Given a set of vectors with integer coordinates, the aim of fpLLL is to compute an LLL-reduced basis of the euclidean lattice that is spanned by the vectors. The reduction is performed efficiently thanks to the use of floating-point arithmetic for the computation of the underlying Gram-Schmidt orthogonalization (central in LLL).

The computation is both fully rigorous and efficient. A hierarchy of heuristic/fast and provable/slower variants is used in order to provide these two properties simultaneously.

fpLLL is used in the SAGE project, and an earlier version of fpLLL is in MAGMA (
http://

In 2007, fpLLL underwent a massive update, in major part by David Cadé, an ENS Master student who was hosted in the team during the summer. The new version, fpLLL-2.1, is faster, and more importantly considerably easier to use and extend.

**Status:**
Version 2.1.6 /
**Target:**
any /
**License:**
GPL /
**OS:**
Linux /
**Programming Language:**
C++ /
**URL:**
http://

The programs to search for the worst cases for the correct rounding of mathematical functions ( exp, log, sin, cos, etc.) using Lefèvre's algorithm have been further improved, in particular:

More robust control scripts, working in more environments, with more automation.

More supported functions.

One of the scripts has entirely been reimplemented, using MPFR instead of Maple, and with more features.

The scripts have been modified to be able to support special functions whose worst-case information has been used for .

Profiling information can now be automatically generated (with very little overhead) and used. This allows to gain up to 22% on Opteron processors.

Milos D. Ercegovac (University of California at Los Angeles) and J.-M. Muller have improved their results of 2004 on digit recurrence algorithms for complex square-root (for which they obtained a best paper award at the ASAP-2004 conference). They have published the obtained results in a special issue of the Journal of VLSI Signal Processing .

The E-method, introduced by Ercegovac, allows efficient parallel solution of diagonally dominant systems of linear equations in the real domain using simple and highly regular hardware.
Since the evaluation of polynomials and certain rational functions can be achieved by solving the corresponding linear systems, the E-method is an attractive general approach for function
evaluation. Milos D. Ercegovac and J.-M. Muller have generalized the E-method to complex linear systems, and have shown some potential applications such as the evaluation of complex
polynomials by a digit-recurrence method
. They have derived algorithms and schemes for computing common arithmetic expressions defined in the complex
domain as hardware-implemented operators.The operators include Complex Multiply-Add, Complex Sum of Products, Complex Sum of Squares and complex Integer Powers. Again, the proposed approach
is to map the expression to a system of linear equations, apply a complex-to-real transform, and compute the solutions to the linear system using a digit-by-digit, the most significant digit
first, recurrence method. The components of the solution vector corresponds to the expressions being evaluated. The number of digit cycles is about
mfor
m-digit precision. The basic modules are similar to left-to-right multipliers. The interconnections between the modules are digit-wide
.

With J.-L. Beuchat, T. Miyoshi and E. Okamoto (Tsukuba University, Japan), J.-M. Muller has written a survey
on the Horner's rule-based algorithms for Multiplication over
GF(
p)and
GF(
p^{n}). They present a generic architecture based on five processing elements and introduce a classification of several algorithms based on their model. They provide the readers with
a detailed description of each scheme which should allow them to write a VHDL description or a VHDL code generator.

R. Michard and N. Veyrat-Charvillon have worked with A. Tisserrand, former team member now at LIRMM. They have improved a new method to optimize hardware operators for the evaluation of fixed-point unary functions. Starting from an ideal minimax polynomial approximation of the function, it first looks for a polynomial whose coefficients are fixed-point numbers of small size. It then bounds accurately the evaluation error using the Gappa tool. This work was first published at the Sympa conference in 2006 and the improvements are to be published in 2008 .

R. Michard has started a work on power consumption. It is a study of several hardware operator families and aims at evaluating the consumption of each to be able to choose what kind of operator is required when designing a circuit. This work is based on Xilinx Power Estimator to characterize operators on Xilinx FPGAs. This work is in progress and will be the subject of a publication in 2008.

Three hardware algorithms for elementary functions implemented in FPLibrary were published in 2007: a dual sine/cosine operator up to single precision, along with a study of the tradeoffs involved, by J. Detrey, F. de Dinechin , and an exponential and a logarithm up to double precision featuring quadratic area using an iterative range reduction, by J. Detrey, F. de Dinechin and X. Pujol (an ÉNS-Lyon student) .

With O. Creţ, I. Trestian, L. Creţ, L. Vǎcariu and R. Tudoran from the Technical University of Cluj-Napoca, F. de Dinechin has worked on the implementation of a hardware accelerator used for the simulation of coils to be used for transcranial magnetic stimulation . The implementation of a full floating-point pipeline on an FPGA reduces simulation time from several hours to a few seconds, and allows practical trial-and-error design of complex coil conformations. This work relies on FPLibrary, and uses in particular its logarithm operator.

This collaboration with users of Arénaire's floating-point operators has pointed out that the flexibility of FPGA hardware is currently underused when floating-point applications are ported to this target. With his collaborators from UCTN, F. de Dinechin has written a prospective survey of the many ways to better exploit this flexibility . Techniques surveyed include specific accumulator design, operator specialization, operator fusion, combining floating- and fixed-point, coarser operators such as elementary functions, 2Sum, 2Mult or interval operators, etc. This survey defines the philosophy of the FloPoCo project.

Since their introduction in constructive cryptographic applications, pairings over (hyper)elliptic curves are at the heart of an ever increasing number of protocols. Software implementations being rather slow, the study of hardware architectures became an active research area.

In collaboration with J.-L. Beuchat and E. Okamoto (Tsukuba Univ., Japan) and M. Shirase and T. Takagi (Future Univ. of Hakodate, Japan), N. Brisebarre and J. Detrey
proposed in
,
,
several algorithms to compute the
_{T}pairing in characteristic three. These algorithms involve addition, multiplication, cubing, inversion, and sometimes cube root extraction over
. The authors also propose a hardware accelerator based on a unified arithmetic operator able to perform the operations required by a given algorithm. and describe the implementation
of a compact coprocessor for the field
given by
, which compares favorably with other solutions described in the open literature. The article
received the CHES'2007 best paper award.

We keep on developing methods for generating the best, or at least very good, polynomial approximations (with respect to the infinite norm or the
L^{2}norm) to functions, among polynomials whose coefficients follow size constraints (e.g., the degree-
icoefficient has at most
m_{i}fractional bits, or it has a given, fixed, value). This is a key step in the process of function evaluation.

About the
L^{2}norm, N. Brisebarre and G. Hanrot (LORIA, INRIA Lorraine) published a complete study of the problem
. Using here again tools from euclidean lattice basis reduction, they gave theoretical and algorithmic results
that make it possible to get optimal approximants.

We are developing libraries for generating such polynomial approximations (see Sections and ).

These two constant are exactly representable in double precision arithmetic. If executed with a fused multiply-add with round-to-nearest mode, the following algorithm

will always return the floating-point number
u_{2}that is nearest
x.

P. Kornerup (Odense University, Denmark), V. Lefèvre and J.-M. Muller have introduced two algorithms for accurately evaluating powers to a positive integer in floating-point arithmetic, assuming a fused multiply-add (fma) instruction is available. They show that their log-time algorithm always produce faithfully-rounded results, discuss the possibility of getting correctly rounded results, and show that results correctly rounded in double precision can be obtained if extended-precision is available with the possibility to round into double precision (with a single rounding).

Correctly-rounded floating-point square roots can be obtained in many ways: by iterative methods (restoring, non-restoring, SRT), by multiplicative methods (Newton, Goldschmidt), or by methods based on the evaluation of high-quality polynomial approximants. With H. Knochel and C. Monat (STMicroelectronics, Grenoble), C.-P. Jeannerod and G. Revy compared those methods in the context of emulation in single precision on the ST231 VLIW integer processor cores of STMicroelectronics. They showed that polynomial-based methods can be made most efficient by exploiting some key architectural features. Then, in , they made this approach simpler (using a single polynomial instead of two) and faster (proposing an improved evaluation scheme). This resulted in a latency of 21 cycles for rounding to nearest. Other rounding modes have also been added, yielding similar latencies, and it was shown that supporting subnormals can be done with an overhead of at most 3 cycles. Finally, the approach turns out to extend immediately to other basic algebraic functions like reciprocal, inverse square root and division.

N. Brisebarre and J.-M. Muller have published a method that makes it possible to get bounds on the accuracy with which intermediate calculations must be carried-on to allow for correctly-rounded algebraic functions .

This new rounding boundary test consists of a few comparisons with pre-computed constants. These constants are deduced from worst cases for the Table Maker's Dilemma, searched over a small subset of the input domain. This is a novel use of such worst-case bounds.

F. de Dinechin, C. Q. Lauter and G. Melquiond have worked on the use of the Gappa tool for proving an elementary function .

S. Chevillard and C. Lauter have worked on the problem of providing a certified bound on the infinite norm of a function . This is useful when designing the implementation of a correctly rounded elementary function: the function is approximated by a polynomial, and one needs a validated, yet tight bound on this approximation error . Commercial tools provide only an approximation of the infinite norm, and do not even guarantee that it is an over-approximation. The algorithm published in has been implemented in the Sollya tool.

Our implementation of Taylor models arithmetic is developed in PVS. We provide new strategies to recursively apply operators on Taylor models, with as few intervention of the user as possible . With these strategies, users can quickly evaluate a formula or prove an inequality and translate it into a fully qualified proof certified by PVS. We applied them to prove error bounds on polynomial approximations of some functions, one of the applications being a computation involved in air traffic conflict resolution .

The implementation of Taylor models arithmetic may use floating-point arithmetic to benefit from the speed of the floating-point implementation. In , we assume that the floating-point arithmetic is compliant with the IEEE-754 standard. We show how to bound roundoff errors and how to take these roundoff errors into account into the interval remainder part. We also propose an implementation of Taylor models with multiple precision coefficients.

When a given computation does not yield the required accuracy, the computation can be done (either restarted or continued) using an increasing computing precision. A natural question is how to increase the computing precision in order to minimize the time overhead, compared to the case where the optimal computing precision is known in advance and used for the computation. We generalize a result by Kreinovich and Rump: we study the case where the computation can benefit from results obtained with a lower precision and thus is not restarted but rather continued. We also propose an asymptotically optimal strategy for adapting the computing precision, which has an overhead tending to 1 when the optimal (unknown) precision tends to infinity.

Most of the algorithmic complexity questions we have been investigating in the past were in algebraic or bit-complexity models. Our typical target problems were system solution, matrix
inversion or canonical forms (see
). Following the Arénaire objective of specification and certification (in an approximate arithmetic
framework) we start studies around the complexity of computing certified error bounds. Based on componentwise perturbation analyses G. Villard proposes in
an approach for computing (certified and effective) error bounds for the
Rfactor of the matrix
QRfactorization. Currently, the corresponding algorithm costs only six times as much as for computing the factorization itself numerically. The approach is applied for certifying the LLL
reducedness of output bases of floating point and heuristic LLL variants.

H.D. Nguyen starts his PhD under the supervision of N. Revol and G. Villard. He studies and experiments the choice of the computing precision and the use of interval arithmetic to get certified enclosures of the error on the solution of linear systems, computed using floating-point arithmetic.

Linear systems with structure such as Toeplitz, Vandermonde or Cauchy-likeness arise in many algebraic problems, like Hermite-Padé approximation or interpolation of bivariate polynomials.
The cost of solving such systems was known to be in
, where
nis the size of the matrix and
is its displacement rank. With A. Bostan (INRIA, project-team Algo) and É. Schost (University of Western Ontario), C.-P. Jeannerod showed in
,
that this cost can be reduced to
, where
is a feasible exponent for matrix multiplication. (In both cases, such costs are obtained by means of Las Vegas probabilistic algorithms.) Since
<2.38, this yields costs of order
and thus asymptotically faster solutions to the algebraic problems mentioned above. On the other hand, this bridges a gap between dense linear algebra (where
=
nand for which system solving has cost
and structured linear algebra (where
=
O(1)and for which system solving has cost
).

Block projections have recently been used, in , to obtain an algorithm to find rational solutions for sparse linear systems (the input matrix can be multiplied by a vector using operations). Unfortunately, the correctness of this algorithm depends on the existence of block projections of matrices and this has been conjectured but not proved. In , G. Villard and his co-authors establish the correctness of the algorithm by proving the existence of efficient block projections. The usefulness of these projections is demonstrated by improving bounds for the cost of several matrix problems: the dense inverse of a sparse matrix is computed using an expected number of operations; a basis for the null space of a sparse matrix — and a certification of its rank — are obtained at the same cost. An application to Kaltofen and Villard's Baby-Steps/Giant-Steps algorithms for the determinant and Smith Form of an integer matrix yields algorithms requiring machine operations. The algorithms are probabilistic of the Las Vegas type.

Lattice reduction algorithms such as LLL and its floating-point variants have a very wide range of applications in computational mathematics and in computer science: polynomial
factorisation, cryptology, integer linear programming,
*etc*. It can occur that a lattice to be reduced has a dimension which is small with respect to the dimension of the space in which it lies. This happens within the LLL algorithm itself.
A. Akhavi and D. Stehlé
described a randomised algorithm specifically designed for such rectangular matrices. It computes bases
satisfying, with very high probability, properties similar to those returned by LLL. The algorithm significantly decreases the complexity dependence in the dimension of the embedding
space. The technique mainly consists in randomly projecting the lattice on a lower dimensional space.

I. Morel starts his PhD under the supervision of D. Stehlé and G. Villard, he is studying LLL reduction algorithms.

D. Stehlé and G. Villard propose a componentwise perturbation analysis of the
QRfactorization for LLL reduced matrices
. This will be applied for designing new floating point variants of LLL reduction oblivious of the underlying
orthogonalization procedure.

The security of lattice-based cryptosystems such as NTRU, GGH and Ajtai-Dwork essentially relies upon the intractability of computing a shortest non-zero lattice vector and a closest lattice vector to a given target vector in high dimensions. The best algorithms for these tasks are due to Kannan, and, though remarkably simple, their complexity estimates had not been improved since over twenty years. Kannan's algorithm for solving the shortest vector problem (SVP) is in particular crucial in Schnorr's celebrated block reduction algorithm, on which rely the best known generic attacks against the lattice-based encryption schemes mentioned above. G. Hanrot and D. Stehlé improved the complexity upper-bounds of Kannan's algorithms. The analysis provides new insight on the practical cost of solving SVP, and helps progressing towards providing meaningful key-sizes.

The Hermite-Korkine-Zolotarev reduction plays a central role in strong lattice reduction algorithms. By building upon a technique introduced by Ajtai, G. Hanrot and
D. Stehlé
showed the existence of Hermite-Korkine-Zolotarev reduced bases that are arguably least reduced. They proved
that for such bases, Kannan's algorithm solving the shortest lattice vector problem requires
bit operations in dimension
d. This matches the best complexity upper bound known for this algorithm
. These bases also provide lower bounds on Schnorr's constants
_{d}and
_{d}that are essentially equal to the best upper bounds. They also showed the existence of particularly bad bases for Schnorr's hierarchy of reductions.

Our goal is to produce a certified active code generator. Starting from specifications given by the user, such a generator produces a target code (that may be modified, at a low level, by this user) along with a proof that the final code corresponds to the given specifications. The specifications we consider are, roughly speaking, mathematical expressions; the generated code evaluates these expressions using floating-point arithmetic and it satisfies prescribed quality criteria: for instance, it returns the correctly rounded result.

More precisely, we aim at doing accurate mathematics using a programming language, typically C. Our tools are the operators and functions specified by the IEEE-754 standard for floating-point arithmetic, the compilation of mathematical expressions and optimizations related to the context (ranges of the variables...). We simultaneously aim at providing certificates and proofs concerning the transformations performed during the code generation, using tools such as Gappa (cf. § ). The optimizations performed for the code generation imply to explore a solution space, more or less automatically. We aim at providing more automation.

The advantages of this approach are mainly the gain in productivity: a minor modification of the input would otherwise be time-consuming and error-prone if handled manually. A second main advantage is the gain in abstraction, through better understanding of models, specifications and constraints.

During this year, we worked on deciding upon the architecture of such a project (cf. §
: EVA-Flo). What we already have at hand is a toolbox of software that intervene for the code generation. We are also defining
a "conductor" algorithm, that will organize when and what each tool will do for the overall code generation. Our work focused mainly on what will be manipulated and transmitted between the
tools: which notions and concepts must be represented. The representation is inspired from XML and more precisely from MathML Content, that we enrich with our own underlying mathematical
structures and notions (for instance, floating-point arithmetic is not available). This representation is handled in the LEMA proposal (
*LEMA: un langage pour les expressions mathématiques annotées*).

Since October 2006, we have been involved in Sceptre, a project of the EMSOC cluster of the Minalogic Competitivity Centre. This project, led by STMicroelectronics, aims at providing new techniques for implementing software on system-on-chips. Within Arénaire, we are focusing on the generation of optimized code for accurate evaluation of mathematical functions; our partner at STMicroelectronics is the HPC Compiler Expertise Center (Grenoble).

F. de Dinechin was included in the XtremeData University program co-sponsored by Altera, AMD, Sun Microsystems and XtremeData, inc. He received a donation of an XD1000 Development System costing $15,000, and the associated programming tools.

The EVA-Flo project (Évaluation et Validation Automatiques de calculs
*Flo*ttants, 2006-2010) is headed by N. Revol (Arénaire). The other teams participating in this project are Dali (LP2A, U. Perpignan), Fluctuat (LIST, CEA Saclay) and
Tropics (INRIA Sophia-Antipolis).

This project focuses on the way a mathematical formula (that includes transcendental functions and, possibly, iterations) is evaluated in floating-point arithmetic. Our approach is threefold: study of algorithms for approximating and evaluating mathematical formulae (with accuracy and performance being at stake), validation of such algorithms (especially their numerical accuracy) when developing them, in order to influence the algorithmic choices, and automation of the process.

The Gecko project (Geometrical Approach to Complexity and Applications, 2005-2008,
http://

The LaRedA project (Lattice Reduction Algorithms, 2008-2010) is funded by the ANR and headed by Brigitte Vallée (CNRS/GREYC) and Valérie Berthé (CNRS/LIRMM). The aim of the project is to finely analyze lattice reduction algorithms such as LLL, by using experiments, probabilistic tools and dynamic analysis. Among the major goals are the average-case analysis of LLL and its output distribution. In Lyon, we concentrate on the experimental side of the project (by using fpLLL and MAGMA) and the applications of lattice reduction algorithms.

The TCHATER project (Terminal Cohérent Hétérodyne Adaptatif TEmps Réel, 2008-2010) is a collaboration between Alcatel-Lucent France, E2V Semiconductors, GET-ENST and the INRIA Arénaire and ASPI project/teams. Its purpose is to demonstrate a coherent terminal operating at 40Gb/s using real-time digital signal processing and efficient polarization division multiplexing. In Lyon, we will study the FPGA implementation of specific algorithms for polarisation demultiplexing and forward error correction with soft decoding.

The GAAP project (
*Étude et outils pour la Génération Automatique d'Approximants Polynomiaux efficaces en machine*, 2004-2008) is a collaboration with the LaMUSE laboratory (U. Saint-Étienne). A.
Tisserand (CNRS, LIRMM, U. Montpellier) is also part of this project. The goal is the development of software tools aimed at obtaining very good polynomial approximants under various
constraints on the size in bits and the values of the coefficients. The target applications are software and hardware implementations, such as embedded systems for instance. The software
output of this project is made of the C libraries Sollya and MEPLib.

This PAI
*(programme d'actions intégrées)*is headed by F. de Dinechin and O. Creţ from Technical University of Cluj-Napoca in Romania. It also involves T. Risset and A. Plesco from the INRIA
Compsys team-project in Lyon. Its purpose is to use FPGAs to accelerate the computation of the magnetic field produced by a set of coils. The Cluj-Napoca team provides the biomedical
expertise, the initial floating-point code, the computing platform and general FPGA expertise. Arénaire contributes the arithmetic aspects, in particular specializing and fusing arithmetic
operators, and error analysis. Compsys brings in expertise in automatic parallelization.

F. de Dinechin, C. Lauter, V. Lefèvre, G. Melquiond, and J.M. Muller have participated in the balloting process for the revision of the IEEE-754 standard for floating-point arithmetic.

V. Lefèvre participates in the Austin Common Standards Revision Group (for the revision of POSIX IEEE Std 1003.1).

Jointly with J. Cannon (University of Sydney) and R. Brent (Australian National University, Canberra), D. Stehlé recently obtained a three-year long funding to investigate
on short lattice points enumeration. This is intricately related to strong lattice reduction and is thus important to assess the security of lattice-based cryptosystems such as NTRU (
http://

is in the program committee of RNC 8 (8th Conference on Real Numbers and Computers).

has been in the Program Committee of FPL2007 (Field Programmable Logic and Applications). He is a member of the Steering Committee of the
*Symposium en Architectures de Machines*.

was co-program chairman (with Peter Kornerup, Odense University) of the 18th IEEE Symposium on Computer Arithmetic (ARITH-18), that was held in Montpellier, France, in June 2007. He is co-associate editor of a special issue of the IEEE Transactions on Computers devoted to Computer Arithmetic (2008). He belongs to the editorial board of JUCS (Journal for Universal Computer Science).

is in the program committee of CCA'08 (Computability and Complexity in Analysis).

has been in the General Committee of the LLL+25 International meeting that was held to celebrate the 25th anniversary of the LLL algorithm.

has been in the Program Committee of ISSAC'07 (International Symposium on Symbolic and Algebraic Computation) and PASCO'07 (Parallel Symbolic Computation). Starting 2008 he will be in the editorial board of Journal of Symbolic Computation (Chief ed. Hoon Hong NCSU).

**General public meetings:**

organized with F. Rastello a one-day seminar on the theme of compiler optimization for embedded systems (ENS Lyon, September 2007). The goal was to present the collaborations that exist between the Arénaire and Compsys INRIA project-teams and STMicroelectronics.

visited high-schools in the region of Lyon (Décines, Boen-sur-Lignon, Villefranche-sur-Saône). She debated with high-school females students at the 40th anniversary of INRIA (Lille, Dec. 2007).

gave a 30h ÉNSL Master course “Algorithms for Computer Arithmetic” (spring 2007).

give a 30h ÉNSL Master course “Algebraic computation” (2007/2008).

gave a 30h ÉNSL Master course “Elementary Functions (spring 2007).

organized a course of the Doctoral School MATHIF, “Applications of Computer Science to Research and Technological Development” and gave one of the lectures.

gave a 30h ÉNSL Master course “Lattice reduction algorithms and applications” (2007).

has given undergraduate and graduate courses at Univ. de St-Étienne until July.

has taught at ENS-Lyon “Computer Science for Non-Computer Scientists”, and “Architecture, Systems and Networks”, for which he received the donation of an Altera DE2 development board. He is coordinator of international exchanges for the computer science department.

gave practical sessions (first steps with MPFR) at the CEA-EDF-INRIA School
*Certified Numerical Computation*at LORIA (October 2007).

gives a 24h Master course “Computer Arithmetic” at Université Claude Bernard - Lyon 1 (2007/2008).

gave a research talk for the students in computer science of the École Normale Supérieure of Lyon (September 2007).

gave a general research talk at the welcoming day of the École Normale Supérieure of Lyon (September 2007).

is
*Chargé de mission*in the ST2I (Engineering, Signal Processing and Computer Science) of CNRS (this involves participating to evaluation committees of laboratories, to hiring
committees, etc.). He participated to the evaluation committee of ANR
*Architectures du futur*, and to the steering committee of ANR
*Calcul intensif et simulation*.

is Vice Chair of LIP laboratory. He is a member of the board of the CNRS-GDR
*Informatique Mathématique*(headed by B. Vallée).

N. Brisebarre, Math. Comm., U. J. Monnet Saint-Étienne. J.-M. Muller and N. Revol, Comp. Sc. Comm., ÉNS Lyon. N. Revol, Comp. Sc. Comm., U. Paris 6. G. Villard, App. Math. Comm., UJF Grenoble.

was in the Habilitation Committee of P. Loidreau (ENSTA Paris, Jan. 07), the PhD Committee of F. Chávez (ÉNS Lyon, Sept. 07), and N. Méloni (U. Montpellier, Nov. 07).

have been examiners for the ÉNS admissions (spring - summer 2007).

has been in the INRIA Rhône-Alpes committee for recruiting junior software-development engineers (spring 2007).

was in Habilitation Committee of F. de Dinechin (Univ. de Lyon, June 2007), and in the PhD committees of J. Detrey (ENS Lyon, Jan. 2007), N. Veyrat-Charvillon (ENS Lyon, June 2007), P.-Y. Rivaille (U. Paris 6, September 2007), N. Fournel (ENS Lyon, Nov. 2007), N. Louvet (U. Perpignan, Nov. 2007) and P. Grosse (ENS Lyon, Dec. 2007).

belongs to the INRIA Rhône-Alpes committee for recruiting post-doctoral researchers and to the 2007 committee for recruiting junior research scientists (CR2).

**National meetings:**

gave talks at the
*Rencontres Arithmétique de l'Informatique Mathématique*, Montpellier, Jan. 2007.

was invited speaker at the Conference in Honor of Donald Knuth (Bordeaux, October 2007).

organized a session on Computer Arithmetic at the
*Rencontres Arithmétique de l'Informatique Mathématique*, (Montpellier, Jan. 2007). She gave an invited talk at the meeting on
*Set methods for control theory*, co-organized by GDR MACS and Robotique (Lyon, Oct. 2007).

gave a talk at the meeting on
*Set methods for control theory*of the GDR MACS (Paris, November 2007).

gave an invited talk at the national meeting of the
*GDR Informatique Mathématique*(Paris, January 2007). He also gave a talk at the French Computer Algebra Meeting (Luminy, January 2007).

gave a talk at the Gecko meeting, Sophia Antipolis, Nov. 2007.

**International seminars and meetings:**

gave a talk at the University of Tsukuba, Japan, April 2007.

presented a poster at LLL+25 in Caen, France, June 2007.

gave a talk at the University of Tsukuba, Japan, April 2007.

gave a talk to the Intel Numerics Group in Nizhny Novgorod, Russia, in August, and another one at Intel Portland, Oregon, in October.

was invited speaker at the 41st Conference on Signals, Systems and Computers (Pacific Grove, California, Nov. 2007).

gave invited seminar talks at the Universities of Frankfurt [Germany, April 2007] and Wollogong [Australia, December 2007]. He was also an invited speaker at the LLL+25 conference [Caen, June 2007].

was invited tutorial speaker at the International Symposium on Symbolic and Algebraic Computation (Waterloo, Canada, Jul. 2007).