Simply stated, floatingpoint arithmetic is arithmetic performed on floatingpoint representations by any number of automated devices.
Traditionally, this definition is phrased so as to apply only to arithmetic performed on floatingpoint representations of real numbers (i.e., to finite elements of the collection of floatingpoint numbers) though several additional types of floatingpoint data including signed infinities and NaNs are also commonly allowed as inputs for such functions.
Despite the succinctness of the definition, it is worth noting that the most widelyadopted standards in computing consider nearly the entirety of floatingpoint theory under the heading "floatingpoint arithmetic." One reason for this breadth stems from the fact that any floatingpoint representation can account for but a finite subset of the continuum of real numbers; this finiteness presents a variety of unforeseen obstacles, chief among which is the fact that certain properties of real arithmetic (e.g., associativity of addition) sometimes fail to hold for floatingpoint numbers (IEEE Computer Society 2008). As a result, any comprehensive treatment of floatingpoint arithmetic and/or algebra must address numerous caveats including representations of floatingpoint numbers, rounding, etc. before ever discussing the actual operations themselves.
As of 2014, the most commonly implemented standard for floating point arithmetic is the IEEE Standard 7542008 for FloatingPoint Arithmetic (written shorthand as IEEE 7542008 and as IEEE 754 henceforth). This framework is a massive overhaul of its predecessor  IEEE 7541985  and includes a builtin collection of guidelines specifying nearly every conceivable aspect of floatingpoint theory. In particular, IEEE 754 addresses the following aspects of floatingpoint theory in considerable detail:
1. Floatingpoint representations and formats.
2. Attributes of floatingpoint representations, including rounding of floatingpoint numbers.
3. Arithmetic and algebraic operations on floatingpoint representations.
4. Infinity, nonnumbers (NaNs), signs, and exceptions.
A number of the above topics are discussed across multiple sections of the standard's documentation (IEEE Computer Society 2008).
The "required" arithmetical operations defined by IEEE 754 on floatingpoint representations are addition, subtraction, multiplication, division, square root, and fused multiplyadd (a ternary operation defined by ); these are required in the sense that adherence to the framework requires these operations to be supported with correct rounding throughout. A number of other "recommended" operations are also provided within the framework, some of which are arithmetic in nature; these are recommended in the sense that support for them is not strictly required by the framework. Finally, note that the framework includes both a collection of utility functions which may also be considered arithmetic, namely copy, negate, and abs, as well as a number of closelyrelated functions defined for vectorvalued input (IEEE Computer Society 2008, pp. 4647)
operation  function  domain  possible exceptions 
exp  Overflow; Underflow  
expm1  Overflow; Underflow  
exp2  Overflow; Underflow  
exp2m1  Overflow; Underflow  
exp10  Overflow; Underflow  
exp10m1  Overflow; Underflow  
log  Divide By Zero (if ); Invalid Operation (if )  
log2  Divide By Zero (if ); Invalid Operation (if )  
log10  Divide By Zero (if ); Invalid Operation (if )  
logp1  Divide By Zero (if ); Invalid Operation (if ); Underflow  
log2p1  Divide By Zero (if ); Invalid Operation (if ); Underflow  
log10p1  Divide By Zero (if ); Invalid Operation (if ); Underflow  
Overflow; Underflow  
rSqrt  Invalid Operation (if ); Divide By Zero (if )  
Invalid Operation (if )  
Invalid Operation (if or and even); Overflow/Underflow (if )  
Several cases  
Several cases  
Several cases 
The above table summarizes the recommended arithmetic operations within IEEE 754. Note that the particulars of the exceptions labeled "Several cases" are addressed in detail in the IEEE 754 documentation (IEEE Computer Society 2008, pp 4345).
As noted above, even some of the basic required arithmetic operators behave unpredictably in light of floatingpoint representations and rounding. This stems from the fact that the "normal" arithmetic operations are assumed within IEEE 754 to have infinite precision while the values of floatingpoint addition, subtraction, multiplication, and division, written symbolically as , , , and , respectively, are computed by performing the "normal" operations of , , , and , respectively, on floatingpoint numbers written in terms of a common exponent and rounding the result to a fixed number of significant digits (by way of the socalled preferred exponent) afterward. As a result, loss of precision, overflow, and underflow can all occur during the arithmetic and/or rounding steps of the computation. For example, the result of adding and is exactly
(1)

On the other hand, in a framework with radix and 7digit precision, the value returned by floatingpoint addition would be
(2)

Similarly, given and , one has that
(3)

using the 7digit precision assumed above. However, one has that
(4)

thus yielding a complete lack of precision. Note that in extreme cases like this, systems implementing IEEE 754 won't actually yield as a result: In particular, such a scenario will trigger an underflow warning. Details and caveats of the other arithmetic functions mentioned throughout can be found in the documentation (IEEE Computer Society 2008, §5 and §9).
Some distinction is made between floatingpoint operations which are arithmetic in nature and those which are algebraic/trigonometric: Operations of the latter variety typically fall under the heading of floatingpoint algebra.