Please enable JavaScript.

Coggle requires JavaScript to display documents.

(Types) - Coggle Diagram

- - - - Depends on language
      - Commonly
        
        assignment
        
        catenation
        
        comparison for equality and inequality
        
        slices
    - - Data elements have pre defined type
      - element is identified by its position
      - homogeneous aggregate of data elements
    - - One-dimensional arrays - Vector
        
        Implementation
        
        if run time checking done, attributes are static
        
        only access function required
        
        descriptor not required
        
        descriptor stores information
        
        requires more compile-time efforts
        
        can be accessed by using the function
        
        value can be computed if statically bound
      - Two-dimensional arrays - Matrix
        
        Implementation
        
        row major order
        
        address is base address of structure
      - Multi-dimensional arrays
        
        accesses to elements of arrays with several subscripts are costly
        
        Rectangular and Jagged Arrays
        
        Rectangular array
        
        all rows have same number and all columns too
        
        Jagged Array
        
        Lengths no need to be same
        
        Associative Array
        
        only design issue that is specific for associative arrays is the form of references to their elements.
        
        indexed by keys
        
        each element is a key and a value
        
        Implemented using a hash table
    - - Heap Dynamic Array
        
        Longer allocation and Deallocation
        
        Flexibility
        
        Binding is dynamic in heap
      - Static Array
        
        statically bound and static allocation
        
        Size known at compile time
        
        Efficient
      - based on
        
        the binding to subscript ranges
        
        the binding to storage
        
        from where the storage is allocated
      - Fixed Stack- Dynamic Array
        
        Space Efficient
        
        Size known at compile time
        
        Requires allocation and de allocation time
        
        statically bound but allocation done at declaration
      - Fixed Heap Dynamic
        
        Subscript ranges and storage binding are fixed after allocation
        
        Binding done during request
        
        Flexible
        
        Allocated from heap which is longer than stack
    - - Depends on language
      - some allow initialisation in declaration
      - C & C++ implement string as a char array
  - - - About
        
        doesn't consider semantics
        
        Different versions are used
        
        Describe Text patterns
        
        Characters have own syntax
        
        aka
        
        regexp
        
        regex
        
        matching text done by Regex Engine
      - Basic Elements
        
        Position indicators
        
        Character sets
        
        Quantifiers
      - Anchors
        
        Regex Engine stops after first match
        
        Characters
        
        ^ - start of the string
        
        $ - end of the
        
        \Z - End of string
        
        \b - Word boundary
        
        \B - Not word boundary
        
        \< - Start of word
        
        > - End of word
      - Character sets
        
        Character classes
        
        [xy] - x or y
        
        [a-z] - a or b or ……z
        
        [1-9a-zA-Z] - a or b or ……z or A or B or ……Z or 1 or 2 or ……9
        
        [^1-9] - Any character other than a digit (negation)
        
        . - Any character.
        
        In languages
        
        \d - Match any character in the range 0 – 9
        
        \D - Match any character NOT in the range 0 - 9
        
        \s - Match any whitespace characters (space, tab etc.)
        
        \S - Match any character NOT whitespace (space, tab)
        
        \w - Match any character in the range 0 - 9, A - Z and a – z
        
        \W - Match any character NOT the range 0 - 9, A - Z and a - z
      - Recursive Definition
        
        a | b choice
        
        ab sequence
        
        (a) grouping
        
        a* zero or more repetitions
        
        a+ One or more repetitions
      - Quantifiers
        
        Specify repetition
        
        generally applies to preceded item
    - - String length
        
        Limited dynamic length strings
        
        Require more complex storage management
        
        Adjacent storage cells
        
        Faster operations
        
        Less storage required
        
        But not practical with increasing string size
        
        Pointer array
        
        Faster than linked list
        
        Extra memory
        
        Linked list
        
        But simpler allocation and deallocation
        
        Extra storage
        
        Complex operations
        
        Stores
        
        Current length
        
        Fixed max length
        
        Require run time descriptor except in C & C++
        
        Static length string
        
        Descriptor required only during compilation has
        
        Address of first character
        
        Name of type
        
        Type length
        
        Dynamic length strings
  - - - Array requires loop for simple tasks
  - - - Value representation
        
        Provision is made by language for collection of bits
        
        True may be 1 or -1 or any other non-zero value
        
        False is 0
        
        Single bit can be used
        
        Single addressable unit such as byte or word is used
        
        Not efficient on many machines
        
        Follows Boolean algebra
        
        Can have either true or false
      - History
        
        C89 uses numerical expressions as conditionals
        
        Introduced in Algol 60
        
        Simplest data type
        
        Improves readability
      - About
        
        Used to implement choice
        
        Logical data type
        
        Represents true and false
    - - Stored as numeric codes
      - Single character as value
      - Most commonly used
        
        8-bit ascii
        
        Iso 8859-1
        
        Unicode
      - Character set is aggregate of all characters
      - Numbers are code points
      - Assignment of numbers are code pages
      - Ordering is collating sequence
      - Each character assigned to different number
      - Most languages include primitive type for single characters except python
    - - Fixed point
        
        Hardware support is available but may be software simulated
        
        Store fixed number of decimal digits with fixed position for decimal point
        
        Primary data type in business data processing like Cobol
        
        Data stored
        
        Using binary coded decimal
        
        As integers with decimal being attribute (scale factor)
        
        Advantages
        
        High precision
        
        Disadvantages
        
        Restricted range (no exponents)
        
        Wasting memory
        
        Stored similar to character strings
        
        More storage taken than binary
      - Integers
        
        Representation
        
        Computer
        
        Hardware support
        
        Not supported
        
        Real world
        
        Differences between integer data types in different languages
        
        May / may not allow negative
        
        Size variation
        
        Different machines
        
        Languages
        
        Storage representation
        
        Unsigned
        
        Signed
        
        Two's complement
        
        Sign magnitude
        
        One's complement
        
        Operations on integer data
        
        Arithmetic
        
        Binary
        
        Unary
        
        Relation
        
        Assignment
        
        Bit operation
      - Floating point
        
        Computer representation
        
        Differ only in size of domain
        
        Precision is accuracy
        
        Range is combination of range of fractions and exponents
        
        Types
        
        Float
        
        Standard size usually 4 bytes
        
        Double
        
        2x space of float
        
        Larger range
        
        Are signed and can have both negative and positive values
        
        Represented as fractions and exponents
        
        Smaller computers do not have hardware support but can emulate with software, albeit slower
        
        Same operations as integer
        
        Numbers are rarely equal due to round-off
        
        Boolean operations are restricted
        
        Representation
        
        Real world
        
        Real numbers
        
        Computer
        
        Exponent & mantissa
        
        IEEE floating point standard 754
        
        Issues
        
        Loss of accuracy
        
        Only approximation
        
        Stored in binary
      - Complex
        
        Descriptors
        
        Used for type checking and building code
        
        Used by run-time system if dynamic
        
        Collection of attributes of variables
        
        Required only at compile time if static
        
        Certain languages support
        
        Allows arithmetic
        
        Represented as ordered pairs of floating point
        
        Explicitly specified in python
        
        Symbol table
        
        Employed by language translator
        
        Information about
        
        Declaration or presence in source code
        
        Type
        
        Scope level
  - - - Concept of data abstraction
        
        Similar motivation to process abstraction
        
        Can declare variables even though type is hidden
        
        Unnecessary details of type can be hidden
        
        Includes subprograms that provide the operations for that type
        
        Includes only the data representation of one specific data type
      - Concept of process abstraction
        
        Not providing the details of how it performs its task
        
        Provide a way for a program to specify a process
      - About
        
        View/ representation of an entity
        
        Allows to collect instances of entities
        
        Common attributes need not be considered
      - Fundamental kinds
        
        Process abstraction
        
        Data abstraction
    - - Difference among languages exist
        
        Mechanisms provided
        
        Controlling operation sequence
        
        Storing data
        
        Type of operations available
        
        Type of data allowed
      - Mathematical model is called algebra
      - Set of values and set of operations defined on them
      - In data types
        
        Data sorted into sets
        
        Operations modeled by function
        
        Tests modelled by
        
        Relations on the sets
        
        Functions on the set
    - - Few languages that support data structures
        
        Fortran
        
        Linked list and binary tree implemented with arrays
        
        Cobol
        
        Allow programmers to specify accuracy
        
        Structured data type for information record
        
        Pl/I
        
        Accuracy specification for int and float
        
        Many data types with greater support
        
        Algol 68
        
        Few basic types
        
        Few flexible structure defining operators
  - - - Basic Operations
        
        can be simulated with integer but may have issues
        
        could be assigned any value
        
        rarely intended
        
        no type checking
        
        loops (depending on language)
        
        Successor and Predecessor
        
        Assignment
        
        Relational operations
      - constants implicitly start from 0,1 but can be reassigned
      - ordered list of distinct values
      - programmer defines both literal name
      - Design Issues related to type checking
      - Advantages
        
        Enhanced Readability
        
        No arithmetic operations
        
        Cannot be reassigned
      - Evaluation
        
        No benefit in C, but C++ slightly better
    - - Implementation
        
        Associating non negative int
        
        Range checking must be implicitly included by complier
      - All parent operations defined for subrange except value assignment
      - Not a new type
        
        Contiguous subsequence
      - Define new names
      - Inbuilt in some languages
  - - - Allow to specify preferred locations of data objects
      - Facilitates
        
        Static (dynamic) type checking.
        
        Selection of correct operations when overloaded.
        
        Storage management
        
        Size of the data block
        
        Allocation
        
        Lifetime
        
        Storage Representation
        
        Bit representation
        
        Attribute representation
        
        Preferred location
        
        Register
        
        Stack
        
        Heap
    - - Who provides the data
        
        Language provided
        
        Int
        
        Hardware provided
        
        Standard libraries
        
        Inbuilt
        
        Other developers
        
        Programmer constructed
        
        Functions and library routines
        
        In line code sequences
      - How they are manipulated in a program
        
        Elementary data objects
        
        Not defined in terms of other types
        
        Usually, an ordered set with min and max
        
        Always manipulates as a unit
        
        Values stored in fixed memory space
        
        Data structures
        
        Built with other data types
        
        Building blocks are components
        
        Data object aggregation
        
        Variable memory space for values