I asked Gemini to teach me the VHDL type conversions. What you read below is the result. An annoying generated podcast will be available for a while.

VHDL IEEE Libraries and Numeric Type Conversions: A Definitive Reference

Introduction

The VHSIC Hardware Description Language (VHDL) is a formal, strongly-typed language engineered for use in all phases of the creation of electronic systems, including development, verification, synthesis, and testing.¹ Its dual nature, being both human-readable and machine-readable, underpins its role in communicating, maintaining, and procuring hardware designs.³ The core language, while powerful, is intentionally minimal. Its true utility in modern digital design is unlocked through a suite of standardized packages governed by the Institute of Electrical and Electronics Engineers (IEEE). These libraries extend VHDL’s capabilities, providing the essential types and functions needed to model complex hardware phenomena accurately and efficiently.

The standardization of VHDL, a process that began in the mid-1980s, is overseen by the VHDL Analysis and Standardization Group (VASG), also known as the IEEE P1076 working group.¹ The evolution of the IEEE 1076 standard and its associated library standards is critical. Adherence to these official standards is paramount for ensuring that VHDL code is portable across different Electronic Design Automation (EDA) tools, interoperable within larger projects, and maintains a predictable, reliable behavior that can be understood and maintained by design teams.²

This report serves as a definitive technical reference for the most essential IEEE libraries used in VHDL design. It begins by deconstructing the foundational multi-value logic system provided by the std_logic_1164 package. It then details the numeric_std package, the official standard for synthesizable arithmetic. Following this, a comprehensive masterclass on type conversion provides practical guidance for navigating VHDL’s type system. Finally, the report offers an overview of specialized packages for advanced simulation and synthesizable fixed- and floating-point arithmetic, concluding with a forward-looking perspective on the language’s evolution.

Section 1: The Foundational Multi-Value Logic System: IEEE.STD_LOGIC_1164

The std_logic_1164 package is the bedrock of modern VHDL design. It provides a standardized multi-value logic system that is indispensable for accurately modeling the physical behavior of digital hardware, moving far beyond the capabilities of the language’s native bit type.

1.1 Beyond BIT: The Rationale for a 9-Value Logic System

VHDL’s built-in BIT type, which is an enumeration of only ‘0’ and ‘1’, is insufficient for realistic hardware modeling and simulation.⁶ Digital circuits exhibit behaviors that cannot be captured by simple binary logic. For example, at the start of a simulation, the state of a register is unknown until it is explicitly initialized; this requires an “uninitialized” state. When multiple drivers contend for control of a single wire (a bus conflict), the resulting voltage level is indeterminate, necessitating an “unknown” state. Furthermore, modeling shared buses requires a “high-impedance” state to represent a driver that is electrically disconnected. To address these and other physical phenomena, the

std_logic_1164 package, defined by the separate IEEE Std 1164, was developed to provide a robust, standardized 9-value logic system.⁷

1.2 The Unresolved Base Type: std_ulogic

The foundation of this 9-value system is the std_ulogic type, an enumerated type that forms the basis for all other types in the package. Its definition includes nine distinct character literals, each representing a specific state of a digital signal.⁹ The vector counterpart,

std_ulogic_vector, is defined as an unconstrained array of std_ulogic elements.⁹

Table 1.1: The Nine States of std_ulogic

The precise meaning of each of the nine logic values is critical for designers to correctly interpret simulation results and write effective verification code.

1.3 Signal Resolution and the std_logic Subtype

The distinction between std_ulogic (unresolved) and std_logic (resolved) is a cornerstone concept in VHDL that directly enables the modeling of complex, real-world bus structures. In VHDL, a “driver” is a source for a signal, such as a process or a concurrent assignment. The language enforces a strict rule that any signal of an unresolved type, like std_ulogic, cannot have more than one driver. This is a compile-time check that prevents ambiguity.⁶

However, physical hardware buses, such as a memory data bus, are explicitly designed to have multiple drivers (e.g., multiple memory chips and a CPU all connected to the same data lines). To model this physical reality, VHDL employs a “resolution function.” The std_logic_1164 package provides a function named resolved that acts as an arbiter. This function takes an array of all driving values on a net and, based on a predefined truth table, returns a single, resolved value that the signal will take.⁶

The std_logic type is formally declared as a subtype of std_ulogic that has this resolution function associated with it: subtype std_logic is resolved std_ulogic;. This simple declaration is profoundly important. It creates a type that can legally have multiple drivers, making it the essential and de facto industry standard for declaring all signals that model physical wires, especially entity ports and internal buses.⁷ The corresponding vector type,

std_logic_vector, is an array of these resolved elements.⁷

1.4 A Compendium of std_logic_1164 Functions

The std_logic_1164 package provides a complete toolkit for manipulating these multi-value logic types.⁷

• Logical Operators: The package overloads the standard logical operators (and, or, nand, nor, xor, xnor, not) to operate on both scalar (std_ulogic, std_logic) and vector (std_ulogic_vector, std_logic_vector) types.
• Edge Detection: The functions rising_edge(signal s: std_logic) and falling_edge(signal s: std_logic) are the standard, preferred way to describe synchronous, edge-triggered logic. They are superior to the older clk’event and clk = ‘1’ construct because they are explicitly defined to return true only for a ‘0’ -> ‘1’ (or ‘1’ -> ‘0’) transition. This correctly filters out ambiguous transitions from meta-values like ‘X’ -> ‘1’ that would otherwise trigger clk’event, leading to more robust and predictable simulation behavior.⁷
• Meta-Value Detection: The is_x function is a powerful, non-synthesizable tool for verification. It returns a boolean TRUE if its input vector or scalar contains any of the non-logic values ‘U’, ‘X’, ‘Z’, ‘W’, or ‘-’. This allows a testbench to check for the propagation of unknown or uninitialized states, which often indicates a design flaw.⁷ Synthesis tools generally do not support this function.⁸
• Conversion Functions: For interoperability with legacy VHDL-87 code, the package includes functions to convert between the std_logic family and the original bit/bit_vector types: to_bit, to_bitvector, to_stdulogic, and to_stdlogicvector.⁷

Section 2: The Standard for Synthesizable Arithmetic: IEEE.NUMERIC_STD

While std_logic_1164 provides the foundation for representing logic values, it does not define their numeric interpretation. The ieee.numeric_std package, defined in IEEE Std 1076.3, is the official, industry-wide standard for performing synthesizable arithmetic operations in VHDL.¹⁴

2.1 Establishing a Standard for Numeric Interpretation

Performing arithmetic directly on a std_logic_vector is inherently ambiguous. The bit pattern “1000” could represent the unsigned value 8 or the signed two’s complement value -8. To resolve this ambiguity and provide a type-safe framework for hardware arithmetic, numeric_std introduces two dedicated numeric types.¹⁴ For any new design that involves arithmetic, this package is the mandatory choice to ensure portability, predictability, and safety.¹⁴

2.2 The Core Numeric Types: unsigned and signed

The package defines two fundamental types that are the basis for all its operations ¹⁹:

• type UNSIGNED is array (NATURAL range <>) of STD_LOGIC;
• type SIGNED is array (NATURAL range <>) of STD_LOGIC;

These types are arrays of std_logic, not bit. This is a crucial feature, as it allows them to carry meta-values (‘X’, ‘Z’, etc.) through a chain of arithmetic operations. If any bit of an operand to a numeric_std function is a meta-value, the entire result is typically set to a vector of ‘X’s.²⁰ This behavior is invaluable for debugging, as it ensures that uninitialized signals or bus conflicts propagate cleanly to the output, making the source of an error far easier to trace than if the meta-values were silently converted to ‘0’ or ‘1’.

The numeric interpretation is strict and unambiguous:

• unsigned: Represents a positive integer in standard binary representation.¹⁴
• signed: Represents an integer in two’s complement format, where the leftmost bit is always treated as the sign bit.¹⁴

2.3 A Compendium of NUMERIC_STD Functions and Operators

The numeric_std package provides a comprehensive set of overloaded functions and operators for robust arithmetic design.¹⁴

• *Arithmetic Operators (+, -, , /, rem, mod): The package provides overloaded versions for operations between two signed vectors, two unsigned vectors, or a numeric vector and an INTEGER or NATURAL.²¹ A deliberate and important design choice in
  numeric_std is the omission of operators for mixed signed and unsigned operands.²⁰ This is not an oversight but a critical feature for type safety. An operation like
  my_signed + my_unsigned is ambiguous: should the unsigned value be zero-extended or sign-extended to match the signed type before addition? The results are mathematically different. By not providing a default behavior, the package forces the designer to make their intent explicit through a type cast (e.g., my_signed + signed(my_unsigned)), thereby preventing a class of subtle and hard-to-find bugs. The rules for result sizing are also well-defined to prevent unintended truncation: addition and subtraction results are sized to match the larger operand, while multiplication results are sized to the sum of the operand lengths.¹⁹
• Comparison Operators (=, /=, >, <, etc.): A full suite of relational operators is provided for comparing two numeric vectors or a numeric vector with an integer.¹⁴
• Logical Operators (and, or, not, etc.): These operators perform bit-wise logical operations on the underlying std_logic elements of the signed or unsigned vectors.¹⁴
• Shift Functions (shift_left, shift_right, sll, srl, rol, ror): The package distinguishes between logical shifts and arithmetic shifts. For unsigned vectors, a right shift is always logical (srl), filling vacated bits with ‘0’. For signed vectors, the arithmetic right shift (sra or shift_right) correctly performs sign extension by replicating the most significant bit, which is essential for preserving the number’s algebraic value when dividing by powers of two.¹⁴
• The resize() Function: This function is of paramount importance for managing vector widths. Its behavior is precisely defined ¹⁴:
  • Increasing Size: When resizing to a larger width, a signed vector is sign-extended (the MSB is replicated to the left), while an unsigned vector is zero-extended (padded with ‘0’s).
  • Decreasing Size (Truncation): The leftmost bits are dropped. For a signed vector, the original sign bit and the rightmost bits are retained. For an unsigned vector, the rightmost bits are retained.

2.4 A Note on Deprecated Packages: The std_logic_arith Family

Designers may encounter packages named std_logic_arith, std_logic_signed, and std_logic_unsigned in the ieee library of their EDA tools.²² It is imperative to understand that these packages are

not part of the official IEEE standard. They are legacy, proprietary packages created by EDA vendors like Synopsys and Mentor Graphics before numeric_std was standardized.¹⁶

These packages should be avoided in all new designs for several critical reasons ¹⁶:

1. Non-Standard: They are not governed by the IEEE and can have tool-specific implementations and behaviors.
2. Ambiguity: They dangerously overload arithmetic operators to work directly on the non-numeric std_logic_vector type. This forces the tool to guess whether the vector is signed or unsigned based on which package is included, hiding the designer’s intent and creating a fertile ground for bugs.
3. Conflicts: The std_logic_signed and std_logic_unsigned packages are mutually exclusive and cannot be used in the same design file, making it difficult to work with both signed and unsigned numbers in the same module.²⁷

The definitive best practice is to always use ieee.numeric_std.all; for all arithmetic operations and to explicitly declare signals as signed or unsigned to make the design’s intent clear and safe.

Section 3: A Comprehensive Guide to VHDL Type Conversion

VHDL’s strong type system is a deliberate design feature that prevents unintended operations between incompatible types, catching a class of errors at compile time that might otherwise go undetected.¹⁷ Navigating this system requires a clear understanding of the difference between type casting and conversion functions.

3.1 Type Casting vs. Conversion Functions: The Core Principle

The distinction between the syntax for different conversions stems directly from VHDL’s language rules regarding type relationships.

• Type Casting: This is a simple re-interpretation of an object’s value as a “closely related type.” The underlying bit representation of the data does not change. In the context of this report, the types std_logic_vector, unsigned, and signed are all defined as arrays of std_logic and are therefore considered closely related.³⁰ A direct type cast is permitted between them.
• Conversion Functions: These are explicit subprograms that perform an algorithmic conversion between types that are not closely related. The integer type, for instance, is an abstract numeric type, not an array of bits, and thus requires a function to convert it to or from a vector type. These functions often require additional parameters, such as the target vector size, to resolve ambiguities.²⁹

3.2 The std_logic_vector ↔ unsigned / signed Nexus

Conversion between the fundamental vector types is accomplished via simple type casting. The only requirement is that the source and destination vectors must have the same length.²⁹

• From std_logic_vector to numeric types:
  VHDL
  – Assuming slv is a std_logic_vector
  my_unsigned <= unsigned(slv);
  my_signed <= signed(slv); \

• From numeric types to std_logic_vector:
  VHDL
  – Assuming u is unsigned and s is signed
  my_slv <= std_logic_vector(u);
  my_slv <= std_logic_vector(s); \

3.3 Bridging to Abstract Numeric Types (integer, real)

Converting to and from abstract types like integer and real requires the use of explicit conversion functions from the numeric_std package.

• Conversions Involving integer:

  • Vector to integer: The to_integer function takes a signed or unsigned vector and returns its corresponding integer value, correctly interpreting the two’s complement or binary representation.¹⁷
  • integer to Vector: The to_signed and to_unsigned functions convert an integer to a numeric vector. A second argument, SIZE, is mandatory because an abstract integer has no inherent bit width. This parameter specifies the width of the resulting vector.²⁰

• The Mandatory Two-Step std_logic_vector ↔ integer Conversion: Because std_logic_vector has no intrinsic numeric meaning, there is no direct conversion path to integer.²⁹ A two-step process is required: first, cast the
  std_logic_vector to its intended numeric type (unsigned or signed), and second, call the appropriate conversion function.¹⁷

  • std_logic_vector to integer:
    VHDL
    – For unsigned data
    my_int <= to_integer(unsigned(my_slv));
    – For signed data
    my_int <= to_integer(signed(my_slv)); \

  • integer to std_logic_vector:
    VHDL
    – For unsigned data
    my_slv <= std_logic_vector(to_unsigned(my_int, 8));
    – For signed data
    my_slv <= std_logic_vector(to_signed(my_int, 8)); \

• Conversions Involving real: The real type is an abstract floating-point type intended for simulation. Conversion between real and integer is done via simple casting: my_real <= real(my_int); and my_int <= integer(my_real);.³⁶ When converting from
  real to integer, the value is rounded to the nearest integer; however, the handling of halfway cases (e.g., 2.5) can be tool-dependent.³⁸
  Crucially, any operation involving the real type is not synthesizable and is strictly for high-level modeling and verification.³⁹

3.4 The Definitive VHDL Conversion Matrix

The following table provides a quick-reference guide for the syntax of the most common type conversions.

Table 3.1: VHDL Type Conversion Syntax & Libraries

3.5 Common Pitfalls and Best Practices

To write robust and error-free code, designers should be aware of common conversion-related pitfalls. These include attempting arithmetic directly on std_logic_vector when using numeric_std, mixing signed and unsigned operands without an explicit cast, and forgetting the essential SIZE parameter in the to_signed/to_unsigned functions.¹⁶ The most robust coding practice is to declare signals with their intended numeric type (

unsigned or signed) from the outset if they are to be used in arithmetic. This approach makes the code’s intent self-documenting and fully leverages VHDL’s type system for safety, rather than treating all signals as generic std_logic_vectors and relying on last-minute casting.¹³

Section 4: Specialized and Evolving IEEE Packages

Beyond the foundational logic and arithmetic packages, the IEEE standard provides libraries for more specialized tasks, drawing a clear line between synthesizable design and high-level verification. The language also continues to evolve, with newer standards offering powerful features for modern design challenges.

4.1 Text I/O for Verification: IEEE.STD_LOGIC_TEXTIO

The std_logic_textio package extends the standard textio package by providing overloaded read and write procedures that can handle std_logic-based types.⁴¹ Its primary application is in testbenches for reading stimulus from text files and writing simulation results to log files.⁴² The package also includes utility procedures like

hread/hwrite and oread/owrite for conveniently handling hexadecimal and octal text representations in files.⁴¹

4.2 High-Level Simulation: The IEEE.MATH_REAL Package

The math_real package contains a rich collection of mathematical constants (e.g., MATH_PI, MATH_E) and transcendental functions (e.g., SQRT, LOG, SIN, COS) that operate on the real data type.⁴⁴ This package is

strictly for non-synthesizable, high-level modeling and simulation.³⁹ Its great value lies in enabling the creation of accurate, floating-point reference models within a testbench. These models can be used to generate expected results against which the synthesizable, bit-accurate hardware implementation can be verified.

4.3 Synthesizable Real-Number Alternatives: The VHDL-2008 Packages

The introduction of synthesizable fixed- and floating-point packages in the VHDL-2008 standard was a landmark event, providing a standardized and portable methodology for implementing algorithms with fractional arithmetic. These packages are the standard-compliant and recommended path from a mathematical concept to a hardware implementation.⁴⁷

• IEEE.FIXED_PKG: This package introduces the ufixed (unsigned fixed-point) and sfixed (signed fixed-point) types.⁵⁰ It employs a novel indexing scheme where the vector range can include negative indices (e.g.,
  sfixed(7 downto -8)), with the binary point implicitly located between index 0 and -1. The package provides to_ufixed and to_sfixed conversion functions and a full suite of arithmetic operators that automatically manage the precision and growth of the result vectors, simplifying fixed-point design significantly.⁵¹
• IEEE.FLOAT_PKG: This package introduces the float type and standard subtypes like float32 and float64, which directly correspond to the IEEE 754 floating-point standards.⁵² It is used for applications requiring a wide dynamic range where the limited range of fixed-point arithmetic may not be suitable.
• Fixed vs. Floating Point Trade-offs: A fundamental trade-off exists between these two representations. Fixed-point arithmetic is generally far more efficient in terms of hardware resources (area) and performance (speed and latency). Floating-point offers a vast dynamic range but at the cost of significantly more complex and resource-intensive hardware. For most FPGA applications, fixed-point is the preferred choice unless the algorithm’s dynamic range requirements make it impractical.⁴⁸

4.4 The Future: VHDL-2019 and Beyond

The VHDL standard is a living document that continues to evolve. The VHDL-2019 revision introduced further enhancements, including 64-bit integers, improved file I/O APIs, and powerful interface constructs, demonstrating that the language is actively maintained and modernized to meet the demands of contemporary hardware design.⁵⁶ The ongoing work of the IEEE P1076 working group toward a future VHDL-202x standard signals a healthy and active future for the language, ensuring its continued relevance in the field of electronic design automation.⁵⁹

Conclusion: Principles for Robust and Portable VHDL

A thorough understanding of the VHDL standard libraries and type system is not merely an academic exercise; it is a prerequisite for writing robust, portable, and maintainable hardware descriptions. The IEEE packages provide the tools to move beyond simple logic modeling into the realms of complex arithmetic, bus-based systems, and sophisticated verification. Mastering their use involves internalizing a set of core principles.

Summary of Key Principles

• std_logic_1164 is Universal: This package provides the foundational 9-value logic system necessary for modeling real-world hardware effects like high-impedance states and unknown values. Its resolved std_logic type is the de facto standard for all signal and port declarations.
• numeric_std is the Standard for Arithmetic: For any synthesizable design that performs mathematical operations, numeric_std is the official, non-negotiable standard. Its signed and unsigned types provide an unambiguous numeric interpretation, and its strict type-checking rules prevent a wide class of common design errors.
• Understand the Conversion Hierarchy: There is a clear distinction between type casting—a simple re-interpretation between closely related array types (std_logic_vector, unsigned, signed)—and conversion functions, which perform algorithmic translations to or from abstract types like integer.
• Respect the Synthesis Boundary: A clear line divides packages intended for simulation and verification (like math_real and std_logic_textio) from those that describe synthesizable hardware (numeric_std, fixed_pkg, float_pkg). Using simulation-only constructs in a design intended for hardware implementation is a common and fundamental error.

Final Recommendations

To produce high-quality, professional VHDL code, designers should adhere to the following best practices:

1. Standardize Design Headers: Begin every synthesizable design file with the following context clauses:
   VHDL
   library ieee;
   use ieee.std_logic_1164.all;
   use ieee.numeric_std.all;

2. Declare with Intent: If a signal represents a number and will be used in arithmetic, declare it directly as unsigned or signed. This makes the code self-documenting and leverages VHDL’s type system for maximum safety. Avoid the practice of declaring everything as std_logic_vector and casting only when necessary.

3. Be Explicit in Conversions: Make all type conversions explicit and clear. Never rely on the ambiguous or non-standard behavior of deprecated packages like std_logic_arith.

4. Use the Right Tool for the Job: Leverage the power of real and the math_real package to create high-level, floating-point reference models in testbenches. For the hardware implementation of any fractional arithmetic, use the synthesizable fixed_pkg or float_pkg from the VHDL-2008 standard.

5. Stay Current: Be aware of the VHDL standard version supported by your tools. Newer versions (VHDL-2008 and beyond) offer powerful, standardized features that simplify code, reduce errors, and enhance verification capabilities.

Works cited

1. IEEE standard VHDL language reference manual - NIST Technical Series Publications, accessed June 29, 2025, https://nvlpubs.nist.gov/nistpubs/Legacy/FIPS/fipspub172-1.pdf
2. IEEE Standard VHDL Language Reference Manual - Electronics Development Group, accessed June 29, 2025, https://edg.uchicago.edu/~tang/VHDLref.pdf
3. IEEE Standard VHDL Language Reference Manual - TWiki, accessed June 29, 2025, https://eda-twiki.org/twiki/pub/P10761/WorkingGroupDocumentsPrivate/P1076-2008-conditional.pdf
4. IEEE Standard for VHDL Language Reference Manual - 0x04.net, accessed June 29, 2025, https://www.0x04.net/~mwk/vstd/ieee-1076-2019.pdf
5. IEEE Std 1076-2008 (Revision of IEEE Std 1076-2002) IEEE Standard VHDL Language Reference Manual - Milwaukee School of Engineering, accessed June 29, 2025, https://faculty-web.msoe.edu/johnsontimoj/Common/FILES/VHDL_2008.pdf
6. Standard Logic Type - VHDL-Online, accessed June 29, 2025, https://www.vhdl-online.de/courses/system_design/vhdl_language_and_syntax/extended_data_types/standard_logic_type
7. Std_Logic_1164 Package - VHDL - Peter F, accessed June 29, 2025, https://peterfab.com/ref/vhdl/vhdl_renerta/mobile/source/vhd00068.htm
8. std_logic_1164 Package, accessed June 29, 2025, http://yang.world/podongii_X2/html/technote/TOOL/MANUAL/15i_doc/fndtn/vhd/vhd10_1.htm
9. Std_logic_1164 Package - HDL Works, accessed June 29, 2025, https://www.hdlworks.com/hdl_corner/vhdl_ref/VHDLContents/StdLogic1164.htm
10. Using the Standard Logic Package - PLDWorld.com, accessed June 29, 2025, http://pldworld.info/_hdl/2/_ref/acc-eda/language_overview/using_standard_logic/using_the_standard_logic_package.htm
11. std_logic_1164, accessed June 29, 2025, https://www.cs.sfu.ca/~ggbaker/reference/std_logic/1164/
12. std_logic_1164 package - UMBC, accessed June 29, 2025, https://portal.cs.umbc.edu/help/VHDL/packages/std_logic_1164.vhd
13. VHDL Best Practices, accessed June 29, 2025, https://faculty-web.msoe.edu/johnsontimoj/Common/FILES/vhdl_best_practices.pdf
14. numeric_std - Wikipedia, accessed June 29, 2025, https://en.wikipedia.org/wiki/Numeric_std
15. Numeric_Std Package - HDL Works, accessed June 29, 2025, https://www.hdlworks.com/hdl_corner/vhdl_ref/VHDLContents/NumericStd.htm
16. VHDL Math: std_logic_arith vs. numeric_std - Nandland, accessed June 29, 2025, https://nandland.com/vhdl-math-std_logic_arith-vs-numeric_std/
17. VHDL Convert to Integer? - Hardware Coder, accessed June 29, 2025, https://hardwarecoder.com/qa/111/vhdl-convert-to-integer
18. When to use VHDL library std_logic_unsigned and numeric_std? - Stack Overflow, accessed June 29, 2025, https://stackoverflow.com/questions/45704135/when-to-use-vhdl-library-std-logic-unsigned-and-numeric-std
19. numeric_std.vhd - UMBC, accessed June 29, 2025, https://portal.cs.umbc.edu/help/VHDL/packages/numeric_std.vhd
20. VHDL Packages: numeric_std - PLDWorld.com, accessed June 29, 2025, http://www.pldworld.com/_hdl/2/RESOURCES/www.ece.msstate.edu/_reese/EE8993/lectures/numeric_standard/numeric_standard.pdf
21. numeric_std Package, accessed June 29, 2025, http://www1.pldworld.com/@xilinx/html/TECHNOTE/TOOL/MANUAL/21i_doc/data/fndtn/vhd/vhd10_3.htm
22. VHDL standard packages and types - UMBC CSEE, accessed June 29, 2025, https://www.csee.umbc.edu/portal/help/VHDL/stdpkg.html
23. std_logic_unsigned, accessed June 29, 2025, https://www2.cs.sfu.ca/~ggbaker/reference/std_logic/unsigned/
24. portal.cs.umbc.edu, accessed June 29, 2025, https://portal.cs.umbc.edu/help/VHDL/std_logic_unsigned.vhdl
25. portal.cs.umbc.edu, accessed June 29, 2025, https://portal.cs.umbc.edu/help/VHDL/std_logic_signed.vhdl
26. Why should I not use std_logic_arith? : r/FPGA - Reddit, accessed June 29, 2025, https://www.reddit.com/r/FPGA/comments/1j0wcbq/why_should_i_not_use_std_logic_arith/
27. numeric_std vs std_logic_unsigned.all | Forum for Electronics, accessed June 29, 2025, https://www.edaboard.com/threads/numeric_std-vs-std_logic_unsigned-all.266288/
28. VHDL: Code Structure, accessed June 29, 2025, http://web02.gonzaga.edu/faculty/talarico/CP430/LEC/lec05-bari.pdf
29. VHDL Type Conversion - BitWeenie | BitWeenie, accessed June 29, 2025, https://www.bitweenie.com/listings/vhdl-type-conversion/
30. Type Conversion - VHDL - Peter F, accessed June 29, 2025, https://peterfab.com/ref/vhdl/vhdl_renerta/mobile/source/vhd00075.htm
31. numeric_std (signed/unsigned) vs std_logic_1164 (std_logic_vector) | Forum for Electronics, accessed June 29, 2025, https://www.edaboard.com/threads/numeric_std-signed-unsigned-vs-std_logic_1164-std_logic_vector.206171/
32. VHDL std_logic_vector conversion to signed and unsigned with numeric_std, accessed June 29, 2025, https://stackoverflow.com/questions/14438516/vhdl-std-logic-vector-conversion-to-signed-and-unsigned-with-numeric-std
33. Examples of VHDL Conversions - Nandland, accessed June 29, 2025, https://nandland.com/common-vhdl-conversions/
34. VHDL: Converting from an INTEGER type to a STD_LOGIC_VECTOR, accessed June 29, 2025, https://electronics.stackexchange.com/questions/4482/vhdl-converting-from-an-integer-type-to-a-std-logic-vector
35. How to use Signed and Unsigned in VHDL - YouTube, accessed June 29, 2025, https://www.youtube.com/watch?v=qyx-DAewCQw
36. Type Conversion - HDL Works, accessed June 29, 2025, https://www.hdlworks.com/hdl_corner/vhdl_ref/VHDLContents/TypeConversion.htm
37. VHDL Type Conversion? - Hardware Coder, accessed June 29, 2025, https://hardwarecoder.com/qa/254/vhdl-type-conversion
38. Type conversion in VHDL: real to integer - Is the rounding mode …, accessed June 29, 2025, https://stackoverflow.com/questions/27823757/type-conversion-in-vhdl-real-to-integer-is-the-rounding-mode-specified
39. Using real data types in VHDL - VHDL coding tips and tricks, accessed June 29, 2025, https://vhdlguru.blogspot.com/2011/06/using-real-data-types-in-vhdl.html
40. Why can’t implement vhdl by real number? - Adaptive Support - AMD, accessed June 29, 2025, https://adaptivesupport.amd.com/s/question/0D52E00006hpT3lSAE/why-cant-implement-vhdl-by-real-number?language=en_US
41. std_logic_textio - UMBC, accessed June 29, 2025, https://portal.cs.umbc.edu/help/VHDL/packages/std_logic_textio.vhd
42. courses:system_design:simulation:file_io [VHDL-Online], accessed June 29, 2025, https://www.vhdl-online.de/courses/system_design/simulation/file_io
43. VHDL BASIC Tutorial - Writing a data in file - YouTube, accessed June 29, 2025, https://www.youtube.com/watch?v=8rteukfxV6c
44. math_real - UMBC, accessed June 29, 2025, https://portal.cs.umbc.edu/help/VHDL/math_real.vhdl
45. ieee/math_real.vhdl · 16a012320947d378611cc7457f64ed76cb52bac4 · vasg / Packages · GitLab, accessed June 29, 2025, https://opensource.ieee.org/vasg/Packages/-/blob/16a012320947d378611cc7457f64ed76cb52bac4/ieee/math_real.vhdl
46. VHDL Predefined IEEE Real Type and IEEE Math_Real Packages - 2025.1 English - UG901, accessed June 29, 2025, https://docs.amd.com/r/en-US/ug901-vivado-synthesis/VHDL-Predefined-IEEE-Real-Type-and-IEEE-Math_Real-Packages
47. Floating Example - EDA Playground, accessed June 29, 2025, https://www.edaplayground.com/x/5htW
48. MicroZed Chronicles: Fixed and Floating Point Maths, accessed June 29, 2025, https://www.adiuvoengineering.com/post/microzed-chronicles-fixed-and-floating-point-maths
49. How to use real numbers in vhdl coding in FPGA? - ResearchGate, accessed June 29, 2025, https://www.researchgate.net/post/How_to_use_real_numbers_in_vhdl_coding_in_FPGA
50. Fixed point package user’s guide - Free Model Foundry, accessed June 29, 2025, https://freemodelfoundry.com/fphdl/Fixed_ug.pdf
51. Fixed Point Operations in VHDL : Tutorial Series Part 3, accessed June 29, 2025, https://vhdlguru.blogspot.com/2010/03/fixed-point-operations-in-vhdl-tutorial_29.html
52. Floating point package user’s guide - Index of /, accessed June 29, 2025, https://reup.dmcs.pl/wiki/images/4/45/Float_ug.pdf
53. fphdl/float_pkg_c.vhdl at master · FPHDL/fphdl · GitHub, accessed June 29, 2025, https://github.com/FPHDL/fphdl/blob/master/float_pkg_c.vhdl
54. Fixed point arithmetic with high level VHDL - Hardware Descriptions, accessed June 29, 2025, https://hardwaredescriptions.com/elementor-fixed-point-arithmetic-in-synthesizable-vhdl/
55. Difference in floating point and fixed point arithmetic in vhdl. - Intel Community, accessed June 29, 2025, https://community.intel.com/t5/Programmable-Devices/Difference-in-floating-point-and-fixed-point-arithmetic-in-vhdl/td-p/193696
56. VHDL 2019: Usability and APIs - Sigasi, accessed June 29, 2025, https://www.sigasi.com/tech/what-is-new-in-vhdl-2019-part4/
57. VHDL-2019: the Users Standard - OSVVM, accessed June 29, 2025, https://osvvm.org/archives/1657
58. What’s new in VHDL-2019 - VHDLwhiz, accessed June 29, 2025, https://vhdlwhiz.com/vhdl-2019/
59. About - 6.0.0-dev - GitHub Pages, accessed June 29, 2025, https://ghdl.github.io/ghdl/about.html
60. VHDL-202X — VHDL Analysis and Standardization Group (VASG …, accessed June 29, 2025, https://ieee-p1076.gitlab.io/VHDL-202X/index.html
61. WebHome < P1076 < TWiki, accessed June 29, 2025, http://www.eda-twiki.org/cgi-bin/view.cgi/P1076/WebHome