virtual class unpacked_array #( type T = bit, int SIZE = 1 )
A parameterized class that manages an unpacked array.
| T | optional The type of an unpacked array. The default type is bit. |
| SIZE | optional The size of an unpacked array. The default is 1. |
| unpacked_array | A parameterized class that manages an unpacked array. |
| Common Arguments | |
| Types | |
| ua_type | The shorthand of the unpacked array type of type T. |
| da_type | The shorthand of the dynamic array type of type T. |
| q_type | The shorthand of the queue type of type T. |
| Functions | |
| from_dynamic_array | static Converts a dynamic array of type T to un unpacked array of the same type. |
| to_dynamic_array | static Converts an unpacked array of type T to a dynamic array of the same type. |
| from_queue | static Converts a queue of type T to an unpacked array of the same type. |
| to_queue | static Converts an unpacked array of type T to a queue of the same type. |
| da_to_ua | static Converts a dynamic array of type T to an unpacked array of the same type. |
| ua_to_da | static Converts an unpacked array of type T to a dynamic array of the same type. |
| q_to_ua | static Converts a queue of type T to an unpacked array of the same type. |
| ua_to_q | static Converts an unpacked array of type T to a queue of the same type. |
| init | static Initializes the each element of the given unpacked array to the specified value. |
| reverse | static Reverses the order of the elements of the given unpacked array. |
| compare | static Compares two unpacked arrays. |
| to_string | static Converts an unpacked array to the form of a string. |
| from_index | The index of the first element of an unpacked array to be processed. If negative, the index counts from the last. For example, if from_index is -9, a function starts at the ninth element (inclusive) from the last. The default is 0 (starts at the first element). |
| to_index | The index of the last element of an unpacked array to be processed. If negative, the index counts from the last. For example, if to_index is -3, a function ends at the third element (inclusive) from the last. The default is -1 (ends at the last element). |
static function ua_type from_dynamic_array( const ref da_type da, input bit reverse = 0 )
static Converts a dynamic array of type T to un unpacked array of the same type. If the size of the dynamic array is larger than SIZE, the excess elements are ignored. If the size of the dynamic array is smaller than SIZE, the default value of type T is used for the missing elements.
| da | A dynamic array to be converted. |
| reverse | optional If 0, the element at the index 0 of da is positioned to the index 0 of the unpacked array. If 1, the elements are positioned in the reverse order. The default is 0. |
An unpacked array converted from da.
bit da[] = new[8]( '{ 0, 0, 0, 1, 1, 0, 1, 1 } ); // da[0] to da[7]
bit ua0[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 };
bit ua1[8] = '{ 1, 1, 0, 1, 1, 0, 0, 0 };
assert( unpacked_array#(bit,8)::from_dynamic_array( da ) == ua0 );
assert( unpacked_array#(bit,8)::from_dynamic_array( da, .reverse( 1 ) ) == ua1 );
static function da_type to_dynamic_array( const ref ua_type ua, input bit reverse = 0 )
static Converts an unpacked array of type T to a dynamic array of the same type.
| ua | A unpacked array to be converted. |
| reverse | optional If 0, the element at the index 0 of ua is positioned to the index 0 of the dynamic array. If 1, the elements are positioned in the reverse order. The default is 0. |
A dynamic array converted from ua.
bit ua[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 }; // assigned to ua[0:7]
bit da0[] = new[8]( '{ 0, 0, 0, 1, 1, 0, 1, 1 } );
bit da1[] = new[8]( '{ 1, 1, 0, 1, 1, 0, 0, 0 } );
assert( unpacked_array#(bit,8)::to_dynamic_array( ua ) == da0 );
assert( unpacked_array#(bit,8)::to_dynamic_array( ua, .reverse( 1 ) ) == da1 );
static function ua_type from_queue( const ref q_type q, input bit reverse = 0 )
static Converts a queue of type T to an unpacked array of the same type. If the size of the queue is larger than SIZE, the excess elements are ignored. If the size of the queue is smaller than SIZE, the default valus of type T is used for the missing elements.
| q | A queue to be converted. |
| reverse | optional If 0, the element at the index 0 of q is positioned to the index 0 of the unpacked array. If 1, the elements are positioned in the reverse order. The default is 0. |
An unpacked array converted from q.
bit q[$] = { 0, 0, 0, 1, 1, 0, 1, 1 }; // q[0] to q[7]
bit ua0[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 };
bit ua1[8] = '{ 1, 1, 0, 1, 1, 0, 0, 0 };
assert( unpacked_array#(bit,8)::from_queue( q ) == ua0 );
assert( unpacked_array#(bit,8)::from_queue( q, .reverse( 1 ) ) == ua1 );
static function q_type to_queue( const ref ua_type ua, input bit reverse = 0 )
static Converts an unpacked array of type T to a queue of the same type.
| ua | An unpacked array to be converted. |
| reverse | optional If 0, the element at the index 0 of ua is positioned to the index 0 of the queue. If 1, the elements are positioned in the reverse order. The default is 0. |
A queue converted from ua.
bit ua[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 }; // assigned to ua[0:7]
bit q0[$] = { 0, 0, 0, 1, 1, 0, 1, 1 };
bit q1[$] = { 1, 1, 0, 1, 1, 0, 0, 0 };
assert( unpacked_array#(bit,8)::to_queue( ua ) == q0 );
assert( unpacked_array#(bit,8)::to_queue( ua, .reverse( 1 ) ) == q1 );
static function void da_to_ua( const ref da_type da, ref ua_type ua, input bit reverse = 0 )
static Converts a dynamic array of type T to an unpacked array of the same type. Unlike from_dynamic_array, this function populates the unpacked array passed by reference, instead of returning a new unpacked array. If the size of the dynamic array is larger than SIZE, the excess elements are ignored. If the size of the dynamic array is smaller than SIZE, the default value of type T is used for the missing elements.
| da | A dynamic array to be converted. |
| ua | An unpacked array to be populated. |
| reverse | optional If 0, the element at the index 0 of da is positioned to the index 0 of ua. If 1, the elements are positioned in the reverse order. The default is 0. |
None.
bit da[] = new[8]( '{ 0, 0, 0, 1, 1, 0, 1, 1 } ); // da[0] to da[7]
bit ua[8];
bit ua0[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 };
bit ua1[8] = '{ 1, 1, 0, 1, 1, 0, 0, 0 };
unpacked_array#(bit,8)::da_to_ua( da, ua );
assert( ua == ua0 );
unpacked_array#(bit,8)::da_to_ua( da, ua, .reverse( 1 ) );
assert( ua == ua1 );
static function void ua_to_da( const ref ua_type ua, ref da_type da, input bit reverse = 0 )
static Converts an unpacked array of type T to a dynamic array of the same type. Unlike to_dynamic_array, this function populates the dynamic array passed by reference, instead of returning a new dynamic array.
| ua | An unpacked array to be converted. |
| da | A dynamic array to be populated. This function does not resize da. Make sure to set the size of the dynamic array to accommodate the elements of ua before calling this function. |
| reverse | optional If 0, the element at the index 0 of ua is positioned to the index 0 of da. If 1, the elements are positioned in the reverse order. The default is 0. |
None.
bit ua[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 }; // assigned to ua[0:7]
bit da [] = new[8]; // set the size of da[]
bit da0[] = new[8]( '{ 0, 0, 0, 1, 1, 0, 1, 1 } );
bit da1[] = new[8]( '{ 1, 1, 0, 1, 1, 0, 0, 0 } );
unpacked_array#(bit,8)::ua_to_da( ua, da );
assert( da == da0 );
unpacked_array#(bit,8)::ua_to_da( ua, da, .reverse( 1 ) );
assert( da == da1 );
static function void q_to_ua( const ref q_type q, ref ua_type ua, input bit reverse = 0 )
static Converts a queue of type T to an unpacked array of the same type. Unlike from_queue, this function populates the unpacked array passed by reference, instead of returning a new unpacked array. If the size of the queue is larger than SIZE, the excess elements are ignored. If the size of the queue is smaller than SIZE, the default valus of type T is used for the missing elements.
| q | A queue to be converted. |
| ua | An unpacked array to be populated. |
| reverse | optional If 0, the element at the index 0 of q is positioned to the index 0 of ua. If 1, the elements are positioned in the reverse order. The default is 0. |
None.
bit q[$] = { 0, 0, 0, 1, 1, 0, 1, 1 }; // q[0] to q[7]
bit ua [8];
bit ua0[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 };
bit ua1[8] = '{ 1, 1, 0, 1, 1, 0, 0, 0 };
unpacked_array#(bit,8)::q_to_ua( q, ua );
assert( ua == ua0 );
unpacked_array#(bit,8)::q_to_ua( q, ua, .reverse( 1 ) );
assert( ua == ua1 );
static function void ua_to_q( const ref ua_type ua, ref q_type q, input bit reverse = 0 )
static Converts an unpacked array of type T to a queue of the same type. Unlike to_queue, this function populates the queue passed by reference instead of returning a new queue.
| ua | An unpacked array to be converted. |
| q | A queue to be populated. |
| reverse | optional If 0, the element at the index 0 of ua is positioned to the index 0 of q. If 1, the elements are positioned in the reverse order. The default is 0. |
None.
bit ua[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 }; // assigned to ua[0:7]
bit q [$];
bit q0[$] = { 0, 0, 0, 1, 1, 0, 1, 1 };
bit q1[$] = { 1, 1, 0, 1, 1, 0, 0, 0 };
unpacked_array#(bit,8)::ua_to_q( ua, q );
assert( q == q0 );
q.delete();
unpacked_array#(bit,8)::ua_to_q( ua, q, .reverse( 1 ) );
assert( q == q1 );
static function void init( ref ua_type ua, input T val )
static Initializes the each element of the given unpacked array to the specified value.
| ua | An unpacked array to be initialized. |
| val | A value to initialize the elements of ua. |
None.
bit ua[8];
bit expected[8] = '{ 1, 1, 1, 1, 1, 1, 1, 1 };
unpacked_array#(bit,8)::init( ua, 1'b1 );
assert( ua == expected );
static function void reverse( ref ua_type ua )
static Reverses the order of the elements of the given unpacked array.
| ua | An unpacked array to be reversed. |
None.
bit ua[8] = '{ 0, 0, 0, 0, 1, 1, 1, 1 };
bit expected[8] = '{ 1, 1, 1, 1, 0, 0, 0, 0 };
unpacked_array#(bit,8)::reverse( ua );
assert( ua == expected );
static function bit compare( const ref ua_type ua1, const ref ua_type ua2, input int from_index1 = 0, int to_index1 = -1, int from_index2 = 0, int to_index2 = -1, comparator#(T) cmp = null )
static Compares two unpacked arrays.
| ua1 | An unpacked array. |
| ua2 | Another unpacked array to compare with ua1. |
| from_index1 | optional The index of the first element of ua1 to compare. See Common Arguments. The default is 0. |
| to_index1 | optional The index of the last element of ua1 to compare. See Common Arguments. The default is -1. |
| from_index2 | optional The index of the first element of ua2 to compare. See Common Arguments. The default is 0. |
| to_index2 | optional The index of the last element of ua2 to compare. See Common Arguments. The default is -1. |
| cmp | optional A strategy object used to compare two unpacked arrays. If not specified or null, comparator #(T) is used. The default is null. |
If the numbers of elements to compare (to_index1-from_index1+1 and to_index2-from_index2+1) are different, 0 is returned. If the two unpacked arrays contain the same data in the specified range, 1 is returned. Otherwise, 0 is returned.
bit ua1[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 };
bit ua2[8] = '{ 1, 1, 0, 1, 1, 0, 0, 0 };
// |<------>|
// 2 5
assert( unpacked_array#(bit,8)::compare( ua1, ua2 ) == 0 );
assert( unpacked_array#(bit,8)::compare( ua1, ua2,
.from_index1( 2 ), .to_index1( 5 ),
.from_index2( 2 ), .to_index2( 5 ) ) == 1 );
static function string to_string( const ref ua_type ua, input string separator = " ", int from_index = 0, int to_index = -1, formatter#(T) fmtr = null )
static Converts an unpacked array to the form of a string.
| ua | An unpacked array to be converted. |
| separator | optional A string to separate each element of ua. The default is a space (“ “). |
| from_index | optional The index of the first element of ua to convert. See Common Arguments. The default is 0. |
| to_index | optional The index of the last element of ua to convert. See Common Arguments. The default is -1. |
| fmtr | optional A strategy object used to format ua. If not specified or null, hex_formatter #(T) is used. The default is null. |
A string to represent ua.
bit ua[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 }; // assigned to ua[0:7]
assert( unpacked_array#(bit,8)::to_string( ua ) == "0 0 0 1 1 0 1 1" );
assert( unpacked_array#(bit,8)::to_string( ua, .separator( "-" ) ) == "0-0-0-1-1-0-1-1" );
assert( unpacked_array#(bit,8)::to_string( ua, .from_index( 4 ) ) == "1 0 1 1" );A parameterized class that manages an unpacked array.
virtual class unpacked_array #( type T = bit, int SIZE = 1 )
The shorthand of the unpacked array type of type T.
typedef T ua_type[SIZE]
The shorthand of the dynamic array type of type T.
typedef T da_type[]
The shorthand of the queue type of type T.
typedef T q_type[$]
static Converts a dynamic array of type T to un unpacked array of the same type.
static function ua_type from_dynamic_array( const ref da_type da, input bit reverse = 0 )
static Converts an unpacked array of type T to a dynamic array of the same type.
static function da_type to_dynamic_array( const ref ua_type ua, input bit reverse = 0 )
static Converts a queue of type T to an unpacked array of the same type.
static function ua_type from_queue( const ref q_type q, input bit reverse = 0 )
static Converts an unpacked array of type T to a queue of the same type.
static function q_type to_queue( const ref ua_type ua, input bit reverse = 0 )
static Converts a dynamic array of type T to an unpacked array of the same type.
static function void da_to_ua( const ref da_type da, ref ua_type ua, input bit reverse = 0 )
static Converts an unpacked array of type T to a dynamic array of the same type.
static function void ua_to_da( const ref ua_type ua, ref da_type da, input bit reverse = 0 )
static Converts a queue of type T to an unpacked array of the same type.
static function void q_to_ua( const ref q_type q, ref ua_type ua, input bit reverse = 0 )
static Converts an unpacked array of type T to a queue of the same type.
static function void ua_to_q( const ref ua_type ua, ref q_type q, input bit reverse = 0 )
static Initializes the each element of the given unpacked array to the specified value.
static function void init( ref ua_type ua, input T val )
static Reverses the order of the elements of the given unpacked array.
static function void reverse( ref ua_type ua )
static Compares two unpacked arrays.
static function bit compare( const ref ua_type ua1, const ref ua_type ua2, input int from_index1 = 0, int to_index1 = -1, int from_index2 = 0, int to_index2 = -1, comparator#(T) cmp = null )
static Converts an unpacked array to the form of a string.
static function string to_string( const ref ua_type ua, input string separator = " ", int from_index = 0, int to_index = -1, formatter#(T) fmtr = null )
singleton Provides strategies to compare objects.
class comparator#( type T = int )
singleton Provides a strategy to convert an object of type T to a string using a hexadecimal format.
class hex_formatter #( type T = int ) extends formatter#( T )