Explicit Modelling of Physical Measures: From Event-B to Java

by   J Paul Gibson, et al.

The increasing development of cyber-physical systems (CPSs) requires modellers to represent and reason about physical values. This paper addresses two major, inter-related, aspects that arise when modelling physical measures. Firstly, there is often a heterogeneity of representation; for example: speed can be represented in many different units (mph, kph, mps, etc. . . ). Secondly, there is incoherence in composition; for example: adding a speed to a temperature would provide a meaningless result in the physical world, even though such a purely mathematical operation is meaningful in the abstract. These aspects are problematic when implicit semantics - concerned with measurements - in CPSs are not explicit (enough) in the requirements, design and implementation models. We present an engineering approach for explicitly modelling measurements during all phases of formal system development. We illustrate this by moving from Event-B models to Java implementations, via object oriented design.



page 1

page 2

page 3

page 4


Knowledge-Assisted Reasoning of Model-Augmented System Requirements with Event Calculus and Goal-Directed Answer Set Programming

We consider requirements for cyber-physical systems represented in const...

A Security Cost Modelling Framework for Cyber-Physical Systems

Cyber-Physical Systems (CPS) are formed through interconnected component...

Checking is Believing: Event-Aware Program Anomaly Detection in Cyber-Physical Systems

Securing cyber-physical systems (CPS) against malicious attacks is of pa...

Multiscale modelling and simulation of physical systems as semiosis

It is explored how physicalist mereotopology and Peircean semiotics can ...

Understanding and Formalizing Accountability for Cyber-Physical Systems

Accountability is the property of a system that enables the uncovering o...

DEMoS Manifesto

This is a manifesto for DEMoS, which is a Distributed Embedded Modular S...

Should Semantic Vector Composition be Explicit? Can it be Linear

Vector representations have become a central element in semantic languag...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

1.1 Problems when using implicit measurements and dimensions

Historically, humans have made many critical mistakes when using units of measurement. For example, Chrostopher Columbus miscalculated the circumference of the earth when he used Roman miles instead of nautical miles [25]. Since software has been written, there is added risk of bugs arising out of the lack of explicit measurement types (and dimensions) in programs. Perhaps the best known bug of this type is the Mars climate orbiter error [26], where separate software modules were using different units of measurement (imperial and metric); yet when they communicated data they were not aware of the different representations and wrongly assumed that the data being shared was represented in the same unit/scale. This issue would have been avoided if the units of measurement had been explicitly (and formally) specified in the module interfaces.

1.2 Proposed requirements for explicit modelling of measures

Formal methods are often used in the development of critical software systems [7]; but they often permit the construction of models which are mathematically meaningful, in the abstract, but which have no coherent interpretation in the real (concrete) world. We propose a modelling technique which helps software engineers to avoid building models that are incoherent, by explicitly specifying measurement dimensions and scales (units).

We are motivated by the international standard for physical measurements which identifies seven base units/dimensions and numerous derived units and constants [24, 28]. We require that the measurement model must: (1) Specify seven base units (explicit) in a standard library: mass, length, time, temperature, current, light and matter. (2) Support the derivation of (standard) units that can be added explicitly to the library (as required) or used implicitly. (3) Support definition of non-standard units that can be defined in terms of standard units. (4) Facilitate specification of scalar universal constants (like PI). (5) Facilitate specification of physical constants of certain dimension (like the speed of light in a vacuum). (6) Be amenable to static/automated analysis for detection of incoherent mixing of units (like adding a speed and a temperature). (7) Support implicit scaling - being able to add/subtract/compare measurements in the same dimension but different scales, without the need to explicitly scale them.

We choose to use Event-B [2] contexts as our modelling language because we wish to re-use our measurement models to play the role of a domain ontology [15] in the development of safety-critical CPSs using refinement [4]. We also wish to have a powerful reasoning tool (in this case Rodin [3]) for automating validation and verification. Our modelling approach could be easily followed using other formal methods (that provide similar language and tool support).

2 Related work

The thesis by Kennedy [20] is one of the earliest works to propose a solution to the problem of representing dimensions in programming languages. The thesis establishes and proves a formal relationship between conventional type systems and the dimension type systems (using a functonal programming language as its foundations). However, the work does not not cover the situation of multiple systems of units within the same dimension ( formal engineering requirements 3 and 7, in section 1.2).

In ‘Object-Oriented Units of Measurement’ [5], the authors state: “Physical units and dimensions are a commonly used computational construct in science and engineering, but there is relatively little support for them in programming languages.” They demonstrate how an OO language that offers rich semantics for polymorphism and dynamic binding can use explicit typing to model a hierachy of measurements for physical values. Their approach also does not meet requirements 3 and 7.

In ‘Arithmetic with Measurements on Dynamically-typed Object-oriented Languages’ [29], the authors implement - in Smalltalk - a measurement system that is general enough to include the SI units for physical measurements, as well as non-physical measures such as units of currency (see section 5). The choice of Smalltalk is interesting because the language’s dynamic type system gives the programmer more support for defining new types, but restricts the strength of static analysis that can be done. Their approach does not support our requirements 2,4, and 5.

In ‘Osprey: A Practical Type System for Validating Dimensional Unit Correctness of C Programs[18], the authors present a sound type system to automatically check for all potential errors involving units of measurements. The system is based on annotating the C code with unit/dimension typing constraints that are then checked using a constraint solver. However, their analysis is limited to comparing units and does not support comparing dimensions. Their approach only partially meets all our requirements, and introduces complexity of annotations into the programming task.

In “A model-driven approach to automatic conversion of physical units” [9], the authors propose checking physical units at the level of the modelling language, removing the need for such a support in the underlying implementation language. They choose to express all physical values in the standard canonical form, as products of powers of the SI base units, and present an elaborate algorithm for translating to and from such a form for any arbitrary unit. However, since in CellML (the modelling language upon which their approach is built) all constants and variables are explicitly annotated with their units, they have not needed to make any type inferences. Thus, they have not considered meeting our 2nd requirement.

3 Formal Specification in Event-B

In this section we present three different Event-B contexts which are used to meet our measurement modelling requirements, as specified in subsection1.2. We chose to structure the model by separating the representation of real-world values (in context C_Values) from the real-world dimensions (in context C_Dimensions). The context C_Measurements then composes them to provide a standard model that can then be extended with derived measurements and values.

3.1 Values as floats

We define a context C_Values to provide a concrete mechanism for constructing and representing values as floating point decimal numbers [14]. A partial specification of the model is given in Figure 1.The constant PI is used as a concrete example of how we represent values using floating point numbers. The first integer, commonly know as the significand, is to be interpreted as a float with the floating point occurring after the first decimal digit. The second integer is to be interpreted as the power of 10, commonly known as the base, which is to be multiplied to the significand in order to give the real value of the floating point number (). The arithmetic operators are defined algebraically (including axioms - not shown - for operator properties, such as commutativity, that are needed for later proofs). We note that this context makes no reference to physical units or dimensions.

Figure 1: The floating number (partial) abstract model

3.2 Dimensions

The partial specification of the context C_Dimensions is given in Figure 2.The seven SI dimension units [24, 28] - Mass, Length, Time, Temperature, Light, Current and Matter are explicitly modelled, and we can derive new dimensions through multiplication, division and reciprocation. So, for example a derived dimension for Acceleration would be defined as: Length divided by Time squared. So the associated powers would be 1 for Length and -2 for Time, with all other base dimensions having 0 powers giving: . We note that this context makes no references to physical values.

Figure 2: The dimension model - CONTEXT C_Dimensions AXIOMS

3.3 Measurements

We define a context C_Measurements which EXTENDS C_Values and C_Dimensions and combines them to define the standard SI units for the 7 base dimensions: Kilogram, Metre, Second, Kelvin, Ampere, Candela, and Mol (see Figure 3). The key modelling decision was to model a measurement as a triple: the dimension, the value, and the bijective normalization function for mapping the value to the standard canonical unit. Thus, the actual unit of measurement is implicit in the function definition. For example, a Mass in Kilograms is constructed from a MassDimension, its Value and the id function (as it is already in the standard unit canonical form). Thus, Kilogram(v) represents a mass of kg.

Figure 3: The 7 SI base unit measurements in CONTEXT C_Measurements

We note that we make no assumption that units must be defined by a simple linear function through the origin (as is the case for most physical scales). The measurement model also permits more general affine functions (as for temperature conversion, for example). The advantage of this explicit approach is that we can now formally specify the addition (and subtraction) of Measurements as partial functions (which are defined only when the Measurements have the same Dimension). For simplicity our paper presents - in Figure 4 - only the function for adding measurements. Subtraction is the same problem, whilst multiplication and division require no consistency checking. Similarly, we model partial functions for comparing measurements, where the functions are defined (using the comparison between the values converted to standard units) only when the measurements are in the same dimensions.

Figure 4: The addition of Measurements

The key aspect of the mathematical operators is that the resulting Measurement is given in the units of the first Measurement parameter. In order to do this, the second parameter Value has to be converted to the same units. This is done by converting to the standard base unit of the Dimension common to the two parameters, and then converting to the unit of the first parameter. For example the addition of grammes and pounds, would result in grammes

4 Illustrating measurement modelling problems

In this section we review a small number of case studies which have included modelling of real-world measures. We compare, with our explicit approach, the way in which the studies (to various degrees) use implicit modelling of units and dimensions.

4.1 Changing the unit of measurement when formalizing a requirements specification

In ‘Modeling a Landing Gear System in Event-B’ [21], a refinement is used to introduce timing aspects. The authors note that with respect to time values: ‘Since, the type Real is not provided in EventB, we multiply all the data per 10’. This impliclty suggests that the basic unit of time in their models will be one tenth of a second (also known as a decisecond). This modelling decision is coherent with the original case study specification [6]

, where timing constraint values are mostly given in integer seconds, but timing measurement values (based on real world estimations) are given as floating point decimals (to 1 decimal place). Both types of timing values are modelled as

NATs in the Event-B models. All the subsequent documentation that accompanies their model refers to units of time (u.t), which are deciseconds, when timing values (variables and constants) are modelled using the in-built NAT set.

Even in this simple case, there is a problem of model validation and understandability. The modellers must continually remember to multiply by ten all timing values given in the requirements specification. Readers of the document who are trying to validate the model against their requirements must continually remember to divide by ten all timing values given in the Event-B model. This type of mental gymnastics is illustrated by the requirement:

If one of the three gears is not seen locked in the down position more than 10 seconds after stimulating the outgoing electro-valve, then the boolean output normal mode is set to false.

and the corresponding Event-B condition:

A secondary concern with this modelling approach is maintainability. If we imagine that a new requirement is added that uses a time measured to 2 decimal places, it will now be necessary to globally change all time values to units of a hundredth of a second (centiseconds). This may not be as straightforward as just multiplying all integer NAT values by 10, as NATs may also have been used to model other variable types in the system (and not just times). So we must be able to locate all time variable and constant definitions. This may be done by introducing naming conventions (such as starting every time with the letter ‘T’); but such approaches are notoriously brittle to changes to systems and models as they evolve. Further, such naming conventions are not necessarily standard, and so composition and re-use of models which use them becomes non-trivial.

Using our approach, we re-use the deciseconds measurement model in the Event-B context shown in Figure 5.

Figure 5: The dimension model - CONTEXT C_Deciseconds

The expression, from the original model:
can then be replaced by the expression:

The original model assumes that the variables and are both times and that they have the same units. Further, it assumes that the value is also a time given in the same units as the two variables. With our explicit approach, the fact that the two variables and one constant are all times will be checked by the Rodin tool as it verifies that the expression is well-defined. Further, there is no need to statically check that the units are homogeneous; if they are different then the conversions will be done implicitly. Finally, it is easier to validate our model against the original natural language requirements as the 10 units of time specified in seconds are modelled explicitly as Seconds. (The clumsy syntax of our model will be improved in future work, where we model measurements and values using a theory plug-in for the Rodin tool.)

4.2 Overloading a type/set/class with values from a different scale of the same dimension

In ‘Integrating Domain-Based Features into Event-B: A Nose Gear Velocity Case Study’ [22], we see a model which represents velocities using 3 different scales: Inch per millisecond (IPmS), Miles per hour (MPH), and Kilometres per hour (KPH). There is an explicit typing of different base measurements: INCH, MILE, MILLISECOND and HOUR. However, kilometres are not modelled explicitly as a type; but they are modelled implicitly in axioms axm1 and axm2:

We also see an explcit type for each of the velocities MPH and KPH, but no explicit type for IPmS, which appears implicitly in axiom axm6.

Axiom axm6 states only that the velocity value is calculated from the inches value and the milliseconds value, but there is no explicit statement that the length dimension is divided by the time dimension.

The explicit function (bijection) that maps MPH to KPH (mphTokph) implies that there is a dimensional equivalence (that of velocity), and we can therefore coherently compare MPH and KPH values. There is no explicit statement that MILEs and INCHes represent the same dimension (length); and that MILLISECONDs and HOURs represent the same dimension (time). The explicit types - as defined in their model - will help us to formally express and validate the natural language requirements; but the lack of explicit dimensions can make the process complex. For example, the requirement:

Estimated ground velocity of the aircraft is available only if it is within 3 KPH of the true velocity at some moment within the past 3s”

contains the constant value 3 for both a velocity and for a time. The original specification of this behaviour111We have highlighted the constant values that are linked to the natural language text. is given in Figure 4.2.

The “3 KPH” from the requirement text is found in 6 locations - highlighted in yellow - in the formal model. The “3 s” from the requirement text is found in 3 locations - highlighted in blue - in the formal model. Having an implicit rather than explicit typing of the values “3” in the model compromises understandibility and introduces complexity. As such, the model is more difficult to maintain and extend.

Following this modelling method, the coherence of arithmetic operations over values cannot be checked automatically. For example, we have edited a sub-expression of inv2 in order to mix velocity and time (written in red). The mismatch in types, in this case, will not be detected automatically because the Rodin toolkit considers the expression to be well-defined.

In their approach, all arithmetic is done over the NAT values in the domain of the typing functions. This facilitates the verification (proving) process, but hinders the validation process, and permits the modelling of mixed-type expressions that are “meaningless” in the real world.

This model also suffers from maintainability and scalability issues. Rather than explicitly modelling the scaling of values between only non-canonical and canonical forms, they provide an explicit mapping between 2 non-canonical forms, namely MPH and KPH. Such explicit mappings are good for models with few units of measure, but they create scaleability problems when multiple units of measure are defined. For example, with 3 unit lengths - miles, kilometres, inches - and 2 unit times - hours and seconds - we have 6 possible unit velocities. An explicit transformation function between each pair of unit velocities would require 30 different function definitions in total. It would be much better to require only a single explicit function for mapping a value in each new single dimension unit to the canonical value in the same unit dimension; and for the transformations of all other units to be done in an automated, implicit, fashion. In this way, the model is much more scaleable to the introduction of new units.

Finally, the model also introduces ambiguous, non-standard notation. The model’s invariants contain the expression . In standard canonical form this would represent a velocity (metres per second); however, due to an unfortunate choice of syntax, in their model it represents a mapping from a millisecond time to a NAT value. Such syntax clashes are inevitable when composing models, except if a standard formal ontology (as we propose) is used by all developers.

With our approach we would explicitly model the new Velocity dimension and the 3 different units using the AXIOMs as shown in Figure 6 :

Figure 6: The dimension model - CONTEXT C_Velocity AXIOMS

Using the Velocity context, we can now re-write inv6 from the original model as:

Coherency of the comparison functions (, and ) and the arithmetic functions ( and ) is guaranteed by the welldefinedness of the expression, as checked by the Rodin tool.

4.3 Overloading a type/set/class with values from different dimensions

In ‘Formalizing hybrid systems with Event-B and the Rodin Platform’ [27], we see the modellers overloading the positive reals to represent both temperature and time in a nuclear plant reactor cooling system:

We define some state variables: is the temperature of the reactor, t1 and t2 denote the time elapsed since rod1 or rod2 have been released.

The modelling of the state of the real world measurements (temperature and time) and the discrete state of the rod is as follows:

These variables are used in specifying the control events:

With regard to the risk of adding values with different dimensions, we see expressions, such as and , where there is a risk that the operands are not coherent measures in the real world. The same risk is taken when comparing values (eg, ) and assigning values (eg, ). Reading the model, it is clear that the authors have taken great care in naming their variables in order to help avoid any incoherent combination of the real values. However, the additional burden on the modellers to check for and guarantee coherence becomes ever more significant as the model introduces implicit composition of dimensions. A good example is the pump controller model, where a variable has implicit dimension of length divided by time (a velocity):

In our approach, we already have explicit dimensions and measures for times and temperatures. The only additional extra dimension required by their model is that of velocity; and so we can re-use the model given in the previous section 4.2.

5 Application to other domains - currency example

The previous sections have demonstrated the utility of our approach with respect to modelling of the natural physical world. However, humans have also introduced abstract quantities into many domains, and these often suffer from the same modelling problems as for the concrete physical world. A typical example is one of currencies. In a shopping/services on-line domain, it is often possible to pay using different currencies (dollars, euros, etc…) in different subsystems. The role of the system would be to provide an ontology matching when combining such systems and domains [11]. We need to be able to check that we coherently perform numerical operations using currency values in the same way as for physical measurements. This would appear to be a trivial extension to our approach. However, it is made more complex by the conversion functions between currencies being variable (rather than constant, as for physical measurement conversions). In order to model this in Event-B, we are obliged to model the state of the system (in a machine).

In our example, customers (in a set C) and providers (in set P) are interacting, when customers are requesting services (in a set S). A service is provided by one and only one provider. A customer should first request a service; the provider sends him or her an invoice and finally the service is paid by the customer. When the service is paid, it is delivered.

We have three levels of machines222The full models for this case study - and for the previous measurement contexts - will be provided by the authors on request. - M0, M00 and M000 - corresponding to a progressive modelling of the problem as a sequence of refinements.

Machine M0: The customer is requesting a service and the service is delivered by the provider. No expression of cost is given and no expression of failure in transaction is stated in our model. Two events model the possible actions operating on variables deliver and order; Ordering_a_service and Serving_a_requested_service. The invariant is simply stating that a service is corresponding to a request ().

Machine M00 introduces the billing system in the process. A service should be paid before being delivered. New variables related to billing are introduced, as well as the actions of sending an invoice and paying an invoice. The invariant is simply stating the sequentiality of different actions and the strengthening of previous actions:


The machine has two new events which are modelling the two new variables: Billing_a_requested_service and Paying_a_requested_service. The event Serving_a_requested_service has a new guard which is strengthening the condition of service.

Machine M000 refines machine M00 by superposing new variables in the current events. We introduce new variables such as the variable which models the set of already existing bills. The main critical property is the invariant which states that the value paid by the customer to the provider corresponds to the value in the currency of the customer: . is the translation of the value of the bill in the currency of the provider () and in the variables, we record the current translation used while paying.

In this simple case study we see that the static approach for Measurements, where the conversion functions are constant, has the potential to be extended to a more dynamic approach (as for currency payments in the example) where the conversion functions are variable. It is currently work-in-progress to extend our methodology to handle the dynamic case.

6 OO Design and Implementation

6.1 Inheritance Hierarchy

We chose to implement our Measurements model in Java because of the rich typing and polymorphic semantics, together with type safety for a reasonable subset of the language [10]. The diagram, in Figure 7, is a partial representation of the inheritance hierarchy in our object oriented implementation (using Java). There are seven single dimension measurements: Mass, Length, Time, Temperatures, Luminosity, Current and Substance, each of which has a standard unit class: Kilogram, Metre, Second, Kelvin, Candela, Ampere and Mole. These are in the base library of Measurements that provide the foundations for constructing three kinds of new classes:

  • Non standard single dimensional measurements, like Centimetre, Kilometre, Mile, Hour and Decisecond (in the diagram).

  • Standard multiple dimensional measurements, like Velocity in MetresPerSecond (in the diagram).

  • Non standard multiple dimensional measurements, like Velocity in MilesPerHour (in the diagram).

Developers are free to add new Measurements (of all 3 types) by extending the class hierarchy. They must execute the Measurement unit tests (see section 6.3) on instances of their new classes in order to (partially) verify that the new classes respect the generic requirements as specified in the Event-B context models (such as associativity and commutativity of the addition operation/method).

Figure 7: (Incomplete) Measurement Class Inheritance Hierarchy

6.2 The Java Code

The abstract behavior is first modelled in the class Measurement.java, below. Concrete measurement classes (in the standard seven dimensions and all possible combinations) are required to override the methods of this general class:

  • the standard four numerical operations, with exceptions thrown for addition and subtraction of measurements in different dimensions;

  • a method to permit the simple scaling of a measurement;

  • two methods for converting to/from the standard unit of measurement for the given dimension;

  • two methods (static and non-static) to check if measures have the same dimension

  • two constructors (including a random constructor)

  • standard getter methods, toString, equals and hashcode

The implementation of each base dimension measurement is now straightforward. For example, the Java code for the Second class is given, below.

The implementation of more complex single and multiple dimensional measurements is slightly more complicated as it requires care when writing the methods for converting to/from the standard units. We note that this is a simple scaling function (except in the case of temperatures). The required properties (as specified in the Event-B theorems) are then used to drive the coding and execution of unit tests on the new measurement classes.

6.3 Java - unit tests from Event-B theorems

Following the approach in  [12], we use the formal models to drive the generation of test cases, rather than refining them towards an implementation. Thus, we identify theorems in the contexts (that have been proven by the Rodin tool) and demonstrate that the properties that they specify are also valid for the Java implementation (through testing). For example, the commutativity and transitivity of the addition of measurements (of the same dimension) can be verified automatically by the RODIN tool, but needs to be tested in the Java implementation.

The technique that we employ is very simple, and based on random test generation combined with the JUnit tool. The abstract tests are coded in the JUnitMeasurement class, which must be extended by a unit test class for each new Measurement class. For example, the Second class has a test class JUnit_Second which extends JUnit_Measurement. The tests use random constructors to check that the required properties are respected for a large number of randomly generated test cases333We can run millions of tests in a matter of seconds. This does not guarantee that the properties are respected for all

the new measurement values, but they reassure the developers that there is a very high probability that their code is correct (with respect to the properties being tested).

7 Ongoing and Future Work

We are currently pursuing three areas of research which extend this work:

I. Accuracy of measurement - In this paper we have not addressed the need to model the fact that values and measurements in our systems are actually approximations to reals. In certain types of (relatively simple) systems this can lead to unpredictability and chaotic behaviour [13]. Consequently, in order to reason about the behaviour of such systems, it is necessary for values to modelled within a certain error (within a bounded interval). Fortunately, there is already much existing work on interval values and interval arithmetic  [23, 19, 19, 16, 8]. We have already extended our Java measurement library to include interval value arithmetic. We hope to report on this in a future paper.

II. Theory of measurements - Rodin provides a Theory plug-in that facilitates definitions of mathematical and prover extensions [17]. It should be relatively straightforward to introduce a theory of Measurements using the current algebraic specifications in our Values, Dimensions and Measurements contexts. However, it seems wise to wait until our work on modelling values as intervals is complete and validated before we attempt to build a theory extension for interval measurements. It should be noted that such a theory extension would help to tidy up our current clumsy notation, and would facilitate more automated proof of simple mathematical properties of measurements.

III. Re-engineering case studies for validation and extension of our approach - It is important to validate our approach using real world case studies. We are currently re-engineering a number of case studies that have used measurements implicitly to adopt our explicit measurement modelling approach. We believe that these re-engineered models - thanks to the explicit modelling of measurements - will be easier to validate, more amenable to automated coherency checking, and easier to maintain. One of the case studies that we are currently re-engineering is the currency example - mentioned previously in this paper - where there is a need to model and reason about dynamic rather than static unit conversion.

8 Conclusions

We have motivated the need for explicit modelling of dimensions of physical measurements during formal development of systems. We have demonstrated one approach for such modelling using Event-B contexts, that meets all our formal engineering requirements. We have compared this approach with other case studies in which the modelling of dimensions is implicit. Java implementations of the Event-B specifications demonstrate the feasibility of the approach. Java unit tests are then derived from the Event-B specifications.


The authors acknowledge the support provided by the French ANR project IMPEX (13-INSE-0001)


  • [1]
  • [2] Jean-Raymond Abrial (2010): Modeling in Event-B - System and Software Engineering. Cambridge University Press. Available at http://www.cambridge.org/uk/catalogue/catalogue.asp?isbn=9780521895569, doi:http://dx.doi.org/10.1017/CBO9781139195881
  • [3] Jean-Raymond Abrial, Michael Butler, Stefan Hallerstede, Thai Son Hoang, Farhad Mehta & Laurent Voisin (2010): Rodin: an open toolset for modelling and reasoning in Event-B. Int. J. Softw. Tools Technol. Transf. 12, pp. 447–466, doi:http://dx.doi.org/10.1007/s10009-010-0145-y.
  • [4] Jean-Raymond Abrial & Stefan Hallerstede (2007): Refinement, Decomposition, and Instantiation of Discrete Models: Application to Event-B. Fundam. Inf. 77(1-2), pp. 1–28.
  • [5] Eric Allen, David Chase, Victor Luchangco, Jan-Willem Maessen & Guy L Steele Jr (2004): Object-oriented units of measurement. ACM SIGPLAN Notices 39(10), pp. 384–403, doi:http://dx.doi.org/10.1145/1028976.1029008.
  • [6] Frédéric Boniol & Virginie Wiels (2014): The Landing Gear System Case Study. In: ABZ 2014: The Landing Gear Case Study, Springer, pp. 1–18, doi:http://dx.doi.org/10.1007/978-3-319-07512-9˙1.
  • [7] Jonathan Bowen & Victoria Stavridou (1993): Safety-critical systems, formal methods and standards. Software Engineering Journal 8(4), pp. 189–209, doi:http://dx.doi.org/10.1049/sej.1993.0025.
  • [8] Hervé Brönnimann, Guillaume Melquiond & Sylvain Pion (2003): The Boost interval arithmetic library. In: Real Numbers and Computers, pp. 65–80.
  • [9] Jonathan Cooper & Steve McKeever (2008): A model-driven approach to automatic conversion of physical units. Software: Practice and Experience 38(4), pp. 337–359, doi:http://dx.doi.org/10.1002/spe.828.
  • [10] Sophia Drossopoulou, Susan Eisenbach & Sarfraz Khurshid (1999): Is the Java type system sound? TAPOS 5(1), pp. 3–24.
  • [11] Jérôme Euzenat, Pavel Shvaiko et al. (2007): Ontology matching. 18, Springer, doi:http://dx.doi.org/10.1007/978-3-642-38721-0.
  • [12] J. Paul Gibson, Eric Lallet & Jean-Luc Raffy (2011): Formal Object Oriented Development of a Voting System Test Oracle. Innovations in Systems and Software Engineering (Special issue UML-FM11) 7(4), pp. 237–245, doi:http://dx.doi.org/10.1007/s11334-011-0167-y.
  • [13] James Gleick (2011): Chaos: Making a new science (Enhanced edition). Open Road Media.
  • [14] David Goldberg (1991):

    What every computer scientist should know about floating-point arithmetic

    ACM Computing Surveys (CSUR) 23(1), pp. 5–48, doi:http://dx.doi.org/10.1145/103162.103163.
  • [15] Thomas R Gruber & Gregory R Olsen (1994): An Ontology for Engineering Mathematics. KR 94, pp. 258–269.
  • [16] Timothy Hickey, Qun Ju & Maarten H Van Emden (2001): Interval arithmetic: From principles to implementation. Journal of the ACM (JACM) 48(5), pp. 1038–1068, doi:http://dx.doi.org/10.1145/502102.502106.
  • [17] Thai Son Hoang, Laurent Voisin, A. Salehi, Michael J. Butler, Toby Wilkinson & N. Beauger (2017): Theory Plug-in for Rodin 3.x. CoRR abs/1701.08625. Available at http://arxiv.org/abs/1701.08625.
  • [18] Lingxiao Jiang & Zhendong Su (2006): Osprey: a practical type system for validating dimensional unit correctness of C programs. In: Proceedings of the 28th international conference on Software engineering, ACM, pp. 262–271, doi:http://dx.doi.org/10.1145/1134285.1134323.
  • [19] R Baker Kearfott (1996): Interval computations: Introduction, uses, and resources. Euromath Bulletin 2(1), pp. 95–112.
  • [20] Andrew Kennedy (1996): Programming languages and dimensions. Ph.D. thesis, University of Cambridge, Computer Laboratory.
  • [21] Amel Mammar & Régine Laleau (2014): Modeling a landing gear system in Event-B. In: International Conference on Abstract State Machines, Alloy, B, TLA, VDM, and Z, Springer, pp. 80–94, doi:http://dx.doi.org/10.1007/978-3-319-07512-9˙6.
  • [22] Dominique Méry, Rushikesh Sawant & Anton Tarasyuk (2015): Integrating Domain-Based Features into Event-B: A Nose Gear Velocity Case Study. In Ladjel Bellatreche & Yannis Manolopoulos, editors: Model and Data Engineering - 5th International Conference, MEDI 2015, Rhodes, Greece, September 26-28, 2015, Proceedings, Lecture Notes in Computer Science 9344, Springer, pp. 89–102, doi:http://dx.doi.org/10.1007/978-3-319-23781-7˙8.
  • [23] Ramon E. Moore (1962): Interval Arithmetic and Automatic Error Analysis in Digital Computing. Ph.D. thesis, Department of Computer Science, Stanford University.
  • [24] TJ Quinn (1995): Base units of the Système International d’Unités, their accuracy, dissemination and international traceability. Metrologia 31(6), p. 515, doi:http://dx.doi.org/10.1088/0026-1394/31/6/011.
  • [25] V Frederick Rickey (1992): How Columbus encountered America. Mathematics Magazine 65(4), pp. 219–225, doi:http://dx.doi.org/10.2307/2691445.
  • [26] Brian J Sauser, Richard R Reilly & Aaron J Shenhar (2009): Why projects fail? How contingency theory can provide new insights - A comparative analysis of NASA’s Mars Climate Orbiter loss. International Journal of Project Management 27(7), pp. 665–679, doi:http://dx.doi.org/10.1016/j.ijproman.2009.01.004.
  • [27] Wen Su, Jean-Raymond Abrial & Huibiao Zhu (2014): Formalizing hybrid systems with Event-B and the Rodin platform. Science of Computer Programming 94, pp. 164–202, doi:http://dx.doi.org/10.1016/j.scico.2014.04.015.
  • [28] Ambler Thompson & Barry N Taylor (2008): Guide for the Use of the International System of Units (SI). Special Publication (NIST SP)-811, doi:http://dx.doi.org/10.6028/NIST.SP.811e2008.
  • [29] Hernán Wilkinson, Máximo Prieto & Luciano Romeo (2005): Arithmetic with Measurements on Dynamically-typed Object-oriented Languages. In: Companion to the 20th Annual ACM SIGPLAN Conference on Object-oriented Programming, Systems, Languages, and Applications, OOPSLA ’05, ACM, New York, NY, USA, pp. 292–300, doi:http://dx.doi.org/10.1145/1094855.1094964.