Vitis HLS ライブラリ リファレンス

C++ の標準出力ストリームの使用

ap_[u]int 変数に格納されている値を出力するのに最も簡単な方法は、次の C++ の標準出力ストリームのいずれかを使用する方法です。

std::cout (#include <iostream> または <iostream.h>)

ストリーム挿入演算子 << は、任意の ap_[u]fixed 変数に対する範囲全体に含まれる値が正しく出力されるように、オーバーロードされます。次のストリーム マニピュレーターもサポートされています。

• dec (10 進数)
• hex (16 進数)
• oct (8 進数)

これにより、値を指定どおりにフォーマットできます。

次の例では、値を出力するのに cout が使用されています。

#include <iostream.h>
// Alternative: #include <iostream>

ap_ufixed<72> Val(“10fedcba9876543210”);

cout << Val << endl; // Yields: “313512663723845890576”
cout << hex << val << endl; // Yields: “10fedcba9876543210”
cout << oct << val << endl; // Yields: “41773345651416625031020”

標準 C ライブラリの使用

標準 C ライブラリ (#include <stdio.h>) を使用して、64 ビットよりも大きな値を出力することもできます。

1. ap_[u]fixed クラスの to_string() メソッドを使用し、値を C++ の std::string に変換します。
2. その結果を std::string クラスの c_str() メソッドを使用して、ヌルで終了する C 文字に変換します。

オプションの引数 1 (基数の指定)

ap[u]int::to_string() メソッドでは目的の基数を指定するオプションの引数を渡すことができます。有効な基数の引数値は、次のとおりです。

• 2 (2 進数) (デフォルト)
• 8 (8 進数)
• 10 (10 進数)
• 16 (16 進数)

オプションの引数 2 (符号付きの値として出力)

ap_[u]int::to_string() の 2 つ目のオプションの引数は、10 進数以外のフォーマットで符号付きの値を出力するかどうかを指定します。この引数はブール形式です。デフォルト値は false で、10 進数以外のフォーマットで符号なしの値が出力されます。

次の例では、値を出力するのに printf が使用されています。

ap_int<72> Val(“80fedcba9876543210”);

printf(“%s\n”, Val.to_string().c_str()); // => “80FEDCBA9876543210”
printf(“%s\n”, Val.to_string(10).c_str()); // => “-2342818482890329542128”
printf(“%s\n”, Val.to_string(8).c_str()); // => “401773345651416625031020” 
printf(“%s\n”, Val.to_string(16, true).c_str()); // => “-7F0123456789ABCDF0”

ビット幅が小さい値を幅が大きいものへ代入する場合のゼロまたは符号拡張

ビット幅が小さい符号付き変数 (ap_int<>) の値を幅の大きなものへ代入すると、符号にかかわらず、値はデスティネーション変数の幅 (大きいほうの幅) に符号拡張されます。

同様に、符号なしのビット幅の小さい変数は代入前にゼロ拡張されます。

代入で予期動作を得るには、ソース変数の明示的な型変換が必要になることがあります。次に例を示します。

ap_uint<10> Result;

ap_int<7> Val1 = 0x7f;
ap_uint<6> Val2 = 0x3f;

Result = Val1; // Yields: 0x3ff (sign-extended)
Result = Val2; // Yields: 0x03f (zero-padded)

Result = ap_uint<7>(Val1); // Yields: 0x07f (zero-padded)
Result = ap_int<6>(Val2); // Yields: 0x3ff (sign-extended)

ビット幅が大きい値を幅が小さいものへ代入する場合の切り捨て

ビット幅が大きいソース変数値を幅の小さなものへ代入すると、値が切り捨てられ、デスティネーション値 (幅の小さいほうの値) の最上位ビット (MSB) を超えたビットはすべて失われます。

この切り捨てが実行されるとき、符号情報が特別に処理されるわけではないので、予期しない動作が見られる可能性があります。予期しない動作を防ぐには、明示的な型変換を利用します。

2 進数の演算子

任意精度演算を実行するため、標準 2 進数整数演算子がオーバーロードされます。次の演算子では次のいずれかが使用されます。

• ap_[u]int の 2 つのオペランド
• ap_[u]int 型 1 つと C/C++ 整数型 1 つ

次に例を示します。

• char
• short
• int

結果値の幅および符号は、デスティネーション変数 (または式) の幅に基づいて符号拡張、ゼロの追加、または切り捨てが実行される前の、オペランドの幅および符号で決まります。戻り値の詳細は、各演算子のセクションで説明します。

式に ap_[u]int 型および C/C++ 整数型の両方が含まれている場合、C++ 型では次の幅が使用されます。

• char (8 ビット)
• short (16 ビット)
• int (32 ビット)
• long (32 ビット)
• long long (64 ビット)

加算

ap_(u)int::RType ap_(u)int::operator + (ap_(u)int op)

次の和が返されます。

• 2 つの ap_[u]int、または
• 1 つの ap_[u]int および C/C++ 整数型

和の幅は、次のようになります。

• 2 つのオペランドの幅の広い方に 1 ビット追加。
• 幅の広い方が符号なしで幅の狭い方が符号付きの場合は 2 ビット追加。

オペランドのいずれか (または両方) が符号付きの場合、和は符号付きとして処理。

減算

ap_(u)int::RType ap_(u)int::operator - (ap_(u)int op)

2 つの整数の差を計算する式です。

差の値の幅は、次のようになります。

• 2 つのオペランドの幅の広い方に 1 ビット追加。
• 幅の広い方が符号なしで幅の狭い方が符号付きの場合は 2 ビット追加。

代入前に、デスティネーション変数の幅に基づいて、符号拡張、ゼロの追加、または切り捨てが実行されます。

オペランドの符号にかかわらず、差は符号付きとして処理されます。

乗算

ap_(u)int::RType ap_(u)int::operator * (ap_(u)int op)

2 つの整数値の積を返します。

積の幅はオペランドの幅の合計です。

オペランドのいずれかが符号付きであれば、積は符号付きとして処理されます。

除算

ap_(u)int::RType ap_(u)int::operator / (ap_(u)int op)

2 つの整数値の商を計算します。

除数が符号なしである場合、商の幅は被除数の幅となり、そうでない場合は、商の幅は被除数の幅に 1 を足したものの幅となります。

オペランドのいずれかが符号付きであれば、商は符号付きとして処理されます。

剰余

ap_(u)int::RType ap_(u)int::operator % (ap_(u)int op)

2 つの整数値の整数除算の余りを返します。

剰余とオペランド両方に同じ符号が付いている場合、剰余の幅は、オペランドの幅の最小値です。

オペランドがどちらも同じ符号である場合は、剰余の幅はオペランドの幅の最小値となります。

除数が符号なし、被除数が符号付きの場合は、剰余の幅は除数の幅に 1 を足したものとなります。

次は、演算子の例です。

ap_uint<71> Rslt;

ap_uint<42> Val1 = 5;
ap_int<23> Val2 = -8;

Rslt = Val1 + Val2; // Yields: -3 (43 bits) sign-extended to 71 bits
Rslt = Val1 - Val2; // Yields: +3 sign extended to 71 bits
Rslt = Val1 * Val2; // Yields: -40 (65 bits) sign extended to 71 bits
Rslt = 50 / Val2; // Yields: -6 (33 bits) sign extended to 71 bits
Rslt = 50 % Val2; // Yields: +2 (23 bits) sign extended to 71 bits

ビット単位の論理演算子

ビット単位の論理演算子はすべて、2 つのオペランドの幅の最大値となる幅の値を返し、両方のオペランドが符号なしの場合にのみ符号なしとして処理されます。そうでない場合は、符号付きとして処理されます。

符号拡張 (またはゼロの追加) は、デスティネーション変数ではなく、式の符号に基づいて実行されます。

ビット単位 OR

ap_(u)int::RType ap_(u)int::operator | (ap_(u)int op)

2 つのオペランドのビット単位の OR 値を返します。

ビット単位 AND (bitwise_and)

ap_(u)int::RType ap_(u)int::operator & (ap_(u)int op)

2 つのオペランドのビット単位の AND 値を返します。

ビット単位 XOR

ap_(u)int::RType ap_(u)int::operator ^ (ap_(u)int op)

2 つのオペランドのビット単位の XOR 値を返します。

単項演算子

加算

ap_(u)int ap_(u)int::operator + ()

ap_[u]int オペランドのセルフ コピーを返します。

減算

ap_(u)int::RType ap_(u)int::operator - ()

次が返されます。

• 符号付きの場合は同じ幅でオペランドのネゲートされた値。
• 符号なしの場合はその幅に 1 を足した値。

戻り値は常に符号付きです。

ビット単位の逆

ap_(u)int::RType ap_(u)int::operator ~ ()

同じ幅および符号の、オペランドのビット単位の NOT を返します。

論理の反転

bool ap_(u)int::operator ! ()

オペランドが 0 ではない場合にブール値 false を返します。

オペランドが 0 の場合は true を返します。

三項演算子

標準 C int 型で三項演算子を使用する場合は、1 つのデータ型から別のデータ型に明示的に変換して、両方の結果が同じデータ型になるようにします。次に例を示します。

// Integer type is cast to ap_int type
ap_int<32> testc3(int a, ap_int<32> b, ap_int<32> c, bool d) {
 return d?ap_int<32>(a):b;
}
// ap_int type is cast to an integer type
ap_int<32> testc4(int a, ap_int<32> b, ap_int<32> c, bool d) {
 return d?a+1:(int)b;
}
// Integer type is cast to ap_int type
ap_int<32> testc5(int a, ap_int<32> b, ap_int<32> c, bool d) {
 return d?ap_int<33>(a):b+1;
}

シフト演算子

各シフト演算子には次の 2 つのバージョンがあります。

• 符号なしの右辺 (RHS) オペランド
• 符号付きの右辺 (RHS) オペランド

符号付き RHS に負の値が与えられるとシフト演算の方向が逆になります。たとえば、RHS オペランドの絶対値によるシフトが逆の方向で発生します。

シフト演算子は、左辺 (LHS) オペランドと同じ幅の値を返します。C/C++ の場合と同じように、右シフトの LHS オペランドが符号付きの場合、符号ビットは、LHS オペランドの符号を維持しつつ、最上位ビットにコピーされます。

符号なし整数右シフト

ap_(u)int ap_(u)int::operator << (ap_uint<int_W2> op)

整数右シフト

ap_(u)int ap_(u)int::operator << (ap_int<int_W2> op)

符号なし整数左シフト

ap_(u)int ap_(u)int::operator >> (ap_uint<int_W2> op)

整数左シフト

ap_(u)int ap_(u)int::operator >> (ap_int<int_W2> op)

次は、シフト演算の例です。

ap_uint<13> Rslt;

ap_uint<7> Val1 = 0x41;

Rslt = Val1 << 6;  // Yields: 0x0040, i.e. msb of Val1 is lost
Rslt = ap_uint<13>(Val1) << 6;  // Yields: 0x1040, no info lost

ap_int<7> Val2 = -63;
Rslt = Val2 >> 4;  //Yields: 0x1ffc, sign is maintained and extended

複合代入演算子

Vitis HLS では、次の複合演算子がサポートされています。

• *=
• /=
• %=
• +=
• -=
• <<=
• >>=
• &=
• ^=
• |=

RHS 式はまず評価されてから RHS オペランドとして基本演算子に供給され、結果が LHS 変数に代入されます。式の長さ、符号、符号拡張か切り捨てかのルールは、関連する演算に対し上記で説明されているように、適用されます。

ap_uint<10> Val1 = 630;
ap_int<3> Val2 = -3;
ap_uint<5> Val3 = 27;

Val1 += Val2 - Val3; // Yields: 600 and is equivalent to:

// Val1 = ap_uint<10>(ap_int<11>(Val1) +
// ap_int<11>((ap_int<6>(Val2) -
// ap_int<6>(Val3))));

インクリメントおよびデクリメント演算子

インクリメントおよびデクリメントの演算子が提供されています。オペランドと同じ幅の値を返しますが、両方のオペランドが符号なしの場合のみ値は符号なしで、そうでない場合は、符号付きです。

プレインクリメント

ap_(u)int& ap_(u)int::operator ++ ()

オペランドのインクリメントされた値を返します。

そのインクリメントされた値をオペランドに代入します。

ポストインクリメント

const ap_(u)int ap_(u)int::operator ++ (int)

インクリメントされた値をオペランド変数に代入する前に、オペランドの値を返します。

プレデクリメント

ap_(u)int& ap_(u)int::operator -- ()

オペランドのデクリメントされた値を返し、その値をオペランドに代入します。

ポストデクリメント

const ap_(u)int ap_(u)int::operator -- (int)

デクリメントされた値をオペランド変数に代入する前に、オペランドの値を返します。

関係演算子

Vitis HLS では、すべての関係演算子がサポートされており、比較結果に基づいてブール値が返されます。ap_[u]int 型の変数は、これらの演算子を使用して C/C++ 基本整数型と比較できます。

等号

bool ap_(u)int::operator == (ap_(u)int op)

等号否定

bool ap_(u)int::operator != (ap_(u)int op)

小なり (<)

bool ap_(u)int::operator < (ap_(u)int op)

大なり (>)

bool ap_(u)int::operator > (ap_(u)int op)

以下

bool ap_(u)int::operator <= (ap_(u)int op)

以上

bool ap_(u)int::operator >= (ap_(u)int op)

ビット レベル演算

ap_[u]int 型変数に格納されている値に基づいて一般的なビット レベル演算を実行するために、次のメソッドが提供されています。

長さ

int ap_(u)int::length ()

ap_[u]int 変数の合計ビット数を表す整数値を返します。

連結

ap_concat_ref ap_(u)int::concat (ap_(u)int low)  
ap_concat_ref ap_(u)int::operator , (ap_(u)int high, ap_(u)int low)

2 つの ap_[u]int 変数を連結します。返された値の幅はオペランドの幅の和です。

high および low の引数にはそれぞれ結果値の高位ビットまたは下位ビットが出力されます。concat() メソッドの場合は下位ビットが出力されます。

オーバーロードされたカンマ演算子を使用するときはかっこが必要です。カンマ演算子バージョンが代入の LHS に現れることもあります。

ap_uint<10> Rslt;

ap_int<3> Val1 = -3;
ap_int<7> Val2 = 54;

Rslt = (Val2, Val1); // Yields: 0x1B5
Rslt = Val1.concat(Val2); // Yields: 0x2B6
(Val1, Val2) = 0xAB; // Yields: Val1 == 1, Val2 == 43

ビット選択

ap_bit_ref ap_(u)int::operator [] (int bit)

任意精度の整数値から 1 ビットを選択し、それを返します。

戻り値は、ap_[u]int 変数の対応するビットをセットまたはクリアできる参照値です。

ビット引数は int 値にする必要があります。選択するビットの指数を指定します。最下位ビットの指数は 0 です。最大指数はこの ap_[u]int のビット幅から 1 を引いた値になります。

ap_bit_ref はビットで指定されているこの ap_[u]int インスタンスの 1 ビットへの参照を表しています。

範囲選択

ap_range_ref ap_(u)int::range (unsigned Hi, unsigned Lo)
ap_range_ref ap_(u)int::operator () (unsigned Hi, unsigned Lo)

引数で指定されるビットの範囲で表される値を返します。

引数 Hi は、範囲内の最上位ビット (MSB) を、Lo は最下位ビット (LSB) を指定します。

ソース変数の LSB は 0 の位置にあります。引数 Hi の値が Lo の値より小さい場合、ビットは逆順で返されます。

ap_uint<4> Rslt;

ap_uint<8> Val1 = 0x5f;
ap_uint<8> Val2 = 0xaa;

Rslt = Val1.range(3, 0); // Yields: 0xF
Val1(3,0) = Val2(3, 0); // Yields: 0x5A
Val1(3,0) = Val2(4, 1); // Yields: 0x55
Rslt = Val1.range(4, 7); // Yields: 0xA; bit-reversed!

AND を使用した低減

bool ap_(u)int::and_reduce ()

• この ap_(u)int のビットすべてに AND 演算を適用します。
• 結果の単一ビットを返します。
• -1 (すべて 1) に対してこの値を比較することと同じで、一致すれば true が返され、一致しない場合は false が返されます。

OR を使用した低減

bool ap_(u)int::or_reduce ()

• この ap_(u)int のビットすべてに OR 演算を適用します。
• 結果の単一ビットを返します。
• 0 (すべて 0) に対してこの値を比較することと同じで、一致すれば false が返され、一致しない場合は true が返されます。

XOR を使用した低減

bool ap_(u)int::xor_reduce ()

• この ap_int のビットすべてに XOR 演算を適用します。
• 結果の単一ビットを返します。
• この値の 1 のビット数を数えて、偶数の場合は false、奇数の場合は true を返すことと同じです。

NAND を使用した低減

bool ap_(u)int::nand_reduce ()

• この ap_int のビットすべてに NAND 演算を適用します。
• 結果の単一ビットを返します。
• -1 (すべて 1) に対してこの値を比較することと同じで、一致すれば false が返され、一致しない場合は true が返されます。

NOR を使用した低減

bool ap_int::nor_reduce ()

• この ap_int のビットすべてに NOR 演算を適用します。
• 結果の単一ビットを返します。
• 0 (すべて 0) に対してこの値を比較することと同じで、一致すれば true が返され、一致しない場合は false が返されます。

XNOR を使用した低減

bool ap_(u)int::xnor_reduce ()

• この ap_(u)int のビットすべてに XNOR 演算を適用します。
• 結果の単一ビットを返します。
• この値の 1 のビット数を数えて、偶数の場合は true、奇数の場合は false を返すことと同じです。

ビット低減メソッドの例

ap_uint<8> Val = 0xaa;

bool t = Val.and_reduce(); // Yields: false
t = Val.or_reduce();       // Yields: true
t = Val.xor_reduce();      // Yields: false
t = Val.nand_reduce();     // Yields: true
t = Val.nor_reduce();      // Yields: false
t = Val.xnor_reduce();     // Yields: true

ビットのリバース

void ap_(u)int::reverse ()

ap_[u]int インスタンスの内容を反転します。

• LSB は MSB になります。
• MSB は LSB になります。

リバース メソッドの例

ap_uint<8> Val = 0x12;

Val.reverse(); // Yields: 0x48

ビット値のテスト

bool ap_(u)int::test (unsigned i)

ap_(u)int インスタンスの指定ビットが 1 であるかどうかをチェックします。

1 の場合は true、それ以外の場合は false を返します。

テスト メソッドの例

ap_uint<8> Val = 0x12;
bool t = Val.test(5); // Yields: true

ビット値の設定

void ap_(u)int::set (unsigned i, bool v)                              
void ap_(u)int::set_bit (unsigned i, bool v)

ap_(u)int インスタンスの指定ビットを整数 V の値に設定します。

ビットの設定 (1)

void ap_(u)int::set (unsigned i)

ap_(u)int インスタンスの指定ビットを 1 に設定します。

ビットのクリア (0)

void ap_(u)int:: clear(unsigned i)

ap_(u)int インスタンスの指定ビットを 0 に設定します。

ビットの反転

void ap_(u)int:: invert(unsigned i)

ap_(u)int インスタンスの関数引数で指定したビットを反転します。指定ビットは、元の値が 0の場合 1 となり、0 の場合は 1 になります。

ビットの設定、クリア、反転メソッドの例:

ap_uint<8> Val = 0x12;
Val.set(0, 1); // Yields: 0x13
Val.set_bit(4, false); // Yields: 0x03
Val.set(7); // Yields: 0x83
Val.clear(1); // Yields: 0x81
Val.invert(4); // Yields: 0x91 

右に移動

void ap_(u)int:: rrotate(unsigned n)

ap_(u)int インスタンスを n 桁右に移動します。

左に移動

void ap_(u)int:: lrotate(unsigned n)

ap_(u)int インスタンスを n 桁左に移動します。

ap_uint<8> Val = 0x12;

Val.rrotate(3); // Yields: 0x42
Val.lrotate(6); // Yields: 0x90

ビット単位 NOT (bitwise_not)

void ap_(u)int:: b_not()

• ap_(u)int インスタンスのすべてのビットを補足します。

ap_uint<8> Val = 0x12;

Val.b_not(); // Yields: 0xED

ビット単位 NOT の例

符号のテスト

bool ap_int:: sign()

• ap_(u)int インスタンスが負の値なのかどうかをチェックします。
• 負の値の場合は true が返されます。
• 正の値の場合は false が返されます。

明示的な変換メソッド

C/C++ の (u)int 型

int ap_(u)int::to_int ()
unsigned ap_(u)int::to_uint ()

• ap_[u]int に含まれる値のネイティブ C/C++ (ほとんどのシステムで 32 ビット) 整数を返します。
• 値が [unsigned] int で表示されるよりも大きい場合は、切り捨てが実行されます。

C/C++ 64 ビット (u)int 型

long long ap_(u)int::to_int64 ()
unsigned long long ap_(u)int::to_uint64 ()

• ap_[u]int に含まれる値のネイティブ C/C++ の 64 ビットの整数を返します。
• 値が [unsigned] int で表示されるよりも大きい場合は、切り捨てが実行されます。

C/C++ の double 型

double ap_(u)int::to_double ()

• ap_[u]int に含まれるネイティブ C/C++ の double の 64 ビット浮動小数点表記を返します。
• ap_[u]int が 53 ビット (double の仮数のビット数) より大きい場合、結果の double に正確な値が含まれないことがあります。

Sizeof

標準 C++ sizeof() 関数は、ap_[u]int やその他のクラスまたはオブジェクトのインスタンスとは一緒に使用できません。ap_int<> 型はクラスで、sizeof からはそのクラスまたはインスタンス オブジェクトで使用されたストレージが返されます。sizeof(ap_int<N>) からは、常に使用されたバイト数が返されます。次に例を示します。

 sizeof(ap_int<127>)=16
 sizeof(ap_int<128>)=16
 sizeof(ap_int<129>)=24
 sizeof(ap_int<130>)=24

コンパイル時のデータ型属性へのアクセス

ap_[u]int<> 型には、変数のサイズをコンパイル時に決定できるようにするスタティック メンバーが含まれます。このデータ型に含まれる static const メンバーの width により、自動的にデータ型の幅が割り当てられます。

static const int width = _AP_W;

既存の ap_[u]int<> 型を抽出するのに width データ メンバーを使用すると、コンパイル時に別の ap_[u]int<> 型を作成できます。次の例は、変数 Res のサイズを変数 Val1 と Val2 変数よりも 1 ビット大きく定義する方法を示しています。

// Definition of basic data type
#define INPUT_DATA_WIDTH 8
typedef ap_int<INPUT_DATA_WIDTH> data_t;
// Definition of variables 
data_t Val1, Val2;
// Res is automatically sized at compile-time to be 1-bit greater than data type 
data_t
ap_int<data_t::width+1> Res = Val1 + Val2;

これにより、Vitis HLS で data_t の INPUT_DATA_WIDTH の値をアップデートした場合ですら、加算によるビット増加が正しく認識されるようになります。

AP_RND

• 特定の ap_[u]fixed 型の近似値に値が丸められます。

  ap_fixed<3, 2, AP_RND, AP_SAT> UAPFixed4 = 1.25; // Yields: 1.5
  ap_fixed<3, 2, AP_RND, AP_SAT> UAPFixed4 = -1.25; // Yields: -1.0

AP_RND_ZERO

• 表示可能なの近似値に値が丸められます。
• 0 の方向へ丸められます。
  • 正の値に対しては重複ビットが削除されます。
  • 負の値に対しては LSB が追加され、最も近い表示可能な値が表示されます。

  ap_fixed<3, 2, AP_RND_ZERO, AP_SAT> UAPFixed4 = 1.25; // Yields: 1.0
  ap_fixed<3, 2, AP_RND_ZERO, AP_SAT> UAPFixed4 = -1.25; // Yields: -1.0

AP_RND_MIN_INF

• 表示可能なの近似値に値が丸められます。
• 負の無限大の方向へ丸められます。
  • 正の値に対しては重複ビットが削除されます。
  • 負の値に対しては LSB が追加されます。

  ap_fixed<3, 2, AP_RND_MIN_INF, AP_SAT> UAPFixed4 = 1.25; // Yields: 1.0
  ap_fixed<3, 2, AP_RND_MIN_INF, AP_SAT> UAPFixed4 = -1.25; // Yields: -1.5

AP_RND_INF

• 表示可能なの近似値に値が丸められます。
• 丸めは LSB によって変わります。
  • 正の値に対しては、LSB が設定されている場合は正の無限大の方向に丸められます。そうでない場合は負の無限大の方向に丸められます。
  • 負の値に対しては、LSB が設定されている場合は負の無限大の方向に丸められます。そうでない場合は正の無限大の方向に丸められます。

  ap_fixed<3, 2, AP_RND_INF, AP_SAT> UAPFixed4 = 1.25; // Yields: 1.5
  ap_fixed<3, 2, AP_RND_INF, AP_SAT> UAPFixed4 = -1.25; // Yields: -1.5

AP_RND_CONV

• 表示可能なの近似値に値が丸められます。
• 丸めは LSB によって変わります。
  • LSB が設定されている場合は正の無限大の方向に丸められます。
  • そうでない場合は負の無限大の方向に丸められます。

  ap_fixed<3, 2, AP_RND_CONV, AP_SAT> UAPFixed4 = 0.75; // Yields: 1.0
  ap_fixed<3, 2, AP_RND_CONV, AP_SAT> UAPFixed4 = -1.25; // Yields: -1.0

AP_TRN

• 常に負の無限大に向かって値が丸められます。

  ap_fixed<3, 2, AP_TRN, AP_SAT> UAPFixed4 = 1.25; // Yields: 1.0
  ap_fixed<3, 2, AP_TRN, AP_SAT> UAPFixed4 = -1.25; // Yields: -1.5

AP_TRN_ZERO

値を次のように丸めます。

• 正の値の場合、AP_TRN モードと同じ丸めになります。
• 負の値の場合はゼロの方向へ丸められます。

  ap_fixed<3, 2, AP_TRN_ZERO, AP_SAT> UAPFixed4 = 1.25; // Yields: 1.0
  ap_fixed<3, 2, AP_TRN_ZERO, AP_SAT> UAPFixed4 = -1.25; // Yields: -1.0

AP_SAT

値が次のように飽和されます。

• オーバーフローが発生したときは値が最大値に飽和されます。
• 負のオーバーフローのときは最小値に飽和されます。

  ap_fixed<4, 4, AP_RND, AP_SAT> UAPFixed4 = 19.0; // Yields: 7.0
  ap_fixed<4, 4, AP_RND, AP_SAT> UAPFixed4 = -19.0; // Yields: -8.0
  ap_ufixed<4, 4, AP_RND, AP_SAT> UAPFixed4 = 19.0; // Yields: 15.0
  ap_ufixed<4, 4, AP_RND, AP_SAT> UAPFixed4 = -19.0; // Yields: 0.0

AP_SAT_ZERO

オーバーフローまたは負のオーバーフローの場合に値 を 0 にします。

ap_fixed<4, 4, AP_RND, AP_SAT_ZERO> UAPFixed4 = 19.0; // Yields: 0.0
ap_fixed<4, 4, AP_RND, AP_SAT_ZERO> UAPFixed4 = -19.0; // Yields: 0.0
ap_ufixed<4, 4, AP_RND, AP_SAT_ZERO> UAPFixed4 = 19.0; // Yields: 0.0
ap_ufixed<4, 4, AP_RND, AP_SAT_ZERO> UAPFixed4 = -19.0; // Yields: 0.0

AP_SAT_SYM

値が次のように飽和されます。

• オーバーフローが発生したときは値が最大値に飽和されます。
• 負のオーバーフローのときは最小値に飽和されます。
  • 符号付き ap_fixed 型の場合は負の最大値
  • 符号なし ap_ufixed 型の場合は 0

  ap_fixed<4, 4, AP_RND, AP_SAT_SYM> UAPFixed4 = 19.0; // Yields: 7.0
  ap_fixed<4, 4, AP_RND, AP_SAT_SYM> UAPFixed4 = -19.0; // Yields: -7.0
  ap_ufixed<4, 4, AP_RND, AP_SAT_SYM> UAPFixed4 = 19.0; // Yields: 15.0
  ap_ufixed<4, 4, AP_RND, AP_SAT_SYM> UAPFixed4 = -19.0; // Yields: 0.0

AP_WRAP

オーバーフローが発生したときは値が折り返されます。

ap_fixed<4, 4, AP_RND, AP_WRAP> UAPFixed4 = 31.0; // Yields: -1.0
ap_fixed<4, 4, AP_RND, AP_WRAP> UAPFixed4 = -19.0; // Yields: -3.0
ap_ufixed<4, 4, AP_RND, AP_WRAP> UAPFixed4 = 19.0; // Yields: 3.0
ap_ufixed<4, 4, AP_RND, AP_WRAP> UAPFixed4 = -19.0; // Yields: 13.0

N の値が 0 の場合 (デフォルトのオーバーフロー モード):

• 範囲外の MSB はすべて削除されます。
• 符号なしの場合は、最大値に達すると 0 に戻ります。
• 符号付きの場合は、最大値に達すると最小値に戻ります。

N が 0 より大きい場合:

• N が 0 より大きい場合、MSB は飽和するか、または 1 に設定されます。
• 符号ビットは保持されるため、正の値は正のまま、負の値は負のままになります。
• 飽和していないビットは LSB 側からコピーされます。

AP_WRAP_SM

値が符号絶対値で折り返されます。

ap_fixed<4, 4, AP_RND, AP_WRAP_SM> UAPFixed4 = 19.0; // Yields: -4.0
ap_fixed<4, 4, AP_RND, AP_WRAP_SM> UAPFixed4 = -19.0; // Yields: 2.0

N の値が 0 の場合 (デフォルトのオーバーフロー モード):

• このモードでは符号絶対値ラップが使用されます。
• 符号ビットは最下位の削除されたビットの値に設定されます。
• 最上位の残りのビットが元の MSB とは異なる場合、残っているビットすべてが反転されます。
• MSB が同じである場合は、ほかのビットがコピーされます。
  1. 重複している MSB が削除されます。
  2. 新しい符号ビットは削除されたビットの最下位ビットです。この場合は 0 です。
  3. 新しい符号ビットが新しい値の符号と比較されます。
• 異なる場合は、すべての数値が反転されます。この場合は数値は異なります。

N が 0 より大きい場合:

• 符号絶対値の飽和が使用されます。
• N 個の MSB が 1 に飽和します。
• N =0 のケースと同様の動作になりますが、正の数値は正のまま、負の数値は負のままになる点が異なります。

標準 C ライブラリの使用

標準 C ライブラリ (#include <stdio.h>) を使用して、64 ビットよりも大きな値を出力することもできます。

1. ap_[u]fixed クラスの to_string() メソッドを使用し、値を C++ の std::string に変換します。
2. その結果を std::string クラスの c_str() メソッドを使用して、ヌルで終了する C 文字に変換します。

オプションの引数 1 (基数の指定)

ap[u]int::to_string() メソッドでは目的の基数を指定するオプションの引数を渡すことができます。有効な基数の引数値は、次のとおりです。

• 2 (2 進数)
• 8 (8 進数)
• 10 (10 進数)
• 16 (16 進数) (デフォルト)

オプションの引数 2 (符号付きの値として出力)

ap_[u]int::to_string() の 2 つ目のオプションの引数は、10 進数以外のフォーマットで符号付きの値を出力するかどうかを指定します。この引数はブール形式です。デフォルト値は false で、10 進数以外のフォーマットで符号なしの値が出力されます。

ap_fixed<6,3, AP_RND, AP_WRAP> Val = 3.25;

printf("%s \n", in2.to_string().c_str()); // Yields: 0b011.010
printf("%s \n", in2.to_string(10).c_str()); //Yields: 3.25

ap_[u]fixed 型は、次の C++ マニピュレーター関数でサポートされます。

• setprecision
• setw
• setfill

setprecision マニピュレーターでは、使用する小数点以下の精度を設定します。1 つのパラメーター f を小数点以下の精度の値として使用します。n は表示する合計有効桁数の最大値 (小数点の前と後の両方をカウント) を指定します。

f のデフォルト値は 6 で、ネイティブ C の float 型と一貫しています。

ap_fixed<64, 32> f =3.14159;
cout << setprecision (5) << f << endl;
cout << setprecision (9) << f << endl;
f = 123456;
cout << setprecision (5) << f << endl;

上記を実行すると、実際の精度が指定した精度を超える場合に丸められ、次の結果が表示されます。

   3.1416
   3.14159
   1.2346e+05

setw マニピュレーターは、次を実行します。

• フィールド幅に使用される文字数を設定します。
• 1 つのパラメーター w を幅の値として使用します。

  説明:

  • w: 出力表示で使用される最小文字数を指定します。

表示の標準幅がフィールド幅よりも短い場合は、埋め字で補足されます。埋め字は setfill マニピュレーターで制御され、1 つのパラメーター f が補足文字として使用されます。

次に例を示します。

    ap_fixed<65,32> aa = 123456;
    int precision = 5;
    cout<<setprecision(precision)<<setw(13)<<setfill('T')<<a<<endl;

この出力は、次のようになります。

     TTT1.2346e+05

2 進数の演算子

加算

ap_[u]fixed::RType ap_[u]fixed::operator + (ap_[u]fixed op)

任意精度の固定小数点と指定したオペランド op を加算します。

オペランドには、次のいずれかの整数型を使用できます。

• ap_[u]fixed
• ap_[u]int
• C/C++

結果のデータ型 ap_[u]fixed::RType は、2 つのオペランドのデータ型によります。

ap_fixed<76, 63> Result;

ap_fixed<5, 2> Val1 = 1.125;
ap_fixed<75, 62> Val2 = 6721.35595703125;

Result = Val1 + Val2; //Yields 6722.480957

Val2 の方が整数部および小数部のビット幅が広いため、結果値をすべて格納できるようにするため、結果のデータ型の幅はこのビット幅に 1 を足したものになります。

データの幅を指定すると、次に示すように、べき関数を使用してリソースが制御されます。同様に、ザイリンクスでは、固定小数点演算の幅を指定する代わりに、格納された結果の幅を指定することをお勧めします。

ap_ufixed<16,6> x=5; 
ap_ufixed<16,7>y=hl::rsqrt<16,6>(x+x); 

減算

ap_[u]fixed::RType ap_[u]fixed::operator - (ap_[u]fixed op)

任意精度の固定小数点値から指定したオペランド op を減算します。

結果のデータ型 ap_[u]fixed::RType は、2 つのオペランドのデータ型によります。

ap_fixed<76, 63> Result;

ap_fixed<5, 2> Val1 = 1625.153;
ap_fixed<75, 62> Val2 = 6721.355992351;

Result = Val2 - Val1; // Yields 6720.23057

Val2 の方が整数部および小数部のビット幅が広いため、結果値をすべて格納できるようにするため、結果のデータ型の幅はこのビット幅に 1 を足したものになります。

乗算

ap_[u]fixed::RType ap_[u]fixed::operator * (ap_[u]fixed op)

任意精度の固定小数点値を指定したオペランド op と乗算します。

ap_fixed<80, 64> Result;

ap_fixed<5, 2> Val1 = 1625.153;
ap_fixed<75, 62> Val2 = 6721.355992351;

Result = Val1 * Val2; // Yields 7561.525452

この例では、Val1 と Val2 を乗算しています。この結果のデータ型は、整数部のビット幅と小数部のビット幅の和になります。

除算

ap_[u]fixed::RType ap_[u]fixed::operator / (ap_[u]fixed op)

任意精度の固定小数点値を指定したオペランド op で除算します。

ap_fixed<84, 66> Result;

ap_fixed<5, 2> Val1 = 1625.153;
ap_fixed<75, 62> Val2 = 6721.355992351;

Val2 / Val1; // Yields 5974.538628

この例では、Val1 で Val2 を除算しています。十分な精度を保持するため、次のようになります。

• 結果のデータ型の整数ビット幅は、Val2 の整数ビット幅と、Val1 の小数ビット幅の和になります。
• 結果のデータ型の小数ビット幅は、Val2 の小数ビット幅と等しくなります。

ビット単位の論理演算子

ビット単位 OR

ap_[u]fixed::RType ap_[u]fixed::operator | (ap_[u]fixed op)

任意精度の固定小数点と任意のオペランド op にビット単位演算を適用します。

ap_fixed<75, 62> Result;

ap_fixed<5, 2> Val1 = 1625.153;
ap_fixed<75, 62> Val2 = 6721.355992351;

Result = Val1 | Val2; // Yields 6271.480957

ビット単位 AND

ap_[u]fixed::RType ap_[u]fixed::operator & (ap_[u]fixed op)

任意精度の固定小数点と任意のオペランド op にビット単位演算を適用します。

ap_fixed<75, 62> Result;

ap_fixed<5, 2> Val1 = 1625.153;
ap_fixed<75, 62> Val2 = 6721.355992351;

Result = Val1 & Val2;  // Yields 1.00000

ビット単位 XOR

ap_[u]fixed::RType ap_[u]fixed::operator ^ (ap_[u]fixed op)

任意精度の固定小数点と任意のオペランド op に xor ビット単位演算を適用します。

ap_fixed<75, 62> Result;

ap_fixed<5, 2> Val1 = 1625.153;
ap_fixed<75, 62> Val2 = 6721.355992351;

Result = Val1 ^ Val2; // Yields 6720.480957

インクリメントおよびデクリメント演算子

前置インクリメント

ap_[u]fixed ap_[u]fixed::operator ++ ()

任意精度の固定小数点変数を 1 インクリメントします。

ap_fixed<25, 8> Result;
ap_fixed<8, 5> Val1 = 5.125;

Result = ++Val1; // Yields 6.125000

後置インクリメント

ap_[u]fixed ap_[u]fixed::operator ++ (int)

この演算関数は、次を実行します。

• 任意精度の固定小数点変数を 1 インクリメント。
• この任意精度の固定小数点の元の値を返す。

  ap_fixed<25, 8> Result;
  ap_fixed<8, 5> Val1 = 5.125;
  
  Result = Val1++; // Yields 5.125000

前置デクリメント

ap_[u]fixed ap_[u]fixed::operator -- ()

任意精度の固定小数点変数を 1 デクリメントします。

ap_fixed<25, 8> Result;
ap_fixed<8, 5> Val1 = 5.125;

Result = --Val1; // Yields 4.125000

後置デクリメント

ap_[u]fixed ap_[u]fixed::operator -- (int)

この演算関数は、次を実行します。

• 任意精度の固定小数点変数を 1 デクリメント。
• この任意精度の固定小数点の元の値を返す。

  ap_fixed<25, 8> Result;
  ap_fixed<8, 5> Val1 = 5.125;
  
  Result = Val1--; // Yields 5.125000

単項演算子

加算

ap_[u]fixed ap_[u]fixed::operator + ()

任意精度の固定小数点変数のセルフ コピーを返します。

ap_fixed<25, 8> Result;
ap_fixed<8, 5> Val1 = 5.125;

Result = +Val1;  // Yields 5.125000

減算

ap_[u]fixed::RType ap_[u]fixed::operator - ()

任意精度の固定小数点変数の負の値を返します。

ap_fixed<25, 8> Result;
ap_fixed<8, 5> Val1 = 5.125;

Result = -Val1; // Yields -5.125000

0 との等価比較

bool ap_[u]fixed::operator ! ()

この演算関数は、次を実行します。

• 任意精度の固定小数点変数を 0 と比較。
• 結果を返す。

  bool  Result;
  ap_fixed<8, 5> Val1 = 5.125;
  
  Result = !Val1; // Yields false

ビット単位の反転

ap_[u]fixed::RType ap_[u]fixed::operator ~ ()

任意精度の固定小数点変数のビット単位の補数を返します。

ap_fixed<25, 15> Result;
ap_fixed<8, 5> Val1 = 5.125;

Result = ~Val1; // Yields -5.25

シフト演算子

符号なし左シフト

ap_[u]fixed ap_[u]fixed::operator << (ap_uint<_W2> op) 

この演算関数は、次を実行します。

• 指定した整数オペランド分左にシフト。
• 結果を返す。

オペランドには次の C/C++ の整数型を使用できます。

• char
• short
• int
• long

左シフト演算で返されるデータ型は、シフトされたデータ型と同じ幅になります。

ap_fixed<25, 15> Result;
ap_fixed<8, 5> Val = 5.375;

ap_uint<4> sh = 2;

Result = Val << sh; // Yields -10.5

結果のビット幅は (W = 25、I = 15) です。左シフト演算の結果のデータ型は Val と同じであるため、次のようになります。

• Val の上位 2 ビットがシフト アウトされます。
• 結果は -10.5 になります。

結果が 21.5 になるようにするには、ap_ufixed<10, 7>(Val) のように、まず Val を ap_fixed<10, 7> にキャストする必要があります。

符号付き左シフト

ap_[u]fixed ap_[u]fixed::operator << (ap_int<_W2> op)

この演算子は、次を実行します。

• 指定した整数オペランド分左にシフト。
• 結果を返す。

オペランドが正か負かによって、シフトの方向が変わります。

• オペランドが正の場合は右シフトが実行されます。
• オペランドが負の場合は左シフト (逆方向) が実行されます。

オペランドには次の C/C++ の整数型を使用できます。

• char
• short
• int
• long

右シフト演算で返される型は、シフトされた型と同じ幅になります。

ap_fixed<25, 15,  false> Result;
ap_uint<8, 5> Val = 5.375;

ap_int<4> Sh = 2;
Result = Val << sh; // Shift left, yields -10.25

Sh = -2;
Result = Val << sh; // Shift right, yields 1.25

符号なし右シフト

ap_[u]fixed ap_[u]fixed::operator >> (ap_uint<_W2> op) 

この operator 関数では、次が実行されます。

• 任意の整数オペランドで右にシフト。
• 結果を返す。

オペランドには次の C/C++ の整数型を使用できます。

• char
• short
• int
• long

右シフト演算で返されるデータ型は、シフトされたデータ型と同じ幅になります。

ap_fixed<25, 15> Result;
ap_fixed<8, 5> Val = 5.375;

ap_uint<4> sh = 2;

Result = Val >> sh; // Yields 1.25

すべての上位ビットを保持する必要がある場合は、ap_fixed<10, 5>(Val) のように、まず Val の小数部のビット幅を拡張します。

符号付き右シフト

ap_[u]fixed ap_[u]fixed::operator >> (ap_int<_W2> op) 

この演算子は、次を実行します。

• 指定した整数オペランド分右にシフト。
• 結果を返す。

オペランドが正か負かによって、シフトの方向が変わります。

• オペランドが正の場合は右シフトが実行されます。
• オペランドが負の場合は左シフト (逆方向) が実行されます。

オペランドには C/C++ の整数型 (char、short、int、または long) を使用できます。

右シフト演算で返されるデータ型は、シフトされるデータ型と同じ幅になります。次に例を示します。

ap_fixed<25, 15,  false> Result;
ap_uint<8, 5> Val = 5.375;

ap_int<4> Sh = 2;
Result = Val >> sh; // Shift right, yields 1.25

Sh = -2;
Result = Val >> sh; // Shift left,  yields -10.5

1.25

比較演算子

等価比較

bool ap_[u]fixed::operator == (ap_[u]fixed op)

任意精度の固定小数点変数と指定したオペランドを比較します。

等しい場合は true、等しくない場合は false を返します。

オペランド op のデータ型には、ap_[u]fixed、ap_int または C/C++ の整数型を使用できます。次に例を示します。

bool Result;

ap_ufixed<8, 5> Val1 = 1.25;
ap_fixed<9, 4> Val2 = 17.25;
ap_fixed<10, 5> Val3 = 3.25;

Result = Val1 == Val2; // Yields  true
Result = Val1 == Val3; // Yields  false

不等価比較

bool ap_[u]fixed::operator != (ap_[u]fixed op)

任意精度の固定小数点変数を指定したオペランドと比較します。

等しくない場合は true、等しい場合は false を返します。

オペランド op のデータ型には、次を使用できます。

• ap_[u]fixed
• ap_int
• C または C++ の整数型

次に例を示します。

bool Result;

ap_ufixed<8, 5> Val1 = 1.25;
ap_fixed<9, 4> Val2 = 17.25;
ap_fixed<10, 5> Val3 = 3.25;

Result = Val1 != Val2; // Yields false
Result = Val1 != Val3; // Yields true

以上

bool ap_[u]fixed::operator >= (ap_[u]fixed op)

変数を指定のオペランドと比較します。

変数がオペランド以上の場合は true、そうでない場合は false を返します。

オペランド op のデータ型には、ap_[u]fixed、ap_int または C/C++ の整数型を使用できます。

次に例を示します。

bool Result;

ap_ufixed<8, 5> Val1 = 1.25;
ap_fixed<9, 4> Val2 = 17.25;
ap_fixed<10, 5> Val3 = 3.25;

Result = Val1 >= Val2; // Yields true
Result = Val1 >= Val3; // Yields false

以下

bool ap_[u]fixed::operator <= (ap_[u]fixed op)

変数と指定のオペランドを比較し、変数がオペランド以下の場合は true、そうでない場合は false を返します。

オペランド op のデータ型には、ap_[u]fixed、ap_int または C/C++ の整数型を使用できます。

次に例を示します。

bool Result;

ap_ufixed<8, 5> Val1 = 1.25;
ap_fixed<9, 4> Val2 = 17.25;
ap_fixed<10, 5> Val3 = 3.25;

Result = Val1 <= Val2; // Yields true
Result = Val1 <= Val3; // Yields true

大なり (>)

bool ap_[u]fixed::operator > (ap_[u]fixed op)

変数を指定のオペランドと比較し、変数がオペランドより大きい場合は true、そうでない場合は false を返します。

オペランド op のデータ型には、ap_[u]fixed、ap_int または C/C++ の整数型を使用できます。

次に例を示します。

bool Result;

ap_ufixed<8, 5> Val1 = 1.25;
ap_fixed<9, 4> Val2 = 17.25;
ap_fixed<10, 5> Val3 = 3.25;

Result = Val1 > Val2; // Yields false
Result = Val1 > Val3; // Yields false

小なり (<)

bool ap_[u]fixed::operator < (ap_[u]fixed op)

変数と指定のオペランドを比較し、変数がオペランド未満の場合は true、そうでない場合は false を返します。

オペランド op のデータ型には、ap_[u]fixed、ap_int または C/C++ の整数型を使用できます。次に例を示します。

bool Result;

ap_ufixed<8, 5> Val1 = 1.25;
ap_fixed<9, 4> Val2 = 17.25;
ap_fixed<10, 5> Val3 = 3.25;

Result = Val1 < Val2; // Yields false
Result = Val1 < Val3; // Yields true

ビット演算子

ビットの選択と設定

af_bit_ref ap_[u]fixed::operator [] (int bit) 

任意精度の固定小数点値から 1 ビット選択し、それを返します。

戻り値は、ap_[u]fixed 変数の対応するビットをセットまたはクリアできる参照値です。ビット引数は整数値である必要があり、選択するビットの指数を指定します。最下位ビットの指数は 0 です。最大指数はこの ap_[u]fixed 変数のビット幅から 1 を引いた値になります。

結果のデータ型は af_bit_ref で、値は 0 または 1 です。次に例を示します。

ap_int<8, 5> Value = 1.375;

Value[3]; // Yields  1
Value[4]; // Yields  0

Value[2] = 1; // Yields 1.875
Value[3] = 0; // Yields 0.875

ビット範囲

af_range_ref af_(u)fixed::range (unsigned Hi, unsigned Lo)
af_range_ref af_(u)fixed::operator [] (unsigned Hi, unsigned Lo) 

この演算は、ビット セレクト演算子 [] に似ていますが、1 ビットではなくビットの範囲を指定し、

任意精度の固定小数点変数からビットのグループを選択します。引数 Hi は範囲の上限のビットを指定し、引数 Lo は下限のビットを指定します。Lo が Hi よりも大きい場合は、選択されたビットが逆順で返されます。

戻り値のデータ型 af_range_ref は、Hi および Lo で指定される ap_[u]fixed 変数の範囲の参照です。次に例を示します。

ap_uint<4> Result = 0;
ap_ufixed<4, 2> Value = 1.25;
ap_uint<8> Repl = 0xAA;

Result = Value.range(3, 0); // Yields: 0x5
Value(3, 0) = Repl(3, 0); // Yields: -1.5

// when Lo > Hi, return the reverse bits string
Result = Value.range(0, 3); // Yields: 0xA

範囲選択

af_range_ref af_(u)fixed::range ()
af_range_ref af_(u)fixed::operator [] 

これは、範囲選択演算子 [] の特殊ケースで、任意精度の固定小数点値からすべてのビットを標準の順序で選択します。

戻り値のデータ型 af_range_ref は、Hi = W - 1 および Lo = 0 で指定される範囲の参照です。次に例を示します。

ap_uint<4> Result = 0;

ap_ufixed<4, 2> Value = 1.25;
ap_uint<8> Repl = 0xAA;

Result = Value.range(); // Yields: 0x5
Value() = Repl(3, 0); // Yields: -1.5

長さ

int ap_[u]fixed::length ()

ビット数を表す整数値を任意精度の整数値で返します。データ型または値に使用できます。次に例を示します。

ap_ufixed<128, 64> My128APFixed;

int bitwidth = My128APFixed.length(); // Yields 128

明示的な変換メソッド

固定小数点から double 型

double ap_[u]fixed::to_double ()

このメンバー関数は、固定小数点値を IEEE の倍精度フォーマットに変換します。次に例を示します。

ap_ufixed<256, 77> MyAPFixed = 333.789;
double Result;

Result = MyAPFixed.to_double(); // Yields 333.789

固定小数点から浮動小数点

float ap_[u]fixed::to_float()

このメンバー関数は、固定小数点値を IEEE の浮動精度フォーマットに変換します。次に例を示します。

ap_ufixed<256, 77> MyAPFixed = 333.789;
float Result;

Result = MyAPFixed.to_float();  // Yields 333.789

固定小数点から半精度浮動小数点

half ap_[u]fixed::to_half()

このメンバー関数は、固定小数点値を HLS の半精度 (16 ビット) 浮動精度フォーマットに変換します。次に例を示します。

ap_ufixed<256, 77> MyAPFixed = 333.789;
half Result;

Result = MyAPFixed.to_half();  // Yields 333.789

固定小数点から ap_int 型

ap_int ap_[u]fixed::to_ap_int ()

このメンバー関数は、この固定小数点値を、小数ビットを切り捨てた整数ビットのみを含む ap_int 型に変換します。次に例を示します。

ap_ufixed<256, 77> MyAPFixed = 333.789;
ap_uint<77> Result;

Result = MyAPFixed.to_ap_int(); //Yields 333

固定小数点から整数型

int ap_[u]fixed::to_int ()
unsigned ap_[u]fixed::to_uint ()
ap_slong ap_[u]fixed::to_int64 ()
ap_ulong ap_[u]fixed::to_uint64 ()

このメンバー関数は、固定小数点値を C のビルトイン整数型に変換します。次に例を示します。

ap_ufixed<256, 77> MyAPFixed = 333.789;
unsigned int  Result;

Result = MyAPFixed.to_uint(); //Yields 333

unsigned long long Result;
Result = MyAPFixed.to_uint64(); //Yields 333

コンパイル時のデータ型属性へのアクセス

ap_[u]fixed<> 型には、データ型のサイズと設定がコンパイル時に決定されるようにする複数のスタティック メンバーがあります。このデータ型には、static const メンバーである width、iwidth、qmode、および omode があります。

static const int width = _AP_W;
static const int iwidth = _AP_I;
static const ap_q_mode qmode = _AP_Q;
static const ap_o_mode omode = _AP_O;

これらのデータ メンバーは、既存の ap_[u]fixed<> 型から次の情報を抽出するために使用できます。

• width: データ型の幅。
• iwidth: データ型の整数部分の幅。
• qmode: データ型の量子化モード。
• omode: データ型のオーバーフロー モード。

これらのデータ メンバーを使用すると、たとえば既存の ap_[u]fixed<> 型のデータ幅を抽出して、コンパイル時に別の ap_[u]fixed<> 型を作成できます。

次の例は、変数 Res のサイズを、変数 Val1 および Val2 よりも 1 ビット大きくし、同じ量子化モードで定義します。

// Definition of basic data type
#define INPUT_DATA_WIDTH 12
#define IN_INTG_WIDTH 6
#define IN_QMODE AP_RND_ZERO
#define IN_OMODE AP_WRAP
typedef ap_fixed<INPUT_DATA_WIDTH, IN_INTG_WIDTH, IN_QMODE, IN_OMODE> data_t;
// Definition of variables 
data_t Val1, Val2;
// Res is automatically sized at run-time to be 1-bit greater than INPUT_DATA_WIDTH 
// The bit growth in Res will be in the integer bits
ap_int<data_t::width+1, data_t::iwidth+1, data_t::qmode, data_t::omode> Res = Val1 + 
Val2;

これにより、INPUT_DATA_WIDTH、IN_INTG_WIDTH、または data_t の量子化モードの値をアップデートした場合でも、Vitis HLS で加算によるビット増加が正しくモデリングされるようになります。