数组运算

y:=[1, 2, 10, 5, 0, 10]


x:=[10, 10, 20, 0, 5, -10]


a:=[10.5, -10.5, 0 ,3]


b:=[3.1415, 0,1.5708, 0.785]


c:=[2, 1, -2, 3, 5, -10]


d:=[3, -10.5, 0, 5]






tuple_abs (a, Abs)


* 计算一个元组的绝对值


* 元组中的元素为整型，则返回绝对值也为整型，为浮点型，则返回浮点型，可以混合


* [10.5, 10.5, 0，3]


  


tuple_fabs (a, Fabs)

* 计算一个元组（例如浮点数）的绝对值

* 统一返回浮点型的绝对值

* [10.5, 10.5, 0.0, 3.0]





tuple_add (a, d, Sum)


* 等同于 Sum := a + b

* 两个元组对应元素相加

* 要保证参数1和参数2的元素个数（数组长度相同）才能进行相加，否则会引发异常

* [13.5，-21.0，0，8]




tuple_sub (a, d, Diff)


* 等同于 Diff:= a - b


* 两个元组对应元素相减


* 要保证参数1和参数2的元素个数（数组长度相同）才能进行相减，否则会引发异常


* [7.5, 0.0, 0 ,-2]


 


tuple_div (x, c, Quot)

* 等同于 Quot:= x / c

* 两个元组对应元素相除，要确保参数2中不能含有0元素，否则会引发异常

* 需要用tuple_find()查找参数2中是否含有0元素

* 要保证参数1和参数2的元素个数（数组长度相同）才能进行相减，否则会引发异常

* [5, 10, -10, 0, 1, 1]





tuple_mult (b, x, Prod)


* 等同于 Prod:= b * c


* 两个元组对应元素相乘


* 要保证参数1和参数2的元素个数（数组长度相同）才能进行相减，否则会引发异常


* [20.0, 10, -40, 0, 25, 100]




tuple_neg (y, Neg)


* 取反---乘-1


* [-1, -2, -10, -5, 0, -10]


数组位操作

数组比较

a:=[3,2,1] 

b:=[4,2,3]


c:=[4,3,3]


tuple_equal (a, b, Equal)


* 两个元组是否相同

* 0--不同    1--相同

 

tuple_not_equal (b, c, Nequal)

* 两个元组是不是不等

* 0--相同    1--不同

 ******** -elem

 

tuple_equal_elem (a, 2 , Equalem)

* 判断元祖中的每个元素是否等于参数2

* 参数3 ： 返回数组[0,1,0]

* 0--不同    1--相同




tuple_not_equal_elem (a, 2, Nequalem)


* 判断元祖中的每个元素是否不等于参数2

* 参数3 ： 返回数组[1,0,1]

* 0--相同    1--不同

 

tuple_greater (b, c, Greater)

* 一个元组是否大于另一个元组

* 按顺序比较

* 0--b<=c     1--b>c

 

tuple_greater_elem (a, 2, Greaterem)

* 判断元祖中的每个元素是否大于参数2

* 参数2 ： 不能传入多元素

* 参数3 ： 返回数组[1,0,0]

* 0--a<=2     1--a>2

****** 加上-equal




tuple_greater_equal


* 1--b>=c




tuple_greater_equal_elem


* 1--a>=2


******


 

tuple_less (b, c, Less)

* 一个元组是否小于另一个元组

* 按顺序比较

* 0--b>=c     1--b



tuple_less_elem (a, 2, Lessem)


* 判断元祖中的每个元素是否小于参数2


* 参数2 ： 不能传入多元素


* 参数3 ： 返回数组[0,0,1]


* 0--a>=2     1--a<2


 ****** 加上-equal


 

tuple_less_equal

* 1--b<=c




tuple_less_equal_elem


* 1--a<=2


******


数组转换

a:=[65,97,49] 

b:=[4.5,-2.9,3.4567]


c:='6814031a'


d:='12345678'


e:=['A', 'a', '1']


f:='liming'






tuple_chr (a, Chr)


* 根据ASCII码将整型元组转换为字符数组


* 参数1：ASCII码


* 参数2: 返回数组


* ['A', 'a', '1'] 





tuple_chrt (a, Chrt)


* 根据ASCII码将整型元组转换为字符串


* 参数2： 返回单个字


* 'Aa1'

 tuple_int (b, Int)

* 一个元组转换为一个整型元组

* 小数部分直接抛弃，不四舍五入

* [4, -2, 3] 

 

tuple_real (a, Real)

* 转换为浮点数

* [65.0, 97.8, 49.0]





tuple_round (b, Round)


* 转换为整型数--四舍五入


* [5，3, 3]


 


tuple_is_number (c, IsNumber)


* 检测一个字符串元组是否表示数字，只含有数字的字符串再算数字字符串


* 1--数字字符串   0--非数字字符串






tuple_number (d, Number)


* 将一个字符串元组转换为一个数值


* 如果d不是数字字符串，就返回原字符串


* 12345678






tuple_ord (e, Ord)


* 将长度为1的字符串的元组转换为它们相应的ASCII码元组


* 参数1： 字符串的长度只能为1，否则会引发异常


* [65, 97, 49]






tuple_ords (f, Ords)


* 将一个字符串的元组转换为它们ASCII码的元组


* 拆分成单个


* [108, 105, 109, 105, 110, 103]


 


tuple_string (f, '-10.3s', String)


* 转换为字符串


* 参数1：输入


* 参数2：格式


*     数值时：


*       '10.2f'   总长度10位，小数点2位   f表示浮点数


*       '-10.2f'   -表示左对齐  否则右对齐


*       '.7f'     总长度不限，小数点7位


*       '+10.3f'   +表示前面加上+-号


*       'x'        转化为小写16进制


*       'X'        转化为大写16进制


*       '.8d'       转化为十进制，总长度8位 


*     字符串时：


*        '10s'     转换为总长度10位的字符串


*        '-10s'    -表示左对齐  否则右对齐


*        '-10.3s'   总长度10位，截取前3个字符   'lim  

数组创建

a:=[1,2,3]


b:=[10,20,30]






tuple_concat (a, b, Concat)


* 两个数组合并，参数1在前，参数2在后


* [1, 2, 3, 10, 20, 30]


 

tuple_gen_const (5, 0, Newtuple)

* 创建一个特殊长度的元组并初始化它的元素

* 参数1：新元组长度

* 参数2：用于初始化元组元素的常量

* 参数3：新元组

* [0, 0, 0, 0, 0]

 

tuple_gen_sequence( : : Start, End, Step : Sequence)

* 生成具有等距值序列的元组

* 输入参数：

* Start ———— 起始值

* End ———— 截至值

* Step ———— 步长 ，可以为小数

* 输出参数：

* Sequence———— 输出的数组

 

tuple_rand (6, Rand)

* 返回0到1之间的随机数元组

* 参数1：要生成的元组的长度

* 参数2：随机数的元组

* [0.693658, 0.168389, 0.895945, 0.365523, 0.332642, 0.601562]

数组元素顺序

a:=[1,2,3]


b:=[10,20,30]


c:=[500,200,400]


tuple_inverse (b, Inverted)


* 将一个元组反置（反转）


* [30, 20, 10]


 

tuple_sort (c, Sorted)


* 按升序排序


* [200, 400, 500]


 

tuple_sort_index (c, Indices)


* 先按升序排序,返回排序后的元素在原元组中的索引(从0开始)


* [1, 2, 0]

数组特征

a:=[1,2,3]


b:=[10.2,20,30.4,80,90,60,50]


c:=[500,200,400]


 


tuple_deviation (a, Deviation)

* 返回元组元素的标准差

* 1.0




tuple_length (a, Length)


* 返回元组元素数目


* 3


 

tuple_max (c, Max) 


* 返回元组的最大元素


* 500


 

tuple_min (a, Min)


* 返回元组的最小元素


* 1


 

tuple_mean (a, Mean)


* 返回元组的平均值


* 2.0


 

tuple_median (b, Median)


* 返回一个元组元素的中值


* 50  


 

tuple_sum (a, Sum)


* 返回所有元素的和


* 6

数组选择

a:=[3,'tuple',5,6,1,2,3,'tuple',0]


b:=[3,'tuple']


c:=[7,1]


 


tuple_find (a, b, Indices)


* 返回参数2在参数1中出现的索引


* 如果没有返回-1


* 如果其中一个或两个输入元组都为空，则运算符返回一个空元组,


* 参数2可以有多个元素，但在查找时，也必须满足顺序。当b:=['tuple',3]则返回-1


* 允许混合字符串和数字


* [0, 6]


 

tuple_first_n (a, 5, Selected)


* 选择前面的元素，直到索引n [包含索引n的元素]


* 参数2：索引n


* 索引从0开始，总共返回索引+1个元素


* 如果参数1为空，则会引发异常


* [3, 'tuple', 5, 6, 1, 2]


 

tuple_last_n (a, 3, Selected1)


* 选择从索引“n”开始到元组末尾的所有元素 [包含索引n的元素]


* 元组元素的索引从0开始，如果Tuple为空，则会引发异常


* [6, 1, 2, 3, 'tuple', 0]


 

tuple_remove (a, c, Reduced)


* 移出指定索引的元素


* 参数2：需要移除的索引


* 元组元素的索引从0开始，即第一个元组元素的索引为0。


* 将忽略超出范围的索引和重复项


* 如果元组（参数1）为空，则运算符返回一个空元组


* [3, 5, 6, 1, 2, 3, 0]


 

tuple_select (a, c, Selected2)


* 返回指定索引的元素


* 参数2：需要返回的索引


* 元组元素的索引从0开始


* 如果参数1为空，则会引发异常


* ['tuple', 'tuple']


 

tuple_select_range (a, 3, 5, Selected3)


* 返回指定索引区域的元素


* 参数2：起始索引  Startindex


* 参数3：终止索引  Endindex


* 参数2和参数3的元素都包含；如果索引相等，则只选择一个元素


* 如果Startindex[]和Endindex[]是空元组，则运算符返回空元组


* Startindex和Endindex 只能含有一个元素，否则会引发异常


* 如果这些参数或元组中只有一个是空元组，则会引发异常


* [6, 1, 2]





d := [4,30,5,6,1,2,3,20,0]


 

tuple_select_rank (d, 4, Selected4)


* 先升序排序，再返回排序后指定索引的元素


* 参数1：不允许混合字符串


* 参数2：索引 


* 参数2只允许单个元素，否则会引发异常


* 4





e:=['abc','liming','mKbc','5842']


 

tuple_str_bit_select (e, 1, Selected5)


* 返回每个字符串中指定索引的字符


* 参数2：索引


* 参数2只允许单个元素，否则会引发异常


* 要是参数2的索引超过了字符串的索引范围，则返回['', i ,'','']空元素


* ['b', 'i', 'K', '8']





g:=[0,0,1,1,1,2,0,1]





tuple_uniq (g, Uniq)


* 连续且相同元素只取一个


* 允许在输入元组中混合字符串和数字


* [0, 1, 2, 0, 1]