Normalising binary floating-point numbers is a process that ensures the representation of these numbers is consistent and efficient. The significance of normalisation lies in maximising precision and simplifying arithmetic operations. In a normalised number, the mantissa (or significand) is adjusted so that its most significant digit (the first digit to the left of the binary point) is non-zero (usually 1 in binary). This is done by adjusting the exponent accordingly. For instance, the binary number 0.101101 x 2³ would be normalised to 1.01101 x 2¹. Normalisation ensures that the mantissa is within a certain range, allowing for the most efficient use of its digits. In floating-point arithmetic, normalised numbers are easier to compare and operate on since they follow a standard format. This consistency is crucial in computational applications where accuracy and efficiency are paramount. Normalisation also helps in detecting and handling special conditions like underflow and overflow, which are critical for maintaining numerical stability in computations.

Not all denary numbers can be accurately represented in binary format. This is mainly due to the fact that the binary system, being base-2, cannot precisely represent some fractions that are easily expressed in the base-10 (denary) system. For example, the denary fraction 0.1 cannot be represented exactly in binary; it becomes a recurring binary fraction, leading to a representation that is only an approximation of the actual value. This limitation has significant implications in computing, particularly in areas requiring high precision, such as scientific calculations, financial computations, and numerical analysis. Rounding errors and precision loss can accumulate in successive calculations, potentially leading to significant discrepancies. To mitigate these issues, computer scientists use various techniques such as extended precision formats, error bounds analysis, and alternative number systems like decimal floating-point representation in specific applications. Understanding these limitations and their effects is crucial for designing algorithms and systems that are robust and accurate.

Understanding binary floating-point representation is crucial in computer science for several reasons. Firstly, it's fundamental for computer hardware, as computers inherently operate using binary logic. Knowing how numbers are represented in binary allows computer scientists and engineers to design and optimize hardware and software systems efficiently. Secondly, in programming, many algorithms and data processing tasks involve numerical computations where floating-point arithmetic is used. A clear understanding of how numbers are represented and manipulated in binary form helps in debugging, optimizing performance, and ensuring accuracy in these computations. Moreover, in fields like computer graphics, scientific computing, and machine learning, precise and efficient handling of floating-point numbers is vital for producing accurate results and managing computational resources effectively. Lastly, an understanding of binary floating-point representation lays the foundation for grasping more complex concepts in computer science, such as encryption algorithms, data compression techniques, and error detection and correction methods.

In binary and denary systems, representing very large or small numbers involves different approaches. In the denary system, large numbers are typically represented in a straightforward manner, using an extended sequence of digits. However, representing extremely large numbers can be challenging due to limitations in physical storage and processing capabilities. In contrast, the binary system often employs a method known as "floating-point representation" for both large and small numbers. This method uses a fixed number of digits (bits) to represent the mantissa and exponent separately, allowing for a wide range of values with a relatively small number of bits. For example, in binary, a large number would have a small mantissa and a large exponent, while a small number would have a larger mantissa and a negative exponent. This method is particularly efficient for representing numbers that vary greatly in magnitude, but it can introduce rounding errors due to the finite number of bits used, leading to precision loss, especially in scientific and engineering calculations where accuracy is paramount.

Overflow and underflow are issues that arise in binary floating-point arithmetic when the numbers involved exceed the representational capacity of the system. Overflow occurs when a number is too large to be represented in the available number of bits, leading to a loss of significant data or an erroneous result. For example, if an arithmetic operation results in a number larger than what can be represented by the allocated bits for the exponent, overflow occurs. This often leads to the number being approximated to infinity or a large number, which can cause significant errors in calculations.

Underflow happens when a number is too small to be represented, typically occurring with numbers close to zero. In such cases, the number may be rounded down to zero or to a smaller number with less precision than required. Underflow can lead to a loss of accuracy, especially in iterative calculations where small errors accumulate over time.

Both overflow and underflow can have critical implications in computing, affecting the accuracy and reliability of numerical computations. To mitigate these issues, modern computing systems implement techniques like extended precision, error checking, and special handling of extreme values. Understanding and managing these issues are essential for designing robust and accurate computational algorithms and systems.