Thanks for your feedback!
Need to tell us more? Click here or use the Feedback button.

Is this page helpful?

Contents

引数
集約操作
フィルタ操作
数値演算
文字列操作
グループ化操作
変換操作
その他の操作
情報操作
関連項目

$VECTOROP (ObjectScript)

ObjectScript を通じて定義されたベクトルに対し、さまざまな操作を実行します。

Synopsis

Aggregate Operations

$VECTOROP("count", vexpr [ , bitexpr ] )
$VECTOROP("max", vexpr [ , bitexpr ] )
$VECTOROP("min", vexpr [ , bitexpr ] )
$VECTOROP("sum", vexpr [ , bitexpr ] )

Filter Operations

$VECTOROP("defined", vexpr)
$VECTOROP("undefined", vexpr)
$VECTOROP("<", vexpr, expr1)
$VECTOROP("<=", vexpr, expr1)
$VECTOROP(">", vexpr, expr1)
$VECTOROP(">=", vexpr, expr1)
$VECTOROP("=", vexpr, expr1)
$VECTOROP("!=", vexpr, expr1)
$VECTOROP("between", vexpr, expr1, expr2)

Vector-wise Filter Operations

$VECTOROP("v<", vexpr1, vexpr2)
$VECTOROP("v<=", vexpr1, vexpr2)
$VECTOROP("v>", vexpr1, vexpr2)
$VECTOROP("v>=", vexpr1, vexpr2)
$VECTOROP("v=", vexpr1, vexpr2)
$VECTOROP("v!=", vexpr1, vexpr2)
$VECTOROP("vbetween", vexpr1, vexpr2, vexpr3)

Numeric Operations

$VECTOROP("+", vexpr, expr [ , bitexpr ] )
$VECTOROP("-", vexpr, [ expr , bitexpr ] )
$VECTOROP("/", vexpr, expr [ , bitexpr ] )
$VECTOROP("*", vexpr, expr [ , bitexpr ] )
$VECTOROP("**", vexpr, expr [ , bitexpr ] )
$VECTOROP("#", vexpr, expr [ , bitexpr ] )
$VECTOROP("e-", vexpr, expr [ , bitexpr ] )
$VECTOROP("e/", vexpr, expr [ , bitexpr ] )
$VECTOROP("v+", vexpr1, vexpr2 [ , bitexpr ] )
$VECTOROP("v-", vexpr1, vexpr2 [ , bitexpr ] )
$VECTOROP("v/", vexpr1, vexpr2 [ , bitexpr ] )
$VECTOROP("v*", vexpr1, vexpr2 [ , bitexpr ] )
$VECTOROP("v**", vexpr1, vexpr2 [ , bitexpr ] )
$VECTOROP("v#", vexpr1, vexpr2 [ , bitexpr ] )
$VECTOROP("ceiling", vexpr)
$VECTOROP("floor", vexpr)
$VECTOROP("cosine-similarity", vexpr1, vexpr2 )
$VECTOROP("dot-product", vexpr1, vexpr2)

String Operations

$VECTOROP("_", vexpr, expr [ , bitexpr ] )
$VECTOROP("e_", vexpr, expr [ , bitexpr ] )
$VECTOROP("v_", vexpr1, vexpr2 [ , bitexpr ] )
$VECTOROP("lower", vexpr)
$VECTOROP("upper", vexpr)
$VECTOROP("substring", vexpr, intexpr1 [ , intexpr2 ... ] )
$VECTOROP("trim", vexpr)
$VECTOROP("triml", vexpr)
$VECTOROP("trimr", vexpr)

Grouping Operations

$VECTOROP("group", vexpr, bitexpr, array)
$VECTOROP("countg", vexpr1, vexpr2, array [ , bitexpr ] )
$VECTOROP("maxg", vexpr1, vexpr2, array [ , bitexpr ] )
$VECTOROP("ming", vexpr1, vexpr2, array [ , bitexpr ] )
$VECTOROP("sumg", vexpr1, vexpr2, array [ , bitexpr ] )
$VECTOROP("countgb", vexpr, bitexpr, array)

Conversion Operations

$VECTOROP("convert", vexpr, expr [ , restrict ] )
$VECTOROP("fromstring", str, type [ , flag [ , intexpr ]])

Miscellaneous Operations

$VECTOROP("distinct-values", vexpr, array)
$VECTOROP("length", vexpr)
$VECTOROP("mask", vexpr, expr)
$VECTOROP("positions", vexpr, bitexpr)
$VECTOROP("replace", vexpr, array)
$VECTOROP("set", vexpr, expr)
$VECTOROP("set", vexpr, expr, type, bitexpr)
$VECTOROP("vset", vexpr1, vexpr2, [ , bitexpr ] )

Informative Operations

$VECTOROP("bytesize", vexpr)
$VECTOROP("type", vexpr)

引数

引数	説明
vexpr	ベクトルとして評価する有効な ObjectScript 式。一部のベクトル操作では、このベクトルが特定の型である必要があります。
expr	有効な ObjectScript 式。ベクトル操作では、多くの場合、この引数が特定の型である必要があります。
bitexpr	$bit によって作成されたビット文字列式。多くの場合、これはベクトル操作のオプションの引数です。これが含まれている場合、bitexpr に対応する 1 の値があるベクトル内の位置でのみ、特定の操作が適用されます。
intexpr	整数に解決される有効な ObjectScript 式。
array	ベクトル操作でデータを入力する配列の名前。vectorop の呼び出しが行われる前に、未定義にすることができます。

省略形： $vop

集約操作

集約操作はベクトルを受け取り、数値を返します。1 つのベクトル全体で操作を実行します。ベクトル内のある位置が未定義の場合は、その位置は無視されます。

すべての集約操作に、オプションの 3 番目の引数 bitexpr があります。この引数を使用して、操作を実行する特定のベクトル要素を指定できます。これが含まれている場合、値 1 を持つビット文字列内の位置に対応する位置のベクトル要素のみが、集約操作に使用されます。

$VECTOROP("count", vexpr [ , bitexpr ] ) は、ベクトル vexpr 内の定義された要素の数をカウントします。未定義の要素は無視されます。結果として、返り値は常に、vexpr の長さ以下となります。
3 番目の引数が指定されている場合、定義された要素を含む位置が操作でカウントされるのは、bitexpr の同じ位置に値 1 がある場合のみです。
```
for i = 1:1:10 set $VECTOR(vec,i,"integer") = i  // defines a 10-element vector
write $VECTOROP("count",vec)  // writes 10
```
$VECTOROP("max", vexpr [ , bitexpr ] ) は、ベクトルのデータ型で vexpr の最大要素を返します。未定義の要素は無視されます。
3 番目の引数が指定されている場合、bitexpr が値 1 を持つベクトル内の要素が定義されている位置のみが、返される可能性のある最大値として考慮されます。
```
for i = 1:1:10 set $VECTOR(vec,i,"integer") = i
write $VECTOROP("max", vec)  // writes 10
```
$VECTOROP("min", vexpr [ , bitexpr ] ) は、ベクトルのデータ型で vexpr の最小要素を返します。未定義の要素は無視されます。
3 番目の引数が指定されている場合、bitexpr が値 1 を持つベクトル内の要素が定義されている位置のみが、返される可能性のある最小値として考慮されます。
```
for i = 1:1:10 set $VECTOR(vec,i,"integer") = i
write $VECTOROP("min",vec)  // writes 1
```
$VECTOROP("sum", vexpr [ , bitexpr ] ) は、ベクトル内のすべての要素を加算し、合計をベクトルのデータ型で返します。この操作は、文字列またはタイムスタンプのデータ型のベクトルで呼び出されると、<FUNCTION> エラーを発生させます。
3 番目の引数が指定されている場合、bitexpr が値 1 を持つベクトル内の要素が定義されている位置のみが、合計に加算されます。
```
for i = 1:1:10 set $VECTOR(vec,i,"integer") = i
write $VECTOROP("sum",vec)  // writes 55
```

フィルタ操作

$VECTOROP 操作では、ベクトルをフィルタ処理するための多くの操作を提供します。フィルタ操作には、主に標準とベクトル単位の 2 種類があります。標準のフィルタ操作は、リストや配列に対して実行されるフィルタ操作と同様に、ベクトルに対して実行されます。ベクトル単位のフィルタ操作は、2 つの異なるベクトルの同じ位置にある要素を比較し、特定の操作の条件を満たす要素を持つベクトルを返します。

いずれかの入力ベクトルが未定義であったり、空の文字列である場合は、空の文字列が返されます。引数がベクトルでないその他の場合 (引数が数値型の場合など)、この操作は<VECTOR> エラーを発生させます。

標準のフィルタ操作

フィルタ操作は、入力ベクトルと同じ長さのビット文字列を返します。ここで、指定された操作が対応する位置のベクトル内の引数をどのように評価するかに応じて、各ビットは 1 または 0 に設定されます。

$VECTOROP("defined", vexpr) は、入力ベクトルと同じ長さのビット文字列を返します。定義されているベクトル内の要素に対応する位置には 1、定義されていないベクトル内の要素に対応する位置には 0 が含まれます。
```
// vec = <1,,3,4,,6,,,9,10>
zwrite $VECTOROP("defined",vec)  // writes the bitstring 1011010011
```
$VECTOROP("undefined", vexpr) は、入力ベクトルと同じ長さのビット文字列を返します。定義されていないベクトル内の要素に対応する位置には 1、定義されているベクトル内の要素に対応する位置には 0 が含まれます。
```
// vec = <1,,3,4,,6,,,9,10>
zwrite $VECTOROP("undefined",vec)  // writes the bitstring 0100101100
```
$VECTOROP("<", vexpr, expr1) は、入力ベクトルと同じ長さのビット文字列を返します。expr1 の値より小さいベクトル内の要素に対応する位置には 1、expr1 の値以上のベクトル内の要素に対応する位置には 0 が含まれます。この操作では、定義されていない位置には 0 が返されます。
```
// vec = <1,,3,4,5,6,,,9,10>
zwrite $VECTOROP("<",vec, 5)  // writes the bitstring 1011000000
```
$VECTOROP("<=", vexpr, expr1) は、入力ベクトルと同じ長さのビット文字列を返します。expr1 の値以下のベクトル内の要素に対応する位置には 1、expr1 の値より大きいベクトル内の要素に対応する位置には 0 が含まれます。この操作では、定義されていない位置には 0 が返されます。
```
// vec = <1,,3,4,5,6,,,9,10>
zwrite $VECTOROP("<=",vec, 5)  // writes the bitstring 1011100000
```
$VECTOROP(">", vexpr, expr1) は、入力ベクトルと同じ長さのビット文字列を返します。expr1 の値より大きいベクトル内の要素に対応する位置には 1、expr1 の値以下のベクトル内の要素に対応する位置には 0 が含まれます。この操作では、定義されていない位置には 0 が返されます。
```
// vec = <1,,3,4,5,6,,,9,10>
zwrite $VECTOROP(">",vec, 5)  // writes the bitstring 0000010011
```
$VECTOROP(">=", vexpr, expr1) は、入力ベクトルと同じ長さのビット文字列を返します。expr1 の値以上のベクトル内の要素に対応する位置には 1、expr1 の値より小さいベクトル内の要素に対応する位置には 0 が含まれます。この操作では、定義されていない位置には 0 が返されます。
```
// vec = <1,,3,4,5,6,,,9,10>
zwrite $VECTOROP(">=",vec, 5)  // writes the bitstring 0000110011
```
$VECTOROP("=", vexpr, expr1) は、入力ベクトルと同じ長さのビット文字列を返します。expr1 の値に等しいベクトル内の要素に対応する位置には 1、expr1 の値に等しくないベクトル内の要素に対応する位置には 0 が含まれます。この操作では、定義されていない位置には 0 が返されます。
```
// vec = <1,,3,4,5,6,,,9,10>
zwrite $VECTOROP("=",vec, 5)  // writes the bitstring 0000100000
```
$VECTOROP("!=", vexpr, expr1) は、入力ベクトルと同じ長さのビット文字列を返します。expr1 の値に等しくないベクトル内の要素に対応する位置には 1、expr1 の値に等しいベクトル内の要素に対応する位置には 0 が含まれます。この操作では、定義されていない位置には 0 が返されます。
```
// vec = <1,,3,4,5,6,,,9,10>
zwrite $VECTOROP("!=",vec, 5)  // writes the bitstring 1111011111
```
$VECTOROP("between", vexpr, expr1, expr2) は、入力ベクトルと同じ長さのビット文字列を返します。expr1 の値以上、かつ、expr2 の値以下のベクトル内の要素に対応する位置には 1 が含まれます。expr1 と expr2 の値の間にないベクトル内の要素に対応する位置、および未定義の位置には 0 が返されます。
```
// vec = <1,,3,4,5,6,,,9,10>
zwrite $VECTOROP("between",vec, 3, 9)  // writes the bitstring 0011110010
```

ベクトル単位のフィルタ操作

ベクトル単位のフィルタ操作は、複数のベクトルを受け取り、入力ベクトルの対応する位置にある要素を比較する指定の演算子に基づいて、0 または 1 の値のビット文字列を返します。返されるビット文字列は、比較に使用された 2 つのベクトルのうち短い方と同じ長さになります。長い方のベクトルの余分な要素は無視されます。

入力ベクトルがすべて同じ型ではない場合、この操作は <FUNCTION> エラーを発生させます。

$VECTOROP("v<", vexpr1, vexpr2) は、vexpr1 の値が vexpr2 の対応する値より小さい場合、各位置での値が 1 のビット文字列を返します。それ以外の場合、値は 0 です。vexpr1 または vexpr2 のいずれかで要素が未定義の場合、ビット文字列内の対応する値は 0 です。
```
// vec1 = <1,2,1,2>
// vec2 = <2,1,1,2>
zwrite $VECTOROP("v<",vec1,vec2)  // writes 1000
```
$VECTOROP("v<=", vexpr1, vexpr2) は、vexpr1 の値が vexpr2 の対応する値以下の場合、各位置での値が 1 のビット文字列を返します。それ以外の場合、値は 0 です。vexpr1 または vexpr2 のいずれかで要素が未定義の場合、ビット文字列内の対応する値は 0 です。
```
// vec1 = <1,2,1,2>
// vec2 = <2,1,1,2>
zwrite $VECTOROP("v<=",vec1,vec2)  // writes 1011
```
$VECTOROP("v>", vexpr1, vexpr2) は、vexpr1 の値が vexpr2 の対応する値より大きい場合、各位置での値が 1 のビット文字列を返します。それ以外の場合、値は 0 です。vexpr1 または vexpr2 のいずれかで要素が未定義の場合、ビット文字列内の対応する値は 0 です。
```
// vec1 = <1,2,1,2>
// vec2 = <2,1,1,2>
zwrite $VECTOROP("v>",vec1,vec2)  // writes 0100
```
$VECTOROP("v>=", vexpr1, vexpr2) は、vexpr1 の値が vexpr2 の対応する値以上の場合、各位置での値が 1 のビット文字列を返します。それ以外の場合、値は 0 です。vexpr1 または vexpr2 のいずれかで要素が未定義の場合、ビット文字列内の対応する値は 0 です。
```
// vec1 = <1,2,1,2>
// vec2 = <2,1,1,2>
zwrite $VECTOROP("v>=",vec1,vec2)  // writes 0111
```
$VECTOROP("v=", vexpr1, vexpr2) は、vexpr1 の値が vexpr2 の対応する値と等しい場合、各位置での値が 1 のビット文字列を返します。それ以外の場合、値は 0 です。vexpr1 または vexpr2 のいずれかで要素が未定義の場合、ビット文字列内の対応する値は 0 です。
```
// vec1 = <1,2,1,2>
// vec2 = <2,1,1,2>
zwrite $VECTOROP("v=",vec1,vec2)  // writes 0011
```
$VECTOROP("v!=", vexpr1, vexpr2) は、vexpr1 の値が vexpr2 の対応する値と等しくない場合、各位置での値が 1 のビット文字列を返します。それ以外の場合、値は 0 です。vexpr1 または vexpr2 のいずれかで要素が未定義の場合、ビット文字列内の対応する値は 0 です。
```
// vec1 = <1,2,1,2>
// vec2 = <2,1,1,2>
zwrite $VECTOROP("v!=",vec1,vec2)  // writes 1100
```
$VECTOROP("vbetween", vexpr1, vexpr2, vexpr3) は、vexpr1 の値が vexpr2 の対応する値以上、かつ vexpr3 の対応する値以下の場合、各位置での値が 1 のビット文字列を返します。それ以外の場合、値は 0 です。vexpr1、vexpr2、または vexpr3 のいずれかで要素が未定義の場合、ビット文字列内の対応する値は 0 です。
```
// vec1 = <5,6,7>
// vec2 = <4,7,8>
// vec3 = <9,9,9>
zwrite $VECTOROP("vbetween",vec1,vec2,vec3)  // writes 100
```

数値演算

数値演算は入力ベクトルに対して算術演算を実行し、演算の引数で定義された算術式の結果を含む新しいベクトルを返します。ベクトル内のある位置で値が未定義の場合、結果として得られるベクトルのその位置の値は未定義となります。さらに、ベクトル引数が未定義または空の文字列の場合、これらの演算は空の文字列を返します。

ベクトル引数のデータ型が文字列の場合は、<FUNCTION> エラーがスローされます。

基本的な算術演算

基本的な算術演算はベクトルと単一の式を受け取ります。この式は暗黙的にベクトルのデータ型に強制されます。指定された値がベクトルのデータ型の範囲に合わない場合、この操作は <MAXNUMBER> エラーを発生させます。

基本的な算術演算では、オプションのビット文字列引数を指定できます。この引数が指定されている場合、演算はビット文字列の値 1 の位置にのみ適用され、結果としてこれらの位置のみが結果のベクトルで定義されます。

$VECTOROP("+", vexpr, expr [ , bitexpr ]) は、入力ベクトルと同じ長さおよび型で、定義されている vexpr の各要素に expr の値を加算したベクトルを返します。
この演算は、タイムスタンプ･データ型のベクトルに適用できます。この場合、expr は、vexpr の値に加算するマイクロ秒数です。
```
// vec = <4,6,7,10>
zwrite $VECTOROP("+",vec,7)  // writes <11,13,14,17>
```
$VECTOROP("-", vexpr [ , expr , bitexpr ] ) は、入力ベクトルと同じ長さおよび型で、定義されている vexpr の各要素から expr の値を減算したベクトルを返します。expr が指定されていない場合、返されるベクトルには、vexpr 内の定義されている各要素に "-" の符号を付けた値が含まれます。
この演算は、タイムスタンプ･データ型のベクトルに適用できます。この場合、expr は、vexpr の値から減算するマイクロ秒数です。
```
// vec = <4,6,7,10>
zwrite $VECTOROP("-",vec,7)  // writes <-3,-1,0,3>
```
$VECTOROP("-", vexpr ) は、vexpr 内の定義されている各要素に "-" の符号を付けた値が含まれるベクトルを返します。
```
// vec = <4,6,7,10>
zwrite $VECTOROP("-",vec)  // writes <-4,-6,-7,-10>
```
$VECTOROP("/", vexpr, expr [ , bitexpr ] ) は、入力ベクトルと同じ長さおよび型で、各要素が vexpr の各要素を expr の値で除算した商の値を持つベクトルを返します。
```
// vec = <4,6,7,10>
zwrite $VECTOROP("/",vec,2)  // writes <2,3,3,5>
```
$VECTOROP("*", vexpr, expr [ , bitexpr ] ) は、入力ベクトルと同じ長さおよび型で、定義されている expr の各要素に vexpr の値を乗算したベクトルを返します。
```
// vec = <4,6,7,10>
zwrite $VECTOROP("*",vec,2)  // writes <8,12,14,20>
```
$VECTOROP("**", vexpr, expr [ , bitexpr ] ) は、入力ベクトルと同じ長さおよび型で、定義されている expr の各要素の vexpr 乗のベクトルを返します。
```
// vec = <4,6,7,10>
zwrite $VECTOROP("**",vec,2)  // writes <16,36,49,100>
```
$VECTOROP("#", vexpr, expr [ , bitexpr ] ) は、入力ベクトルと同じ長さおよび型で、各要素が vexpr の各要素を expr の値で除算した余りの値を持つベクトルを返します。
```
// vec = <4,6,7,11>
zwrite $VECTOROP("#",vec,3)  // writes <1,0,1,2>
```
$VECTOROP("e-", vexpr , expr [ , bitexpr ] ) は、入力ベクトルと同じ長さおよび型で、expr から、定義されている vexpr の各要素の値を減算したベクトルを返します。
```
// vec = <4,6,7,10>
zwrite $VECTOROP("e-",vec,7)  // writes <3,1,0,-3>
```
$VECTOROP("e/", vexpr, expr [ , bitexpr ] ) は、入力ベクトルと同じ長さおよび型で、各要素が expr を vexpr の各要素の値で除算した商の値を持つベクトルを返します。
```
// vec = <4,6,7,10>
zwrite $VECTOROP("e/",vec,8)  // writes <2,1,1,0>
```

ベクトル単位の算術演算

ベクトル単位の算術演算は、2 つのベクトルを受け取り、対応する位置にある要素に対して指定された演算を適用します。返されるベクトルは、2 つの入力ベクトルのうち短い方の長さになります。必要な 2 つの引数のいずれかがベクトルではない場合、演算は <VECTOR> エラーを発生させます。

ベクトル単位の算術演算では、オプションのビット文字列引数を指定できます。この引数が指定されている場合、演算はビット文字列の値 1 の位置にのみ適用され、結果としてこれらの位置のみが結果のベクトルで定義されます。

$VECTOROP("v+", vexpr1, vexpr2 [ , bitexpr ] ) は、vexpr1 と vexpr2 の対応する位置にある要素を足し合わせたベクトルを返します。vexpr1 の型が integer、decimal、または double の場合、vexpr2 は同じ型を持つ必要があります。同じ型でない場合、演算は <FUNCTION> エラーを発生させます。
vexpr1 が timestamp 型のベクトルである場合、vexpr2 は integer 型のベクトルである必要があります。vexpr2 は、vexpr1 のタイムスタンプに加算するマイクロ秒数を表します。
```
// vec1 = <3,6,2,5>
// vec2 = <1,3,7,9>
zwrite $VECTOROP("v+",vec1,vec2)  // writes <4,9,9,14>
```
$VECTOROP("v-", vexpr1, vexpr2 [ , bitexpr ] ) は、vexpr2 の要素から vexpr1 の要素を減算したベクトルを返します。vexpr1 の型が integer、decimal、または double の場合、vexpr2 は同じ型を持つ必要があります。同じ型でない場合、演算は <FUNCTION> エラーを発生させます。
vexpr1 が timestamp 型のベクトルである場合、vexpr2 は integer 型のベクトルである必要があります。vexpr2 は、vexpr1 のタイムスタンプから減算するマイクロ秒数を表します。
```
// vec1 = <3,6,2,5>
// vec2 = <1,3,7,9>
zwrite $VECTOROP("v-",vec1,vec2)  // writes <2,3,-5,-4>
```
$VECTOROP("v/", vexpr1, vexpr2 [ , bitexpr ] ) は、vexpr1 の要素を vexpr2 の要素で除算したベクトルを返します。vexpr1 の型が integer、decimal、または double の場合、vexpr2 は同じ型を持つ必要があります。同じ型でない場合、演算は <FUNCTION> エラーを発生させます。vexpr1 と vexpr2 が整数のベクトルの場合、演算では整数の除算が実行されます。
```
// vec1 = <3,6,2,5>
// vec2 = <1,3,7,9>
zwrite $VECTOROP("v/",vec1,vec2)  // writes <3,2,0,0>
```
$VECTOROP("v*", vexpr1, vexpr2 [ , bitexpr ] ) は、vexpr1 の要素に vexpr2 の要素を乗算したベクトルを返します。vexpr1 の型が integer、decimal、または double の場合、vexpr2 は同じ型を持つ必要があります。同じ型でない場合、演算は <FUNCTION> エラーを発生させます。
```
// vec1 = <3,6,2,5>
// vec2 = <1,3,7,9>
write $VECTOROP("v*",vec1,vec2)  // writes <3,18,14,45>
```
$VECTOROP("v**", vexpr1, vexpr2 [ , bitexpr ] ) は、vexpr1 の要素の vexpr2 乗のベクトルを返します。vexpr1 の型が integer、decimal、または double の場合、vexpr2 は同じ型を持つ必要があります。同じ型でない場合、演算は <FUNCTION> エラーを発生させます。
```
// vec1 = <3,6,2,5>
// vec2 = <1,3,7,9>
zwrite $VECTOROP("v**",vec1,vec2)  // writes <3,216,128,1953125>
```
$VECTOROP("v#", vexpr1, vexpr2 [ , bitexpr ] ) は、vexpr1 の要素を vexpr2 の要素で除算した余りを含むベクトルを返します。vexpr1 の型が integer、decimal、または double の場合、vexpr2 は同じ型を持つ必要があります。同じ型でない場合、演算は <FUNCTION> エラーを発生させます。
```
// vec1 = <3,6,2,5>
// vec2 = <1,3,7,9>
zwrite $VECTOROP("v#",vec1,vec2)  // writes <0,0,2,5>
```

丸め演算

$VECTOROP("ceiling", vexpr) は、vexpr の各要素に切り上げ演算を適用した結果を要素の値とするベクトルを返します。vexpr 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義のままになります。vexpr が decimal または double 型のベクトルでない場合、演算は <FUNCTION> エラーを発生させます。
```
// vec = <2.4, 2.5, 2.7, 2.81, 2.19, 2.0>
zwrite $VECTOROP("ceiling",vec)  // writes <3,3,3,3,3,2>
```
$VECTOROP("floor", vexpr) は、vexpr の各要素に切り下げ演算を適用した結果を要素の値とするベクトルを返します。vexpr 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義のままになります。vexpr が decimal または double 型のベクトルでない場合、演算は <FUNCTION> エラーを発生させます。
```
// vec = <2.4, 2.5, 2.7, 2.81, 2.19, 2.0>
zwrite $VECTOROP("floor",vec)  // writes <2,2,2,2,2,2>
```

ベクトルの距離演算

$VECTOROP("cosine-similarity", vexpr1, vexpr2 ) は、2 つのベクトル間のコサイン類似度の値を返します。値 1 はベクトルが同一であることを示し、値 0 はベクトルが直交することを示します。
この演算は、decimal または double 型のデータを持つベクトルでのみ機能します。
```
// vec1 = <2.4, 2.5, 2.7, 2.81, 2.19, 2.0>
// vec2 = <1.1, 1.7, 1.3, 1.9, 1.33, 1.11>
write $VECTOROP("cosine-similarity",vec1, vec2)  // writes .988
```
$VECTOROP("dot-product", vexpr1, vexpr2 ) は、2 つのベクトル間のドット積を返します。値 1 はベクトルが同一であることを示し、値 0 はベクトルが直交することを示します。
この演算は、decimal または double 型のデータを持つベクトルでのみ機能します。
```
// vec1 = <.400, .417, .450, .468, .365, .333>
// vec2 = <.312, .483, .369, .539, .378, .315>
write $VECTOROP("dot-product",vec1,vec2)  // writes .987
```

文字列操作

文字列操作は、入力ベクトルと同じ長さで、各位置に、指定した文字列操作の結果に基づく要素値が含まれる文字列ベクトルを返します。ある位置で値が未定義の場合、結果として得られるベクトルのその位置の値は未定義となります。さらに、ベクトル引数が未定義または空の文字列の場合、これらの演算は空の文字列を返します。

ベクトル入力のデータ型が string でない場合、操作は <FUNCTION> エラーを発生させます。

連結操作

連結操作は、文字列ベクトルを受け取り、別の引数をベクトルの各要素に連結します。

$VECTOROP("_", vexpr, expr [ , bitexpr ] ) は、ベクトルの各定義済み要素に expr が連結されたベクトルを返します。vexpr 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義のままになります。
3 番目の引数が指定されている場合、vexpr と expr の要素の連結は、ベクトルに要素が定義されており、bitexpr の値が 1 である位置に対してのみ実行されます。
```
// vec = <"b","great","larg">
zwrite $VECTOROP("_",vec,"est")  // writes <"best","greatest","largest">
```
$VECTOROP("e_", vexpr, expr [ , bitexpr ] ) は、定義されている各要素が expr と連結されたベクトルを返します。vexpr 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義のままになります。
3 番目の引数が指定されている場合、expr と vexpr の要素の連結は、ベクトルに要素が定義されており、bitexpr の値が 1 である位置に対してのみ実行されます。
```
// vec = <"b","great","larg">
zwrite $VECTOROP("e_",vec,"est")  // writes <"estb","estgreat","estlarg">
```
$VECTOROP("v_", vexpr1, vexpr2 [ , bitexpr ] ) は、vexpr1 の定義されている各要素が vexpr2 の定義されている対応する要素と連結されたベクトルを返します。vexpr1 または vexpr2 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義になります。
3 番目の引数が指定されている場合、vexpr1 と vexpr2 の要素の連結は、両方のベクトルに要素が定義されており、bitexpr の値が 1 である位置に対してのみ実行されます。
```
// vec1 = <"take on", "take me", "I'll be">
// vec2 = <" me", " on", " gone">
zwrite $VECTOROP("v_",vec1,vec2)  // writes <"take on me","take me on","I'll be gone">
```

大文字/小文字の操作

大文字/小文字の操作は、ベクトル内の文字列の大文字/小文字を変更します。

$VECTOROP("lower", vexpr) は、vexpr の各要素が小文字に変換されたベクトルを返します。vexpr 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義のままになります。
```
// vec = <"UpPeR","UPPER","upper"
zwrite $VECTOROP("lower",vec)  // writes <"upper","upper","upper">
```
$VECTOROP("upper", vexpr) は、vexpr の各要素が大文字に変換されたベクトルを返します。vexpr 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義のままになります。
```
// vec = <"UpPeR","UPPER","upper"
zwrite $VECTOROP("upper",vec)  // writes <"UPPER","UPPER","UPPER">
```

部分文字列

$VECTOROP("substring", vexpr, intexpr1 [ , intexpr2 ] ) は、vexpr の定義された各要素から部分文字列を取得し、その部分文字列を含む新しいベクトルを返します。vexpr 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義のままになります。

部分文字列の範囲は、intexpr1 とオプションの intexpr2 によって決定されます。intexpr1 のみが指定されている場合、結果として得られる文字列には、intexpr1 の位置にある文字のみが含まれます。intexpr2 が指定されている場合、intexpr1 は部分文字列の開始位置を特定し、intexpr2 は部分文字列の終了位置を特定します。intexpr1 と intexpr2 の位置にある文字はどちらも部分文字列に含まれます。

intexpr1 と intexpr2 は、$VECTOR の構文と同様に、アスタリスク (*) とマイナス記号 (-) を使用して文字列の末尾からの位置を指定することで、文字列の末尾から指定できます。

intexpr1 が intexpr2 より大きい場合、この操作は空の文字列を返します。

intexpr2 が特定の文字列の長さより大きい場合、この操作はエラーを発生させるのではなく、intexpr1 で始まり文字列の末尾で終わる部分文字列を返します。

// vec = <"long","short",,,"headstrong","teleport">
zwrite $VECTOROP("substring",vec,3,6)
// writes <"ng","ort",,,"adst","lepo">

トリミング操作

トリミング操作は、文字列の先頭または末尾、あるいはその両方から空白 (スペースやタブなど) を削除します。

$VECTOROP("trim", vexpr) は、vexpr の各要素が先頭と末尾の両方でトリミングされたベクトルを返します。vexpr 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義のままになります。
```
// vec = <"  left", "right  ","  middle  ">
zwrite $VECTOROP("trim",vec)  // writes <"left","right","middle">
```
$VECTOROP("triml", vexpr) は、vexpr の各要素が先頭 (左側) でトリミングされたベクトルを返します。vexpr 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義のままになります。
```
// vec = <"  left", "right  ","  middle  ">
zwrite $VECTOROP("triml",vec)  // writes <"left","right  ","middle  ">
```
$VECTOROP("trimr", vexpr) は、vexpr の各要素が末尾 (右側) でトリミングされたベクトルを返します。vexpr 内のある位置が定義されていない場合、その位置は、結果のベクトルでも未定義のままになります。
```
// vec = <"  left", "right  ","  middle  ">
zwrite $VECTOROP("trimr",vec)  // writes <"  left","right","  middle">
```

グループ化操作

グループ化操作により、さまざまな操作をベクトルのサブセットに対して実行することができます。結果は多次元配列に格納されます。すべてのグループ化操作の戻り値は、出力配列に追加された新しいキーの数です。

基本的なグループ化

$VECTOROP("group", vexpr, bitexpr, array) は、bitexpr の対応する位置が 1 である vexpr の各値の添え字を、配列 array に入力します。false の bitexpr の位置に対応する vexpr の値は無視されます。

bitexpr の対応する位置が 1 の vexpr の位置で未定義のものがある場合、array は未定義に設定されます。配列に既に要素が定義されている場合、その配列はこの操作で未定義としてマークされませんが、新しい要素は追加されません。

vexpr が未定義または空の文字列の場合、bitexpr に 1 に設定されている位置があるかどうかに応じて、array の最上位ノードのみが変更される場合があります。

// vec = <10,8,6,15,3,17,18,2,7,100,101>
kill arr, bits
for i=1,4,5,7,9 set $bit(bits,i)=1
zwrite $VECTOROP("group",vec,bits,arr)  // writes ""
zwrite arr

arr(3)=""
arr(7)=""
arr(10)=""
arr(15)=""
arr(18)=""

ベクトルのグループ化

ベクトルのグループ化操作は、2 つのベクトル (vexpr1 と vexpr2)、多次元配列 (array)、およびオプションでビット文字列 (bitexpr) を受け取ります。データをグループ化した後、そのグループに対して指定の操作を実行し、結果を多次元配列に格納します。

vexpr2 内の要素は、vexpr1 の要素によって識別される、位置的に対応するグループに分割されます。例えば、vexpr2 の位置 5 の要素は、vexpr1 の位置 5 の値によって識別されるグループに属します。array には、vexpr1 の一意の値ごとに 1 つの添え字が含まれ、その添え字にグループの合計が格納されます。vexpr2 で定義されているが、vexpr1 では定義されていない位置は、array の最上位ノードに関連付けられたグループに属します。

array 内の既存の添え字は上書きされません。いずれかの添え字が vexpr1 の要素である場合、グループの合計値は、その添え字に既に格納されている値の末尾に追加されます。

オプションの bitexpr 引数が渡される場合、グループは、bitexpr が 1 の値を持つ vexpr2 の値に対してのみ形成されます。

$VECTOROP("countg", vexpr1, vexpr2, array [ , bitexpr ] ) は、グループ内の要素数をカウントし、それらを array の添え字に格納します。

// vec1 = <"g1","g2","g1","g1","g2","g2","g2","g2","g1">
// vec2 = <10,8,6,15,3,17,16,2,7,100,101>
kill arr
zwrite $VECTOROP("countg",vec1,vec2,arr)  // writes ""
zwrite arr

arr=2
arr("g1")=4
arr("g2")=5

$VECTOROP("maxg", vexpr1, vexpr2, array [ , bitexpr ] ) は、グループ内の最大値を見つけ、それらを array の添え字に格納します。

// vec1 = <"g1","g2","g1","g1","g2","g2","g2","g2","g1">
// vec2 = <10,8,6,15,3,17,16,2,7,100,101>
kill arr
zwrite $VECTOROP("maxg",vec1,vec2,arr)  // writes ""
zwrite arr

arr=101
arr("g1")=15
arr("g2")=17

$VECTOROP("ming", vexpr1, vexpr2, array [ , bitexpr ] ) は、グループ内の最小値を見つけ、それらを array の添え字に格納します。

// vec1 = <"g1","g2","g1","g1","g2","g2","g2","g2","g1">
// vec2 = <10,8,6,15,3,17,16,2,7,100,101>
kill arr
zwrite $VECTOROP("ming",vec1,vec2,arr)  // writes ""
zwrite arr

arr=100
arr("g1")=6
arr("g2")=2

$VECTOROP("sumg", vexpr1, vexpr2, array [ , bitexpr ] ) は、グループの合計を見つけ、それらを array の添え字に格納します。
vexpr2 の型が string または timestamp の場合、この操作は <FUNCTION> エラーを発生させます。
```
// vec1 = <"g1","g2","g1","g1","g2","g2","g2","g2","g1">
// vec2 = <10,8,6,15,3,17,16,2,7,100,101>
kill arr
zwrite $VECTOROP("sumg",vec1,vec2,arr)  // writes ""
zwrite arr
```
```
arr=201
arr("g1")=38
arr("g2")=46
```

ビットマップのグループ化

$VECTOROP("countgb", vexpr, bitexpr, array) は、1 の値を持つ bitexpr の位置に対応する位置のサブセットから、vexpr 内の同一の値をグループ化します。この操作は、vexpr のこのサブセットを添え字として array に追加し、サブセット内にこの値が出現する回数を格納します。ベクトルのグループ化操作と同様、この関数は、array 引数に値を入力し、返り値は未定義です。

// vec = <"x","y","x","y","x","y","y","y","x">
kill arr, bits
for i=1,3,4,7,8 set $bit(bits,i)=1
zwrite $VECTOROP("countgb",vec,bits,arr)  // writes ""
zwrite arr

arr("x")=2
arr("y")=3

変換操作

変換操作では、ある型から別の型にデータを変更できます。ベクトルをある型から別の型に変換したり、文字列をベクトルに変換したり、ベクトルを文字列に変換したりすることができます。

$VECTOROP("convert", vexpr, expr [ , restrict ] ) は、ObjectScript の変換規則に従って、vexpr の各要素が expr の型に強制変換された新しいベクトルを返します。vexpr 内の要素がターゲットの型の範囲に合わない場合、この操作は <MAXNUMBER> エラーを発生させます。expr は、文字列として表される有効なベクトル型である必要があります。
オプションの restrict 引数は、デフォルトでは 0 に設定されますが、これを 1 に設定すると、vexpr 内の対応する値が要求された型に適合しない位置では未定義の値を持つように、返されるベクトルを制限することができます。これが発生する可能性があるケースとして、以下の 3 つが挙げられます。
- vexpr 内の文字列値が有効な数値式ではない。
- 変換により精度が失われる (integer 型に変換する場合など)。
- <MAXNUMBER> エラーが発生する。
vexpr で未定義の位置は、返されるベクトルでも未定義です。
vexpr が未定義または空の文字列の場合、この操作は空の文字列を返します。vexpr がベクトルではない場合、または expr が有効なベクトル型に評価されない場合、この操作は <VECTOR> エラーを発生させます。
```
// vec = <"1", "one", "4", "seven", "10">
zwrite $VECTOROP("convert", vec, "int")  // writes <1,0,4,0,10>
```
```
// vec = <"1", "one", "4", "seven", "10">
zwrite $VECTOROP("convert", vec, "int", 1)  // writes <1,,4,,10>
```
$VECTOROP("fromstring", str, type [ , delimeter [ , flag [ , length ]]) は、区切られた要素を持つ文字列 str をベクトルに変換することで、指定した type のベクトルを返します。delimeter 引数でカスタムの区切り文字を指定できます。既定の区切り文字はコンマ (,) です。length 引数を指定すると、指定した要素の数に対応するようにベクトルが割り当てられます。length が 65536 より大きい場合、<VECTOR> が発生します。
flag 引数は 2 ビットのバイナリ・フラグで、各ビットが特定の動作を定義します。その結果、この引数に可能な値は、0 (既定の動作)、1、2、および 3 の 4 つのみとなります。最初のビットは、str 内で隣接する区切り文字 (つまり、返されるベクトルで省略された要素) の処理方法を指定します。2 番目のビットは、文字列内の引用符の処理方法を指定します。4 つのフラグの効果を、以下に説明します。
- 0 — 文字列内で省略された要素は、返されるベクトルでは空の文字列 ("") で表されます。また、区切られた部分文字列内の引用符は、ベクトルの対応する要素に保持されます。この動作は、返されるベクトルの指定の type が "string" の場合にのみ適用されます。
- 1 — 文字列内で省略された要素は、返されるベクトルでは未定義の要素として表されます。また、区切られた部分文字列内の引用符は、ベクトルの対応する要素に保持されます。この動作は、返されるベクトルの指定の type が "string" の場合にのみ適用されます。
- 2 — 文字列内で省略された要素は、返されるベクトルでは空の文字列 ("") で表されます。また、区切られた部分文字列の先頭と末尾の引用符は削除されますが、その部分文字列内の区切り文字は、分割するための区切り文字としては扱われません。代わりに、区切り文字を含む部分文字列は、ベクトルの要素に含められます。この動作は、返されるベクトルの指定の type が "string" の場合にのみ適用されます。
- 3 — 文字列内で省略された要素は、返されるベクトルでは未定義の要素として表されます。また、区切られた部分文字列の先頭と末尾の引用符は削除されますが、その部分文字列内の区切り文字は、分割するための区切り文字としては扱われません。代わりに、区切り文字を含む部分文字列は、ベクトルの要素に含められます。この動作は、返されるベクトルの指定の type が "string" の場合にのみ適用されます。
```
// str = "ab,cd,,e,"
zwrite $VECTOROP("fromstring",str,"string",",",0) // writes <"ab","cd","","e">
```
```
// str = "ab,cd,,e,"
zwrite $VECTOROP("fromstring",str,"string",",",1) // writes <"ab","cd",,"e">
```
```
q1 ;; "abc","",d,123,,"x""y","h,i",k
set str = $p($text(q1)," ;; ",2)
zwrite $VECTOROP("fromstring",str,"string",",",2) // writes <"abc","","d","123","","x""y","h,i","k">
```
```
q1 ;; "abc","",d,123,,"x""y","h,i",k
set str = $p($text(q1)," ;; ",2)
zwrite $VECTOROP("fromstring",str,"string",",",3) // writes <"abc",,"d","123",,"x""y","h,i","k">
```

その他の操作

InterSystems IRIS は、ベクトル内の情報の記述、ベクトルの型の変換、ベクトルの要素の設定など、さまざまな用途に使用できるベクトル操作を、他にも多数用意しています。

$VECTOROP("distinct-values", vexpr, array ) は、vexpr に格納されている一意の要素の数を返し、vexpr に格納されている一意の各値の添え字を、array に入力します。出力 array の各添え字の配列の値は、空の文字列です。
array に既に要素が格納されている場合は、新しい値が追加されます。array に、vexpr の一意の値の 1 つが既に格納されている場合、一意の要素のカウントがインクリメントされますが、配列の値は空の文字列で上書きされません。
array が空の文字列として入力されている場合、または vexpr の少なくとも 1 つの位置に空の文字列が値として格納されている場合、この操作により array は空の文字列に設定されます。
vexpr が未定義または空の文字列の場合、この操作はゼロを返し、array は変更されません。
```
// vec = <1,2,3,3,5>
write $VECTOROP("distinct-values",vec,arrayOut) // writes 4
zwrite arrayOut
//writes
// arrOut(1)=""
// arrOut(2)=""
// arrOut(3)=""
// arrOut(5)=""
```
$VECTOROP("length", vexpr) は、vexpr の長さを返します。ベクトルの長さは、暗黙的に、定義された要素を持つ最後の位置として定義されます。vexpr には、複数の未定義要素が含まれる場合があります。
vexpr が未定義または空の文字列の場合、この操作は 0 を返します。
```
for i = 2:2:10 set $VECTOR(vec,i,"integer") = i
write $VECTOROP("length",vec)  // writes 10
```
$VECTOROP("mask", vexpr, bitexpr) は、bitexpr が 0 の値を持つ未定義の位置がある vexpr と同じ型のベクトルを返します。結果として得られるベクトルの長さは、bitexpr となります。vexpr に定義された値があるすべての位置で bitexpr の値が 0 のため、結果のベクトルに未定義の要素しか含まれない場合は、空の文字列が返されます。
vexpr が未定義または空の文字列の場合、この操作は空の文字列を返します。さらに、bitexpr が vexpr より長い場合、この操作は空の文字列を返します。
```
for i = 1:1:10 set $VECTOR(vec,i,"integer") = i
for i=2,5,6,7,8,9 set $bit(bits,i)=1
zwrite $VECTOROP("mask",vec,bits)  // writes <,,3,,5,6,7,8,9>
```
$VECTOROP("positions", bitexpr) は、bitexpr が 1 である vexpr 内の各位置がその位置の整数自体に設定されている整数ベクトルを返します。bitexpr が 0 の位置は未定義です。
```
for i=2,3,4,6 set $bit(bits,i)=1
zwrite $VECTOROP("positions",bits)  // writes <,2,3,4,,6>
```
$VECTOROP("replace", vexpr, array) は、vexpr と同じ型、同じ長さの新しいベクトルを返します。ここで、array の添え字に対応する vexpr の各値は、array の添え字に格納されている値に置き換えられます。array の添え字でない値は変更されません。
```
// vec = <1,2,3,3,5>
// arr(1) = 11
// arr(3) = 13
// arr(5) = 15
// arr(6) = 16
zwrite $VECTOROP("replace",vec,arr)  // writes <11,2,13,13,15>
```
$VECTOROP("set", vexpr, expr) は、vexpr と同じ型および長さであるものの、各要素が expr に設定されている新しいベクトルを返します。expr の型は、強制的にベクトルの型に変換されます。指定された値がベクトルのデータ型の範囲に合わない場合、この操作は <MAXNUMBER> エラーを発生させます。
vexpr が未定義または空の文字列の場合、この操作は空の文字列を返します。vexpr は定義されている値だが、ベクトルでも空の文字列でもない場合、この操作は <VECTOR> エラーを発生させます。
```
// vec = <60,40,80,90>
$VECTOROP("set", vec, 500)  // writes <500,500,500,500>
```
$VECTOROP("set", vexpr, expr, type, bitexpr) は、vexpr と同じ型および長さの新しいベクトルを返します。ここで、指定された bitexpr が 1 の値を持つすべての位置は、expr に設定され、ObjectScript の変換規則を使用して、暗黙的にそのベクトルの型に強制的に変換されます。指定された値がベクトルのデータ型の範囲に合わない場合、この操作は <MAXNUMBER> エラーを発生させます。
返されるベクトルの長さは、vexpr の長さと bitexpr が 1 の値を持つ最後の位置のうち、長い方になります。
vexpr が未定義または空の文字列の場合、返されるベクトルの長さは、bitexpr が 1 の値を持つ最後の位置を介して定義されます。この場合、返されるベクトルの型は、type で指定される型になります。vexpr が定義されている場合、type はその型と一致する必要があります。type は常に有効なベクトルの型として定義される必要があり、定義されていない場合、この操作は <VECTOR> エラーを発生させます。
bitexpr が未定義または空の文字列の場合、返されるベクトルは、vexpr と同じになります。
vexpr が定義されているがベクトルではない場合、この操作は <VECTOR> エラーを発生させます。vexpr と bitexpr が未定義または空の文字列の場合、この操作は空の文字列を返します。
```
for i = 1:1:10 set $VECTOR(vec,i,"integer") = i
for i=1,2,3,4,5,6 set $bit(bits,i)=1
zwrite $VECTOROP("set",vec,16,"int",bits)
// writes <16,16,16,16,16,16,7,8,9,10>
```
$VECTOROP("vset", vexpr1, vexpr2 [ , bitexpr ] ) は、vexpr1 と同じ型および長さのベクトルを返します。ここで、各位置の要素は、vexpr2 の対応する値 (これが定義されている場合)、または vexpr1 の値 (vexpr2 の値が未定義の場合) に設定されます。vexpr1 が未定義または空の文字列の場合、この操作は vexpr2 のコピーを返します。
4 番目の引数が指定されている場合、この操作は、bitexpr で 1 の値に対応する位置に対してのみ実行されます。返されるベクトルの長さは、vexpr1 の長さ、または bitexpr が 1 の値を持ち、vexpr2 が定義されている最後の位置の、いずれか大きい方です。
オプションの bitexpr 引数が含まれているが、未定義または空の文字列である場合、この操作は、bitexpr が false の値のみを持つと想定し、vexpr1 のコピーを返します。vexpr2 内のある位置が、明示的に未定義であるか、bitexpr が vexpr2 より長いため、未定義である場合、結果のベクトルは、bitexpr が 1 の値を持つ位置で未定義の値を持ちます。vexpr1 が未定義または空の文字列の場合、この操作は、vexpr2 と同じ型で、指定された bitexpr が 1 の値を持つすべての位置が vexpr2 の対応する位置の要素の値に設定されたベクトルを返します。
```
// vec1 = <1,,3,4,,6>
// vec2 = <,2,10,11,,12>
zwrite $VECTOROP("vset",vec1,vec2)  // writes <1,2,10,11,,12>
```

情報操作

$VECTOROP("bytesize", vexpr) は、バイト数で表した vexpr の現在のサイズを返します。vexpr が未定義または空の文字列の場合、この操作は 0 を返します。
```
for i = 1:1:10 set $VECTOR(vec,i,"integer") = i
write $VECTOROP("bytesize",vec)  // writes 320
```
$VECTOROP("type", vexpr) は vexpr の型を文字列で返します。可能な値は、“integer”、“decimal”、“double”、“timestamp”、“string” です。vexpr が未定義または空の文字列の場合、この操作は空の文字列を返します。
```
for i = 1:1:10 set $VECTOR(vec,i,"integer") = i
write $VECTOROP("",vec)  // writes "integer"
```