QUDT Schema for Datatypes - Version 3.1.2

qudt:AbstractDatatype

An "Abstract Datatype" (ADT) is a specification of a set of data and the set of operations that can be performed on the data. Such a data type is abstract in the sense that it is independent of various concrete implementations. The definition can be mathematical, or it can be programmed as an interface. A first class ADT supports the creation of multiple instances of the ADT, and the interface normally provides a constructor, which returns an abstract handle to new data, and several operations, which are functions accepting the abstract handle as an argument.

qudt:AerospaceCoordinateSystem

A sub-type of 'Coordinate system'. Detailed description to be provided in a future version.

qudt:AlgebraicDatatype

An "Algebraic Datatype" is a datatype each of whose values are data from other data types wrapped in one of the constructors of the data type. Any wrapped datum is an argument to the constructor. In contrast to other data types, the constructor is not executed and the only way to operate on the data is to unwrap the constructor using pattern matching.

The most common algebraic data type is a list with two constructors: Nil or [] for an empty list, and Cons (an abbreviation of constructor), ::, or : for the combination of a new element with a shorter list (for example (Cons 1 '(2 3 4)) or 1:[2,3,4]).

Special cases of algebraic types are product types i.e. records (only one constructor) and enumerated types (many constructors with no arguments). Algebraic types are one kind of composite type (i.e. a type formed by combining other types).

An algebraic data type may also be an abstract data type (ADT) if it is exported from a module without its constructors. Values of such a type can only be manipulated using functions defined in the same module as the type itself.

qudt:AlignmentType

Specifies how a physical data field is aligned. The alignment could be at a bit, byte or word boundary.

qudt:Array

An array is represented as ordered entries of values arranged according to the dimensions given. The dimensions are given as a list of integers where each integer is the cardinality of each dimension. The number of dimensions is specified in the attribute 'dimensionality'. Optionally a reference can be made to a variable, whose values are the array entries. The data type of the array entries is an optional field, 'elementType', which points to a data type definition. If the data type is given, then it applies to all elements. If it is not given then the elements can be of different types for each position in the array.

The property 'type:typeMatrix' must refer to a matrix of types. If a default value is given this can be used to place the appropriate value in a cell when an entry value is not known. If no dimensionality or dimension vector is specified the array is under-specified but still legitimate as a place-holder for a data type.

qudt:ArrayDataOrder

A sub-type of 'Enumerated Value'. Detailed description to be provided in a future version.

qudt:AssociativeArray

An Associative Array (or Map) is an abstract data type composed of a collection of keys and a collection of values, where each key is associated with one value. The operation of finding the value associated with a key is called a lookup or indexing, and this is the most important operation supported by an associative array. The relationship between a key and its value is sometimes called a mapping or binding.

qudt:AxialOrientationType

The axial orientation of a coordinate system frame axis.

qudt:BalancedTree

A Balanced Tree Type is a data type that defines the properties of data structures that represent balanced trees. A balanced tree is a tree where no leaf is much farther away from the root than any other leaf. Different balancing schemes allow different definitions of "much farther" and different amounts of work to keep them balanced.

qudt:BigIntegerType

A Big Integer is an integer that can be represented in eight octets (64 bits) of machine memory. Big integers may be signed or unsigned.

qudt:BinaryTree

A Binary Tree Type is a data type that defines the properties of data structures that represent binary trees. A binary tree is a tree in which each node has at most 2 children.

qudt:BitEncodingType

A bit encoding is a correspondence between the two possible values of a bit, 0 or 1, and some interpretation. For example, in a boolean encoding, a bit denotes a truth value, where 0 corresponds to False and 1 corresponds to True.

A Binary Tree Type is a data type that defines the properties of data structures that represent binary trees. A binary tree is a tree in which each node has at most 2 children.

qudt:BitField

A bit field is a common idiom used in computer programming to store a set of Boolean datatype flags compactly, as a series of bits. The bit field is stored in an integral type of known, fixed bit-width. Each Boolean flag is stored in a separate bit. Usually the source code will define a set of constants, each a power of two, that semantically associate each individual bit with its respective Boolean flag. The bitwise operators and, or, and not are used in combination to set, reset and test the flags.

qudt:BooleanEncodingType

qudt:BooleanType

A boolean data type can take on only two values.

qudt:BooleanTypeEnumeratedValue

Specifies how a boolean value is expressed

qudt:ByteEncodingType

This class contains the various ways that information may be encoded into bytes.

qudt:CartesianCoordinates

A set of variables which fix a geometric object. If the coordinates are distances measured along perpendicular axes, they are known as Cartesian coordinates.

qudt:CharEncodingType

The class of all character encoding schemes. Each defines a rule or algorithm for encoding character data as a sequence of bits or bytes.

qudt:CharacterType

A Character Type is a data type that defines the type and encoding of single characters.

qudt:Collection

A collection is a grouping of some variable number of zero or more data items that need to be operated upon together in some controlled fashion. Generally, the data items will all share the same data type or are derived from some common ancestor data type.

qudt:CompositeDatatype

Composite types are datatypes which can be constructed in a programming language out of that language's basic primitive types and other composite types. The act of constructing a composite type is known as composition.

qudt:CompositeTable

A sub-type of 'Table Type'. Detailed description to be provided in a future version.

qudt:CompositionFunction

qudt:CompositionTree

qudt:Concept

The root class for all QUDT concepts.

qudt:CoordinateCenterKind

An enumeration of coordinate centers for coordinate systems, such as: "Earth centered", "Mars centered", "Moon centered", "Sun centered", and "Vehicle centered".

qudt:CoordinateMember

A Coordinate Member Type is a data type that defines the properties of a coordinate in a coordinate system.

qudt:CoordinateSystem

In geometry, a coordinate system is a system which uses one or more numbers, or coordinates, to uniquely determine the position of a point or other geometric element on a manifold such as Euclidean space. The order of the coordinates is significant. They are sometimes identified by their position in an ordered tuple and sometimes by a letter, as in 'the x-coordinate'.

In elementary mathematics the coordinates are taken to be real numbers, but may be complex numbers or elements of a more abstract system such as a commutative ring. The use of a coordinate system allows problems in geometry to be translated into problems about numbers and vice versa; this is the basis of analytic geometry.

In astronomy, a celestial coordinate system is a system for specifying positions of celestial objects: satellites, planets, stars, galaxies, and so on. Coordinate systems can specify a position in 3-dimensional space, or merely the direction of the object on the celestial sphere, if its distance is not known or not important.

The coordinate systems are implemented in either spherical coordinates or rectangular coordinates. Spherical coordinates, projected on the celestial sphere, are analogous to the geographic coordinate system used on the surface of the Earth. These differ in their choice of fundamental plane, which divides the celestial sphere into two equal hemispheres along a great circle.

Rectangular coordinates, in appropriate units, are simply the cartesian equivalent of the spherical coordinates, with the same fundamental (x,y) plane and primary (x-axis) direction. Each coordinate system is named for its choice of fundamental plane.

qudt:Coordinates

A coordinate system is a mathematical structure for assigning a unique n-tuple of numbers or scalars to each point in an n-dimensional space. A Coordinate System Type is a data type that defines the properties of data structures that represent coordinate systems.

The primary attributes of any coordinate system are the coordinate frame or orientation of the axes of the coordinate system and the coordinate center or origin of the coordinate system. The coordinate center is the easier of the two attributes to define and in trajectory-related coordinate systems is often taken to be the center of mass of natural solar system bodies such as the Earth, the Moon, or Mars. Precise definition of the coordinate frame, however, usually takes much more effort. As a result, the primary purpose is to provide a detailed description of a number of different coordinate frames commonly used in mission analysis.

qudt:Coordinates-2D

A 2D coordinate system is a system for assigning a two-tuple of numbers or scalars to each point in an 2-dimensional space. A corresponding 2D Coordinate Type is a data type that defines the data type for each coordinate (tuple member) in a 2D coordinate system.

qudt:Coordinates-2D-DoublePrecision

A 2D coordinates in double floating point precision for locating a point in physical space.

qudt:Coordinates-2D-SinglePrecision

A 2D coordinates in single floating point precision for locating a point in physical space.

qudt:Coordinates-3D

A 3D coordinate system is a system for assigning a three-tuple of numbers or scalars to each point in an 3-dimensional space. A corresponding 3D Coordinate Type is a data type that defines the data type for each coordinate (tuple member) in a 3D coordinate system.

qudt:Coordinates-3D-DoublePrecision

A 3D coordinates in double floating point precision for locating a point in physical space.

qudt:Coordinates-3D-SinglePrecision

A 3D coordinates in single floating point precision for locating a point in physical space.

qudt:DateStringType

Date String Types are scalar data types that define the properties of strings that represent calendar dates.

qudt:DateTimeStringEncodingType

Date Time encodings are logical encodings for expressing date/time quantities as strings by applying unambiguous formatting and parsing rules.

qudt:DateTimeStringType

A class of data types for structures that represent temporal quantities. For example, calendar dates, times, duration of time since a given epoch, etc.

qudt:DimensionalDatatype

A dimensional data type is a data type that specifies a physical quantity or unit of measure. Information about the physical dimensions of the quantities and units is embedded in their types.

qudt:DiscreteState

qudt:DoublePrecisionType

A double precision data type specifies how a numeric value, such as an integer or real number, is stored in memory. Typically this occupies two words in computer memory, where the byte length of a word depends on machine address size of the computer processor. For example, on 32-bit machine architectures, a word is four bytes, and so double precision data value on a 32-bit machine architecture occupies eight bytes of memory.

qudt:EarthCoordinateSystem

A "Trajectory Coordinate System" for all earth-centered coordinates, such as:

• Earth mean equator and prime meridian coordinate system";
• Earth true equator and prime meridian of epoch coordinate system";
• International celestial reference system";
• International terrestrial reference system";
• Sun centered international celestial reference system";
• Vehicle centered international celestial reference system".

qudt:Encoding

An encoding is a rule or algorithm that is used to convert data from a native, or unspecified form into a specific form that satisfies the encoding rules. Examples of encodings include character encodings, such as UTF-8.

qudt:Enumeration

An enumeration is a set of literals from which a single value is selected. Each literal can have a tag as an integer within a standard encoding appropriate to the range of integer values. Consistency of enumeration types will allow them, and the enumerated values, to be referred to unambiguously either through symbolic name or encoding. Enumerated values are also controlled vocabularies and as such need to be standardized. Without this consistency enumeration literals can be stated differently and result in data conflicts and misinterpretations.

The tags are a set of positive whole numbers, not necessarily contiguous and having no numerical significance, each corresponding to the associated literal identifier. An order attribute can also be given on the enumeration elements. An enumeration can itself be a member of an enumeration. This allows enumerations to be enumerated in a selection. Enumerations are also subclasses of Scalar Datatype. This allows them to be used as the reference of a datatype specification.

qudt:FieldType

A sub-type of 'Composite Data Type'. Detailed description to be provided in a future version.

qudt:FileFormat

A sub-type of 'Enumerated Value'. Detailed description to be provided in a future version.

qudt:FixedIntervalTimeSeriesArray

A Fixed Interval Time Series Array Type is a data type that specifies the properties of arrays that hold time series data. For example, data that has been sampled over uniformly spaced time intervals. A time series is a sequence of data points, measured typically at successive times, spaced at uniform or non-uniform time intervals.

qudt:FloatingPointEncodingType

A type for specifying an "Encoding" with the following instance(s): "Double Precision Encoding", and "Single Precision Real Encoding".

qudt:FrameType

This class contains elements which specify the intertial type of a coordinate frame as either inertial, rotating, or non-rotating.

qudt:FunctionDatatype

A function data type defines the input and output data type for a function or method. The data type includes at least the function name and the number of its parameters. In some programming languages, it may also specify the function's return type or the types of its arguments.

qudt:GroundCoordinateSystem

A sub-type of 'Aerospace coordinate system'. Detailed description to be provided in a future version.

qudt:Heap

A heap is a specialized tree-based data structure that satisfies the condition: if B is a child node of A, then $key(A) \ge key(B)$. This implies that an element with the greatest key is always in the root node, and so such a heap is sometimes called a max heap. Alternatively, if the comparison is reversed, the smallest element is always in the root node, which results in a min heap. The function or method that implements the key() operator is specified by the heap type.

qudt:HexBinaryType

A string composed of hex characters.

qudt:InertialCoordinateFrame

A "Coordinate Frame".

qudt:InertialReferenceFrame

A sub-type of 'Reference Frame'. Detailed description to be provided in a future version.

qudt:IntegerDatatype

An Integer Type is a data type that specifies how integer numbers are represented and stored in machine memory.

qudt:IntegerEncodingType

The encoding scheme for integer types

qudt:IntegerVector

qudt:InterpolatedTable

A sub-type of 'Table Type'. Detailed description to be provided in a future version.

qudt:LargeObject

A 'LargeObject' datatype is used to store blocks of unstructured data (such as text, graphic images, video clips, and sound waveforms). They often are used to allow efficient, random, piece-wise access to the data.

qudt:List

A sub-type of 'Collection Type'. Detailed description to be provided in a future version.

qudt:LocalCoordinateSystem

A "Trajectory Coordinate System" with the following instance(s): "Local vertical curvilinear coordinate system", "Local vertical local horizontal coordinate system", "Vehicle centered local vertical curvilinear coordinate system".

qudt:LongIntegerType

A Long Integer is an integer that can be represented in four octets (32 bits) of machine memory. Long integers may be signed or unsigned.

qudt:LunarCoordinateSystem

Two slightly different coordinate frames are commonly used to define the orientation of the axes of a lunar body-fixed coordinate system: a mean Earth/rotation frame and a principal axis coordinate frame. The mean Earth/rotation frame (sometimes called the "Mean Earth/polar axis" frame) is a lunar body-fixed coordinate frame with the X-axis aligned with the mean direction from the Moon to the Earth and the Z-axis aligned with the mean axis of rotation of the Moon. The principal axis frame is a lunar body-fixed coordinate frame aligned with the principal axes of the Moon. Due to the fact that the Moon is synchronously rotating but is not exactly symmetric, the principal axes and the mean Earth/rotation axes of the Moon do not coincide.

qudt:MajorMinorType

A sub-type of 'Enumerated Value'. Detailed description to be provided in a future version.

qudt:Map

A Map Type is an abstract data type that defines the properties of map data structures. A Map (or Associative Array) is an abstract data structure composed of a collection of keys and a collection of values, where each key is associated with one value. The operation of finding the value associated with a key is called a lookup or indexing, and this is the most important operation supported by an associative array. The relationship between a key and its value is sometimes called a mapping or binding.

qudt:MarsCoordinateSystem

A "Trajectory Coordinate System" with the following instance(s): "Mars mean equator and IAU-Node of epoch", "Mars mean equator and prime meridian body-fixed".

qudt:MassPropertiesArray

A Mass Properties Array holds, for an object, four values for the properties: Center of Gravity, Mass, Moment of Inertia, and Product of Inertia.

qudt:MathsFunctionType

A sub-type of 'QUDT Concept'. Detailed description to be provided in a future version.

qudt:Matrix

A Matrix Type is a data type that specifies the properties of data structures that hold matricies.

qudt:MemoryOrderType

A sub-type of 'Enumerated Value'. Detailed description to be provided in a future version.

qudt:ModalEnumeration

A sub-type of 'QUDT Enumeration'. Detailed description to be provided in a future version.

qudt:MultiDimensionalArray

Ordinary or one-dimensional arrays are indexed by a single integer. For a multi-dimensional array, the index into the array uses an ordered list of integers, such as in a[3,1,5]. The length of the list of integers used to index into the multi-dimensional array is always the same and is referred to as the array's dimensionality. The bounds on each of these are called the array's dimensions.

qudt:MultiDimensionalDataFormat

Data formats for storing and manipulating scalar and multidimensional data in a platform and discipline independent manner, for example HDF, CDF and netCDF.

qudt:MultiModalEnumeration

A sub-type of 'QUDT Enumeration'. Detailed description to be provided in a future version.

qudt:MultiModalType

A sub-type of 'Enumerated Value'. Detailed description to be provided in a future version.

qudt:N-Tuple

A tuple containing n objects is known as an "n-tuple". For example the 4-tuple (or "quadruple"), with components of respective types: PERSON, DAY, MONTH and YEAR, could be used to record that a certain person was born on a certain day of a certain month of a certain year.

qudt:NonRotatingInertialFrame

The non-rotating (or "inertial") coordinate frames are defined by taking a "snapshot" of the orientation of a particular set of right-handed, orthogonal axes at a specific epoch or time. In other words, the non-rotating coordinate frame, however it is defined, is frozen or fixed at a specific time - for all time. These non-rotating coordinate frames are referred to as "of Epoch" coordinate frames.

qudt:NumericType

Numeric data types are data types whose values denote quantities as defined by a mathematical number system.

qudt:OctetType

An 8 bit unsigned integer

qudt:OnOffState

qudt:OrderedCollection

An Ordered Collection Type is an abstract data type that defines the properties of collection data structures whose members can be linearly ordered. An ordered collection is a collection together with an ordering relation (such as greater than) that linearly orders the collection elements.

qudt:OrderedTree

An "Ordered Tree Type" is a data type that defines the properties of data structures that represent ordered trees. An ordered tree is a tree where the children of every node are ordered, that is, there is a first child, second child, third child, etc. Typically a type specification for an ordered tree will include the comparison operator (such as lt or gt) that is used to order the nodes.

qudt:OrdinalType

An ordinal data type is a data type that specifies the properties of values that can easily be put in a one to one correspondence with a subset of the natural numbers. Examples include boolean, character, and integer data types.

qudt:PaddingType

This describes how unused bits of a field are filled. Unused bits could be set to one or zero. A third option is "don't care".

qudt:PhysicalAddress

A physical address is a pointer to a memory location.

qudt:PolarCoordinates

A set of variables which fix a geometric object. If the coordinates of a point P are determined by the distance from P to the origin and the angle subtended by the radial vector at P and a fixed axis, they are known as polar coordinates. Typically, the angle is measured with respect to the x-axis." ;

qudt:QuantityValueType

A sub-type of 'Dimensional Data Type'. Detailed description to be provided in a future version.

qudt:RealDatatype

A real number is represented as a factor, called the mantissa, multiplied by a power (the exponent) of a base. Different bases yield different approximations to real numbers, and conversion between them is limited in accuracy. Four floating-point types are defined in 'IEEE-754 Standard for Binary Floating-Point'. These types are 'single', 'extended single', 'double', and 'extended double'.

qudt:RealDoublePrecisionType

A real double precision data type specifies how a real number, or an approximation of a real number is stored in memory that occupies two words in computer memory, where the byte length of a word depends on machine address size of the computer processor. For example, on 32-bit machine architectures, a word is four bytes. An example of a real double precision data type specification is the IEEE 754 standard for encoding binary or decimal floating point numbers in 8 bytes for storage on 32-bit machine architectures.

qudt:RealSinglePrecisionType

A real single precision data type specifies how a real number, or an approximation of a real number is stored in memory that occupies one word in computer memory, where the byte length of a word depends on machine address size of the computer processor. For example, on 32-bit machine architectures, a word is four bytes. An example of a real single precisoin data type specification is the IEEE 754 standard for encoding binary or decimal floating point numbers in 4 bytes for storage on 32-bit machine architectures.

qudt:Record

A Record Type is a type whose values are records, i.e. aggregates of several items of possibly different types. The aggregated items are called fields or members and are usually identified or indexed by field labels.

qudt:ReferenceDatatype

A reference is an object containing information which refers to data stored elsewhere, as opposed to containing the data itself. A reference data type is a data type that specifies how a reference is represented and stored in memory, as well as the operations that can be performed on reference values. The most common example of a reference data type is a pointer.

qudt:ReferenceFrame

A reference frame (or frame of reference) in physics, may refer to a coordinate system or set of axes. The frame serves as the datum to measure the position, orientation, and other properties of objects in it. Reference frame may refer to an observational reference frame tied to the state of motion of an observer. Reference frame may also refer to both an observational reference frame and an attached coordinate system as a unit.

qudt:RotatingReferenceFrame

A sub-type of 'Reference Frame'. Detailed description to be provided in a future version.

qudt:Sequence

A "Structured Datatype".

qudt:Set

A Set Type is an abstract data type that defines the properties of sets. A set is a collection (container) of certain values, without any particular order, and no repeated values. It corresponds with a finite set in mathematics.

qudt:ShortIntegerType

A Short Integer is an integer that can be represented in two octets (16 bits) of machine memory. Short integers may be signed or unsigned.

qudt:SignedBigIntegerType

A Signed Big Integer is a signed integer that can be represented in eight octets (64 bits) of machine memory.

qudt:SignedIntegerType

Signed Integers are integers can take on both positive and negative values.

qudt:SignedLongIntegerType

A Signed Long Integer is a signed integer that can be represented in four octets (32 bits) of machine memory.

qudt:SignedMediumIntegerType

A "Signed Medium Integers" is an integer of 24 bits that can take on both positive and negative values.

qudt:SignedShortIntegerType

A Signed Short Integer is a signed integer that can be represented in four octets (32 bits) of machine memory.

qudt:SignedType

A signed type is a numeric type that distinguishes between positive and negative numbers using an encoding scheme, such as sign and magnitude, one's compliment, and two's compliment to represent negative numbers.

qudt:SignedVariableLengthIntegerType

A Signed Variable Length Integer data type defines a data structure for representing signed integers that uses a variable number of bits depending on the magnitude of the integer. Typically, variable length integer data types are between one and 64 bits in length.

qudt:SinglePrecisionType

A single precision data type specifies how a numeric value, such as an integer or real number, is stored in memory that occupies one word in computer memory, where the byte length of a word depends on machine address size of the computer processor. For example, on 32-bit machine architectures, a word is four bytes, and so a single precision data value on a 32-bit machine architecture occupies four bytes of memory.

qudt:SplineCalibrator

A sub-type of 'Map Type'. Detailed description to be provided in a future version.

qudt:SplinePoint

A sub-type of 'Tuple Type'. Detailed description to be provided in a future version.

qudt:StateSpaceMatrix

In control engineering, a state space representation is a mathematical model of a physical system as a set of input, output and state variables related by first-order differential equations. To abstract from the number of inputs, outputs and states, the variables are expressed as vectors and the differential and algebraic equations are written in matrix form (the last one can be done when the dynamical system is linear and time invariant).

qudt:StateSpaceVector

A state vector in general control systems describes the observed states of an object in state space, e.g. in variables of the degrees of freedom for motion. As data types, state vector types are used to specify the structure of state vectors, such as how the observed state is encoded.

qudt:StringEncodingType

An "Encoding" with the following instance(s): "qudt:UTF8-StringEncoding", qudt:UTF16-StringEncoding".

qudt:StringType

A String Type is a data type that specifies the properties of data structures that hold strings.

qudt:StringUTF16

String UTF-16 Type is a string data type that specifies the properties of string data structures which encode strings using the UTF-16 encoding. UTF-16 is the native internal representation of text in the Microsoft Windows NT/Windows 2000/Windows XP/Windows CE, Qualcomm BREW, and Symbian operating systems; the Java and .NET byte code environments; Mac OS X's Cocoa and Core Foundation frameworks; and the Qt cross-platform graphical widget toolkit.

qudt:StringUTF8

String UTF-8 Type is a string data type that specifies the properties of string data structures which encode strings using the UTF-8 encoding. UTF-8 includes ASCII, otherwise referred to as IA-5 (International Alphabet 5, as standardized by International Organization for Standardization [ISO]) as the first 128 values. The Internet Engineering Task Force (IETF) requires all Internet protocols to identify the encoding used for character data with UTF-8 as at least one supported encoding. The Internet Mail Consortium (IMC) recommends that all e-mail programs must be able to display and create mail using UTF-8.

qudt:Table

A Table Type is a data type that specifies the properties of table data structures. A table is both a mode of visual communication and a means of arranging data. The use of tables is pervasive throughout NASA The precise conventions and terminology for describing tables varies depending on the context. Moreover, tables differ significantly in variety, structure, flexibility, notation, representation and use.

qudt:TaggedEnumeration

An enumeration where each literal has a tag that is a non-negative integer. These enumerations are likely to have their literals encoded - hence the need for the tag.

qudt:TextStringType

A text string. Encodings can be specified as subclass or in connection to character arrays in Structured Datatypes.

qudt:ThreeBodyRotatingCoordinateSystem

The lunar coordinate systems are primarily used when operating in close proximity to the Moon. There are, however, a few additional coordinate systems that are also useful when analyzing (and depicting) trajectories in the vicinity of the Earth-Moon system. They are rotating coordinate systems associated with two different three-body systems: the Sun-Earth-spacecraft system and the Earth-Moon-spacecraft system. The Sun-Earth and Earth-Moon rotating coordinate frames are defined as follows. The pole vector or Z-axis of the coordinate frame is set equal to the instantaneous orbit normal of the secondary (smaller) body about the primary (larger) body and the X-axis is set equal to the vector from the primary body center of mass (CM) to the secondary body CM. The X-axis rotates at a rate equal to the instantaneous rotation rate of the secondary body about the primary body.

qudt:ThreeTuple

A three-tuple is a tuple with exactly three members. A Three-Tuple Type is a data type that defines the type properties of a class of three-tuples and their members.

qudt:TimeDataType

A sub-type of 'QUDT Enumeration'. Detailed description to be provided in a future version.

qudt:TimeSeriesArray

A Time Series Array Type is a data type that specifies the properties of arrays that hold time series data. A time series is a sequence of data points, measured at successive time intervals. The time intervals may be uniformly or non-uniformly spaced.

qudt:TimeStringType

Time takes a number of forms, depending on the units used (e.g., year, day, minute, millisecond, or combinations thereof) and the origin (i.e., time zero) to which the time value is related.

qudt:TrajectoryCoordinateSystem

A "Coordinate System".

qudt:Tree

A "Tree" is a data type that defines the properties of data structures that represent trees. A tree is a graph data structure accessed beginning at the root node. Each node is either a leaf or an internal node. An internal node has one or more child nodes and is called the parent of its child nodes. Leaf nodes have no chidren. Nodes that share the same parent are siblings. In graph theoretic terminology, a tree is a connected, undirected, acyclic graph.

qudt:Triplet

A "Tuple".

qudt:Tuple

The term Tuple originated as an abstraction of the sequence: single, double, triple, quadruple, quintuple, n-tuple. In mathematics, a tuple is a finite sequence (also known as an Ordered List of objects, each of a specified type. The n can be any non-negative integer.

qudt:TwoTuple

A 2-tuple is called a pair. For example, a complex number can be represented as a 2-tuple. 2D coordinates are sometimes represented as 2-tuples.

qudt:TypeList

A sub-type of 'QUDT Datatype'. Detailed description to be provided in a future version.

qudt:TypeVector

A Type Vector is a vector whose elements are data types. They are used to specify the type of each component of a vector or class of vectors.

qudt:UnsignedBigIntegerType

An Unsgned Big Integer is an unsigned integer that can be represented in eight octets (64 bits) of machine memory.

qudt:UnsignedIntegerType

Unsgned Integers are integers that are either strictly non-negative or non-positive.

qudt:UnsignedLongIntegerType

An Unsigned Long Integer is an unsigned integer that can be represented in four octets (32 bits) of machine memory.

qudt:UnsignedMediumIntegerType

An "Unsigned Medium Integers" is an integer of 24 bits that only takes on both positive values.

qudt:UnsignedShortIntegerType

An Unsigned Short Integer is an unsigned integer that can be represented in four octets (32 bits) of machine memory.

qudt:UnsignedType

An unsigned data type is a numeric type that does not distinguish between positive and negative values.

qudt:UnsignedVariableLengthIntegerType

An Unsigned Variable Length Integer data type defines a data structure for representing unsigned integers that uses a variable number of bits depending on the magnitude of the integer. Typically, variable length integer data types are between one and 64 bits in length.

qudt:VariableIntervalTimeSeriesArray

A Variable Interval Time Series Array Type is a data type that specifies the properties of arrays that hold time series data that has been sampled over non-uniformly spaced time intervals. A time series is a sequence of data points, measured typically at successive times, spaced at uniform or non-uniform time intervals. For variable interval time series, the successive time intervals may follow a repeating pattern, or may be completely random.

qudt:VariableLengthIntegerType

A Variable Length Integer data type defines a data structure for representing integers that uses a variable number of bits depending on the magnitude of the integer. Typically, variable length integer data types are between one and 64 bits in length.

qudt:Vector

A Vector Type is a data type that specifies the properties of data structures that hold vectors.

qudt:VehicleCoordinateSystem

A sub-type of 'Aerospace coordinate system'. Detailed description to be provided in a future version.

qudt:VisualCue

qudt:WetDryState

qudt:YesNoType

dcterms:description

qudt:abbreviation

An abbreviation for a unit is a short ASCII string that is used in place of the full name for the unit in contexts where non-ASCII characters would be problematic, or where using the abbreviation will enhance readability. When a power of abase unit needs to be expressed, such as squares this can be done using abbreviations rather than symbols. For example, sq ft means square foot, and cu ft means cubic foot.

qudt:accuracy

Accuracy is the degree to which a given quantity is correct and free from error. For example, a quantity specified as 100+/-1 has an (absolute) accuracy of +/-1 (meaning its true value can fall in the range 99-101). While a quantity specified as 100+/-2% has a (relative) accuracy of +/-2% (meaning its true value can fall in the range 98-102). The concepts of accuracy and precision are both closely related and often confused. While the accuracy of a number x is given by the number of significant decimal (or other) digits to the right of the decimal point in x, the precision of x is the total number of significant decimal (or other) digits.

qudt:alignment

qudt:allowedPattern

This property relates a date string encoding (c.f. type:DateStringEncodingType) to one or more XML Schema compliant regular expressions that together determine the allowed lexical expressions that can be unambiguously parsed to determine a temporal quantity.

qudt:ansiSQLName

qudt:arg1Type

This property relates a funciton data type with the type of its arg1.

qudt:arg2Type

This property relates a funciton data type with the type of its arg2.

qudt:arg3Type

This property relates a funciton data type with the type of its arg3.

qudt:argType

This property relates a function data type with the type of one of its arguments.

qudt:auralCue

qudt:base

qudt:basis

qudt:bitOrder

qudt:bits

qudt:bounded

A datatype is bounded if its value space has either a finite upper and lower bound. Either bound may be inclusive or exclusive.

qudt:byteOrder

Byte order is an enumeration of two values: 'Big Endian' and 'Little Endian' and is used to denote whether the most signiticant byte is either first or last, respectively.

qudt:bytes

qudt:cName

Datatype name in the C programming language

qudt:cardinality

qudt:columns

qudt:coordinateCenter

qudt:coordinateSystem

qudt:coordinateSystemFrame

qudt:dataOrder

qudt:datatype

This property is used to relate a structured data type with the data type the structured type's elements. It is used for structured data types with elements that are all of the same type.

qudt:defaultValue

qudt:dimensionality

The number of dimensions making up a matrix or an array. For example a 4 by 4 array has a dimensionality of 2. Whereas a vector or a string has a dimensionality of 1.

qudt:dimensions

The number of elements for each dimension of an array, vector, or matrix.

qudt:elementKind

This property is used to describe the quantity kind for a dimensional data type.

qudt:elementLabel

This property is used to label the field of a composite data structure.

qudt:elementName

qudt:elementTypeCount

This property determines the allowed number of element types that a structured data type may have.

qudt:elementTypeList

This property is used to relate a structured data type with a list of data types. The list members determine the types of structured type's elements. It is used for structured data types with elements that are of different types.

qudt:elementUnit

qudt:encodedValue

qudt:encoding

qudt:enumeration

qudt:exponent

This property relates a factor unit its exponent

qudt:field

qudt:fieldLabels

This property is used to list the field labels for a record type.

qudt:fieldName

qudt:float_X

qudt:float_Y

qudt:float_Z

qudt:frameType

qudt:functionArity

This property is used to state the number of arguments for a function type.

qudt:id

The "qudt:id" is an identifier string that uniquely identifies a QUDT concept. The identifier is constructed using a prefix. For example, units are coded using the pattern: "UCCCENNNN", where "CCC" is a numeric code or a category and "NNNN" is a digit string for a member element of that category. For scaled units there may be an addition field that has the format "QNN" where "NN" is a digit string representing an exponent power, and "Q" is a qualifier that indicates with the code "P" that the power is a positive decimal exponent, or the code "N" for a negative decimal exponent, or the code "B" for binary positive exponents.

qudt:inverted

qudt:isByteString

qudt:javaName

qudt:jsName

qudt:length

The length of a structure, for example the size of a vector

qudt:lowerBound

qudt:matlabName

qudt:maxBits

qudt:maxDepth

qudt:maxExclusive

maxExclusive is the exclusive upper bound of the value space for a datatype with the ordered property. The value of maxExclusive must be in the value space of the base type or be equal to {value} in {base type definition}.

qudt:maxExponent

qudt:maxInclusive

maxInclusive is the inclusive upper bound of the value space for a datatype with the ordered property. The value of maxInclusive must be in the value space of the base type.

qudt:maxLength

qudt:maxMantissa

The maximium mantissa is the largest integer that may appear as a coefficient in a finite precision representation of a real number. For a given numeric data type, the value of maxMantissa} (M) and the values of base (b) and precision (p) are related by the formula: M = b - 1.

qudt:microsoftSQLServerName

qudt:minBits

qudt:minExclusive

minExclusive is the exclusive lower bound of the value space for a datatype with the ordered property. The value of minExclusive must be in the value space of the base type or be equal to {value} in {base type definition}.

qudt:minInclusive

minInclusive is the inclusive lower bound of the value space for a datatype with the ordered property. The value of minInclusive must be in the value space of the base type.

qudt:minLength

qudt:minMantissa

The minimium mantissa is the negative integer with the greatest magnitude that may appear as a coefficient in a finite precision representation of a real number. For a given numeric data type, the value of minMantissa (M) and the values of base (b) and precision (p) are related by the formula:

M = -(b^p - 1).

qudt:minValue

qudt:modalCue

qudt:modalCueEnumeration

qudt:modifiability

Reference to one in a list of enumerated elements that indicates whether data (e.g. variable or parameter) can be changed.

qudt:mySQLName

qudt:odbcName

qudt:oleDBName

OLE DB (Object Linking and Embedding, Database, sometimes written as OLEDB or OLE-DB), an API designed by Microsoft, allows accessing data from a variety of sources in a uniform manner. The API provides a set of interfaces implemented using the Component Object Model (COM); it is otherwise unrelated to OLE.

qudt:optional

qudt:oracleSQLName

qudt:orderInStructure

qudt:orderedType

qudt:orderingRelation

This property identifies the mathematical comparison operator (such as "<" or ">") that is used to order the elements of a collection.

qudt:originDefinition

qudt:padding

qudt:pattern

A pattern is a constraint on the value space of a datatype which is achieved by constraining the lexical space to literals which match a specific pattern. The value of pattern must be a regular expression.

qudt:pitchRotationDefinition

qudt:precision

Precision is the number of digits used to perform a given computation. The concepts of accuracy and precision are both closely related and often confused. While the accuracy of a number x is given by the number of significant decimal (or other) digits to the right of the decimal point in x, the precision of x is the total number of significant decimal (or other) digits. For a given numeric data type, the value of type:precision (?p) is related to the values of type:maxMantissa (?M) and type:base (?b) by the formula ?p := log(?b, ?M) where log(a,y) = x iff y=a^x.

qudt:protocolBuffersName

qudt:pythonName

qudt:rdfsDatatype

qudt:realization

qudt:referenceFrame

qudt:referenceFrameType

qudt:returnType

This property is used to state the return type of a function type.

qudt:rollRotationDefinition

qudt:rotationDefinition

qudt:rows

qudt:signedness

qudt:significantDigits

qudt:typeMatrix

qudt:typeVector

qudt:upperBound

qudt:valueType

qudt:vbName

qudt:xAxisDefinition

The definition of the X-Axis could be an intersection, cross-product or other function of a meridian or orbit. It could also mention any aspects of rotation, for example, the rotation equator of the Earth, Sun, Moon or other celestial body. An epoch might also be given.

qudt:xCoordinateDefinition

qudt:yAxisDefinition

The definition of the Y-Axis could be an intersection, cross-product or other function of a meridian or orbit. It could also mention any aspects of rotation, for example, the rotation equator of the Earth, Sun, Moon or other celestial body. An epoch might also be given.

qudt:yCoordinateDefinition

qudt:yawRotationDefinition

qudt:zAxisDefinition

The definition of the Y-Axis could be an intersection, croos-product or other function of a meridian or orbit. It could also mention any aspects of rotation, for example, the rotation equator of the Earth, Sun, Moon or other celestial body. An epoch might also be given.

qudt:zCoordinateDefinition

qudt:ByColumn

URI: http://qudt.org/schema/qudt/ByColumn

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/ByColumn>
  rdf:type <http://qudt.org/schema/qudt/ArrayDataOrder> ;
  <http://www.linkedmodel.org/schema/dtype#literal> "byColumn" ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:label "By Column" ;
.

{"resource":"By Column" 
 ,"qname":"qudt:ByColumn" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/ByColumn" 
 ,"properties":["isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"label":"By Column" 
    ,"literal":"byColumn" 
    ,"type":"qudt:ArrayDataOrder" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/ByColumn",
  "@type" : "http://qudt.org/schema/qudt/ArrayDataOrder",
  "literal" : "byColumn",
  "isDefinedBy" : "http://qudt.org/3.1.2/schema/datatype",
  "label" : "By Column",
  "@context" : {
    "literal" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#literal"
    },
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:ByLeftMostIndex

URI: http://qudt.org/schema/qudt/ByLeftMostIndex

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/ByLeftMostIndex>
  rdf:type <http://qudt.org/schema/qudt/ArrayDataOrder> ;
  <http://www.linkedmodel.org/schema/dtype#literal> "byLeftMostIndex" ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:label "By Left Most Index" ;
.

{"resource":"By Left Most Index" 
 ,"qname":"qudt:ByLeftMostIndex" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/ByLeftMostIndex" 
 ,"properties":["isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"label":"By Left Most Index" 
    ,"literal":"byLeftMostIndex" 
    ,"type":"qudt:ArrayDataOrder" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/ByLeftMostIndex",
  "@type" : "http://qudt.org/schema/qudt/ArrayDataOrder",
  "literal" : "byLeftMostIndex",
  "isDefinedBy" : "http://qudt.org/3.1.2/schema/datatype",
  "label" : "By Left Most Index",
  "@context" : {
    "literal" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#literal"
    },
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:ByRow

URI: http://qudt.org/schema/qudt/ByRow

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/ByRow>
  rdf:type <http://qudt.org/schema/qudt/ArrayDataOrder> ;
  <http://www.linkedmodel.org/schema/dtype#literal> "byRow" ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:label "By Row" ;
.

{"resource":"By Row" 
 ,"qname":"qudt:ByRow" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/ByRow" 
 ,"properties":["isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"label":"By Row" 
    ,"literal":"byRow" 
    ,"type":"qudt:ArrayDataOrder" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/ByRow",
  "@type" : "http://qudt.org/schema/qudt/ArrayDataOrder",
  "literal" : "byRow",
  "isDefinedBy" : "http://qudt.org/3.1.2/schema/datatype",
  "label" : "By Row",
  "@context" : {
    "literal" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#literal"
    },
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:FALSE

URI: http://qudt.org/schema/qudt/FALSE

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/FALSE>
  rdf:type <http://qudt.org/schema/qudt/BooleanTypeEnumeratedValue> ;
  <http://www.linkedmodel.org/schema/dtype#literal> "false" ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:label "False" ;
.

{"resource":"False" 
 ,"qname":"qudt:FALSE" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/FALSE" 
 ,"properties":["isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"label":"False" 
    ,"literal":"false" 
    ,"type":"qudt:BooleanTypeEnumeratedValue" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/FALSE",
  "@type" : "http://qudt.org/schema/qudt/BooleanTypeEnumeratedValue",
  "literal" : "false",
  "isDefinedBy" : "http://qudt.org/3.1.2/schema/datatype",
  "label" : "False",
  "@context" : {
    "literal" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#literal"
    },
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:NonModifiableParameter

URI: http://qudt.org/schema/qudt/NonModifiableParameter

Parameter is fixed, not modifiable.

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/NonModifiableParameter>
  rdf:type <http://qudt.org/schema/qudt/ParameterModifiabilityType> ;
  <http://purl.org/dc/terms/description> "Parameter is fixed, not modifiable." ;
  <http://www.linkedmodel.org/schema/dtype#code> "0" ;
  <http://www.linkedmodel.org/schema/dtype#literal> "fixed" ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:label "Non modifiable parameter" ;
.

{"resource":"Non modifiable parameter" 
 ,"qname":"qudt:NonModifiableParameter" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/NonModifiableParameter" 
 ,"properties":["code":"0" 
    ,"description":"Parameter is fixed, not modifiable." 
    ,"isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"label":"Non modifiable parameter" 
    ,"literal":"fixed" 
    ,"type":"qudt:ParameterModifiabilityType" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/NonModifiableParameter",
  "@type" : "http://qudt.org/schema/qudt/ParameterModifiabilityType",
  "description" : "Parameter is fixed, not modifiable.",
  "code" : "0",
  "literal" : "fixed",
  "isDefinedBy" : "http://qudt.org/3.1.2/schema/datatype",
  "label" : "Non modifiable parameter",
  "@context" : {
    "description" : {
      "@id" : "http://purl.org/dc/terms/description"
    },
    "code" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#code"
    },
    "literal" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#literal"
    },
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:OctetEncoding

URI: http://qudt.org/schema/qudt/OctetEncoding

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/OctetEncoding>
  rdf:type <http://qudt.org/schema/qudt/BooleanEncodingType> ;
  rdf:type <http://qudt.org/schema/qudt/ByteEncodingType> ;
  <http://qudt.org/schema/qudt/bytes> 1 ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/qudt> ;
  rdfs:label "OCTET Encoding" ;
.

{"resource":"OCTET Encoding" 
 ,"qname":"qudt:OctetEncoding" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/OctetEncoding" 
 ,"properties":["bytes":"1" 
    ,"isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/qudt>" 
    ,"label":"OCTET Encoding" 
    ,"type":"qudt:BooleanEncodingType" 
    ,"type":"qudt:ByteEncodingType" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/OctetEncoding",
  "@type" : [ "http://qudt.org/schema/qudt/BooleanEncodingType", "http://qudt.org/schema/qudt/ByteEncodingType" ],
  "http://qudt.org/schema/qudt/bytes" : 1,
  "isDefinedBy" : [ "http://qudt.org/3.1.2/schema/qudt", "http://qudt.org/3.1.2/schema/datatype" ],
  "label" : "OCTET Encoding",
  "@context" : {
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "bytes" : {
      "@id" : "http://qudt.org/schema/qudt/bytes",
      "@type" : "http://www.w3.org/2001/XMLSchema#integer"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:TRUE

URI: http://qudt.org/schema/qudt/TRUE

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/TRUE>
  rdf:type <http://qudt.org/schema/qudt/BooleanTypeEnumeratedValue> ;
  <http://www.linkedmodel.org/schema/dtype#literal> "true" ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:label "True" ;
.

{"resource":"True" 
 ,"qname":"qudt:TRUE" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/TRUE" 
 ,"properties":["isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"label":"True" 
    ,"literal":"true" 
    ,"type":"qudt:BooleanTypeEnumeratedValue" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/TRUE",
  "@type" : "http://qudt.org/schema/qudt/BooleanTypeEnumeratedValue",
  "literal" : "true",
  "isDefinedBy" : "http://qudt.org/3.1.2/schema/datatype",
  "label" : "True",
  "@context" : {
    "literal" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#literal"
    },
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:UTF16-StringEncoding

URI: http://qudt.org/schema/qudt/UTF16-StringEncoding

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/UTF16-StringEncoding>
  rdf:type <http://qudt.org/schema/qudt/StringEncodingType> ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:label "UTF-16 String" ;
.

{"resource":"UTF-16 String" 
 ,"qname":"qudt:UTF16-StringEncoding" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/UTF16-StringEncoding" 
 ,"properties":["isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"label":"UTF-16 String" 
    ,"type":"qudt:StringEncodingType" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/UTF16-StringEncoding",
  "@type" : "http://qudt.org/schema/qudt/StringEncodingType",
  "isDefinedBy" : "http://qudt.org/3.1.2/schema/datatype",
  "label" : "UTF-16 String",
  "@context" : {
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:WordAligned

URI: http://qudt.org/schema/qudt/WordAligned

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/WordAligned>
  rdf:type <http://qudt.org/schema/qudt/AlignmentType> ;
  <http://www.linkedmodel.org/schema/dtype#literal> "word" ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:label "Word Aligned" ;
.

{"resource":"Word Aligned" 
 ,"qname":"qudt:WordAligned" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/WordAligned" 
 ,"properties":["isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"label":"Word Aligned" 
    ,"literal":"word" 
    ,"type":"qudt:AlignmentType" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/WordAligned",
  "@type" : "http://qudt.org/schema/qudt/AlignmentType",
  "literal" : "word",
  "isDefinedBy" : "http://qudt.org/3.1.2/schema/datatype",
  "label" : "Word Aligned",
  "@context" : {
    "literal" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#literal"
    },
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:negative

URI: http://qudt.org/schema/qudt/negative

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/negative>
  rdf:type <http://qudt.org/schema/qudt/Polarity> ;
  <http://www.linkedmodel.org/schema/dtype#code> "1" ;
  <http://www.linkedmodel.org/schema/dtype#literal> "negative" ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:label "negative" ;
.

{"resource":"negative" 
 ,"qname":"qudt:negative" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/negative" 
 ,"properties":["code":"1" 
    ,"isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"label":"negative" 
    ,"literal":"negative" 
    ,"type":"qudt:Polarity" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/negative",
  "@type" : "http://qudt.org/schema/qudt/Polarity",
  "code" : "1",
  "literal" : "negative",
  "isDefinedBy" : "http://qudt.org/3.1.2/schema/datatype",
  "label" : "negative",
  "@context" : {
    "code" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#code"
    },
    "literal" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#literal"
    },
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:positive

URI: http://qudt.org/schema/qudt/positive

@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

<http://qudt.org/schema/qudt/positive>
  rdf:type <http://qudt.org/schema/qudt/Polarity> ;
  <http://www.linkedmodel.org/schema/dtype#code> "2" ;
  <http://www.linkedmodel.org/schema/dtype#literal> "positive" ;
  rdfs:isDefinedBy <http://qudt.org/3.1.2/schema/datatype> ;
  rdfs:label "positive" ;
.

{"resource":"positive" 
 ,"qname":"qudt:positive" 
 ,"uri":"http:\/\/qudt.org\/schema\/qudt\/positive" 
 ,"properties":["code":"2" 
    ,"isDefinedBy":"<http:\/\/qudt.org\/3.1.2\/schema\/datatype>" 
    ,"label":"positive" 
    ,"literal":"positive" 
    ,"type":"qudt:Polarity" 
    ]}

{
  "@id" : "http://qudt.org/schema/qudt/positive",
  "@type" : "http://qudt.org/schema/qudt/Polarity",
  "code" : "2",
  "literal" : "positive",
  "isDefinedBy" : "http://qudt.org/3.1.2/schema/datatype",
  "label" : "positive",
  "@context" : {
    "code" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#code"
    },
    "literal" : {
      "@id" : "http://www.linkedmodel.org/schema/dtype#literal"
    },
    "isDefinedBy" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
      "@type" : "@id"
    },
    "label" : {
      "@id" : "http://www.w3.org/2000/01/rdf-schema#label"
    },
    "rdf" : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "owl" : "http://www.w3.org/2002/07/owl#",
    "xsd" : "http://www.w3.org/2001/XMLSchema#",
    "rdfs" : "http://www.w3.org/2000/01/rdf-schema#"
  }
}

qudt:BitField

A bit field is a common idiom used in computer programming to store a set of Boolean datatype flags compactly, as a series of bits. The bit field is stored in an integral type of known, fixed bit-width. Each Boolean flag is stored in a separate bit. Usually the source code will define a set of constants, each a power of two, that semantically associate each individual bit with its respective Boolean flag. The bitwise operators and, or, and not are used in combination to set, reset and test the flags.

qudt:UTC-DayTime

xsd:pattern [0-9]{4}\\-[0-9]{3}T[0-9]{2}:[0-9]{2}:[0-9]{2}\\.[0-9]{2}Z?

qudt:hexbinary

xsd:dateTime

YYYY-MM-DDThh:mm:ss[.dd] or YYYY-DDDThh:mm:ss[.dd], where 'YYYY' is the year, 'MM' is the two-digit month, 'DD' is the two-digit day, 'DDD' is the three digit day of year, 'T' is constant, 'hh:mm:ss[.dd]' is the UTC time in hours, minutes, seconds, and optional fractional seconds. As many 'd' characters to the right of the period as required may be used to obtain the required precision. All fields require leading zeros.