halcon #tuple用法

`
a:=[-10,100,130]
t:=[-0.5,0.5,1]

tuple_abs (a, Abs)
*计算一个元组的绝对值
*[10, 100, 130]

tuple_acos (t, ACos)
*计算一个元组的反余弦
*参数1：输入元组。 限制：-1<=t<=1
*[2.0944, 1.0472, 0.0]

tuple_add (a, t, Sum)
*两个元组相加
*[-10.5, 100.5, 131]

tuple_asin (t, ASin)
*计算一个元组的反余弦
*参数1：输入元组。 限制：-1<=t<=1
*[-0.523599, 0.523599, 1.5708]

tuple_atan (a, ATan)
*计算一个元组的反正切
*[-1.47113, 1.5608, 1.5631]

y:=[10,-10,10,5,0,10]
x:=[10,10,20,0,5,-10]
a:=[10.5,-10.5,0,3.0]
b:=[3.1415, 0,1.5708, 0.785]

tuple_atan2 (y, x, ATan)
*计算一个元组四个象限的反正切
*参数1：输入y值的元组
*参数2：输入x值的元组
*参数3：返回元组的反正切--单位：弧度
*说明：tanA=y/x， 则 A=arctany/x
*[0.785398, -0.785398, 0.5235]

tuple_ceil (a, Ceil)
*计算一个元组的上限函数--大于或等于元素的最小整数
*上限函数始终作为浮点数返回
*[11.0, -10.0, 0.0, 3.0]

tuple_cos (b, Cos)
*计算一个元组的余弦
*参数1：单位：弧度
*[-1.0, 1.0, -3.67321e-006, 0.707388]

tuple_cumul (y, Cumul)
*计算一个元组的累计和
*[10, 0, 10, 15, 15, 25]

y:=[1,2,10,5,0,10]
x:=[10,10,20,0,5,-10]
a:=[10.5,-10.5,0,3.0]
b:=[3.1415, 0,1.5708, 0.785]
c:=[2,1,-2,3,5,-10]

tuple_deg (b, Deg)
*将一个元组从弧度转换为角度

tuple_div (x, c, Quot)
*将两个元组相除
*[5, 10, -10, 0, 1, 1]

tuple_exp (y, Exp)
*计算以e为底的指数【eⁿ】
*参数1：指数
*[2.71828, 7.38906, 22026.5, 148.413, 1.0, 22026.5]

tuple_fabs (a, Abs)
*计算一个元组（例如浮点数）的绝对值
*[10.5, 10.5, 0.0, 3.0]

tuple_floor (a, Floor)
*返回小于等于元素的整数---地板函数
*[10.0, -11.0, 0.0, 3.0]

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

tuple_ldexp (y, c, Ldexp)
*计算两个元组的返回长双精度指数函数
*[4.0, 4.0, 2.5, 40.0, 0.0, 0.00976563]
*计算公式：看下面

b:=[2,1,20,3,5,10]

tuple_log (b, Log)
*自然对数
*自然对数是以常数e为底数的对数，记作lnN（N>0）

y:=[1,2,10,5,0,10]
b:=[2,1,20,3,5,10]
x:=[3.5,6,8.9,4,1.1,6.5]
c:=[2.8,1.4,20.3,3.5,5.9,10.0]

tuple_log10 (b, Log)
*底为10的对数
*[0.30103, 0.0, 1.30103, 0.477121, 0.69897, 1.0]

tuple_max2 (y, b, Max2)
*对应位置的最大值
*[2, 2, 20, 5, 5, 10]

tuple_min2 (y, b, Min2)
*对应位置的最小值
*[1, 1, 10, 3, 0, 10]

tuple_mod (y, b, Mod)
*功能：整型数相除的余数
*[1, 0, 10, 2, 0, 0]

tuple_fmod (x, c, Fmod)
*浮点数相除的余数
*[0.7, 0.4, 8.9, 0.5, 1.1, 6.5]

tuple_mult (b, x, Prod)
*两个元组相乘
*[7.0, 6, 178.0, 12, 5.5, 65.0]

tuple_neg (y, Neg)
*取反---乘-1

y:=[1,2,10,5,0,10]
b:=[2,1,20,3,5,10]
x:=[3.5,6,8.9,4,1.1,6.5]
c:=[2.8,1.4,20.3,3.5,5.9,10.0]

tuple_pow (b, y, Pow)
*冥函数
*参数1：底
*参数2：指数
*[2.0, 1.0, 1.024e+013, 243.0, 1.0, 1e+010]

指数为常数的函数称为幂函数。例如函数y=x0 、y=x1、y=x2、y=x-1等都是幂函数

y:=[1,2,10,5,0,10]
b:=[2,1,20,3,5,10]
x:=[3.5,6,8.9,4,1.1,6.5]
c:=[2.8,1.4,20.3,3.5,5.9,10.0]
a:=[90,180,45,0,30,270]
a1:=[1.5708, 3.14159, 0.785398, 0.0, 0.523599, 4.71239]
d:=[1,-2,10,-5,0,10]

tuple_rad (a, Rad)
*角度转换为弧度
*[1.5708, 3.14159, 0.785398, 0.0, 0.523599, 4.71239]

tuple_sgn (d, Sgn)
*计算一个元组的正负
*[1, -1, 1, -1, 0, 1]

tuple_sin (a1, Sin)
*正弦-->sin函数
*参数1：单位：弧度
*[1.0, 2.65359e-006, 0.707107, 0.0, 0.5, -1.0]

tuple_sqrt (b, Sqrt)
*平方根（二次方根）
*[1.41421, 1.0, 4.47214, 1.73205, 2.23607, 3.16228]

tuple_sub (x, y, Diff)
*相减
*[2.5, 4, -1.1, -1, 1.1, -3.5]

d:=[1,-2,10,-5,0,10]
tuple_tan (d, Tan)
*计算一个元组的正切
位操作
复制代码
a:=[3,2,1]
b:=[4,2,3]
tuple_band (a, b, BAnd)
*位与-->对应位都是1才是1
*[0, 2, 1]

tuple_bor (a, b, BOr)
*按位或-->对应位有1就是1
*[7, 2, 3]

tuple_bnot (a, BNot)
*逐位取逻辑非
*[-4, -3, -2]

tuple_bxor (a, b, BXor)
*异或-->如果a、b两个值不相同，则异或结果为1。如果a、b两个值相同，异或结果为0
*[7, 0, 2]

tuple_lsh (a, b, Lsh)
*逐位左移
*参数1：待移位的元组
*参数2：移位次数
*如果没有发生溢出，此操作相当于乘以2^b
*如果a为负值，结果取决于硬件
*如果移位为负数或大于32，则结果未定义
*[48, 8, 8]

tuple_rsh (a, b, Rsh)
*逐位右移
*相当于除以2^b
*如果a为负值，结果取决于硬件
*如果移位为负数或大于32，则结果未定义
*[0, 0, 0]

比较

a:=[3,2,1]
b:=[4,2,3]
c:=[4,3,3]

tuple_equal (a, b, Equal)
*两个元组是否相同
*0--不同 1--相同

tuple_greater (b, c, Greater)
*一个元组是否大于另一个元组
*按顺序比较
*0--b不大于c 1--b大于c

tuple_greater_equal (b, c, Greatereq)
*一个元组是否大于等于另一个
*0--b<c 1--b>=c

tuple_less (b, c, Less)
*一个元组是否小于另一个元组
0--b不小于c 1--b小于c

tuple_less_equal (b, c, Lesseq)
*一个元组是否小于等于另一个
*0--b>c 1--b<=c

tuple_not_equal (b, c, Nequal)
*两个元组是不是不等

• 0--相等 1--不等

转换

a:=[65,97,49]
b:=[4.5,-2.9,3.4567]
c:='6814031a'
d:='12345678'
e:=['A', 'a', '1']

tuple_chr (a, Chr)
*根据ASCII码将整型元组转换为字符
*参数1：ASCII吗
*['A', 'a', '1']

tuple_chrt (a, Chrt)
*根据ASCII码将整型元组转换为字符串
*'Aa1'

tuple_int (b, Int)
*一个元组转换为一个整型元组
*小数部分直接抛弃，不四舍五入
*[4, -2, 3]

tuple_is_number (c, IsNumber)
*检测一个字符串元组是否表示数字

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

tuple_number (d, Number)
*将一个字符串元组转换为一个数值
*如果d不是数字字符串，就返回原字符串
*12345678

tuple_ord (e, Ord)
*将长度为1的字符串的元组转换为它们相应的ASCII码元组
*[65, 97, 49]

a:=[-65,97.8,49,0]
f:='liming'
b:=[-65,97.8,49.2,0]
c:=-123456.8763
d:=254
e:=0xff

tuple_ords (f, Ords)
*将一个字符串的元组转换为它们ASCII码的元组
*[65, 97, 49]

tuple_real (a, Real)
*转换为浮点数
*[-65.0, 97.8, 49.0, 0.0]

tuple_round (b, Round)
*转换为整型数--四舍五入
*[-65, 98, 49, 0]

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, 3, 10, 20, 30]

tuple_gen_const (5, 0, Newtuple)
*创建一个特殊长度的元组和初始化它的元素
*参数1：新元组长度
*参数2：用于初始化元组元素的常量
*参数3：新元组
*[0, 0, 0, 0, 0]

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:=[1,2,3,0,4]
b:=[2,1,4,5,0]
c:=[5,0,3,0,0]

tuple_and (a, b, And)
*数值与--对应位数值都不等于0才是1
*[1, 1, 1, 0, 0]

tuple_not (a, Not)
*数值非---非0返回0,0返回1
*参数1：只能包含整数
*如果输入元组为空，则会引发异常
*[0, 0, 0, 1, 0]

tuple_or (a, c, Or)
*数值或--对应位有非0返回1，都是0返回0
*[1, 1, 1, 0, 1]

tuple_xor (a, c, Xor)
*数值异或
*对应位一个是0一个不是0时其结果是1，否则结果为0
*【相同是0，不同是1】
*[0, 1, 0, 0, 1]

选择

a:=[3,'liming',5,6,1,2,3,'liming',0]
b:=[3,'liming']
c:=[7,1]

tuple_find (a, b, Indices)
*返回参数2在参数1中出现的索引
*如果没有返回-1
*如果其中一个或两个输入元组都为空，则运算符返回一个空元组
*允许混合字符串和数字
*[0, 6]

tuple_first_n (a, 5, Selected)
*选择前面的元素，直到索引n[包含索引n的元素]
*参数2：索引n
*索引从0开始，总共返回索引+1个元素
*如果参数1为空，则会引发异常
*[3, 'liming', 5, 6, 1, 2]

tuple_last_n (a, 3, Selected1)
*选择从索引“n”开始到元组末尾的所有元素，包含索引n的元素
*元组元素的索引从0开始，如果Tuple为空，则会引发异常
*[6, 1, 2, 3, 'liming', 0]

tuple_remove (a, c, Reduced)
*移出索引n的元素
*参数2：需要移除的索引
*元组元素的索引从0开始，即第一个元组元素的索引为0。将忽略超出范围的重复项和索引
*如果元组为空，则运算符返回一个空元组
*[3, 5, 6, 1, 2, 3, 0]

tuple_select (a, c, Selected2)
*返回指定索引的元素
*参数2：需要返回的索引
*元组元素的索引从0开始
*如果Tuple为空，则会引发异常
*['liming', 'liming']

tuple_select_range (a, 3, 5, Selected3)
*返回指定索引区域的元素
*参数2：起始索引
*参数3：终止索引
*参数2和参数3的元素都包含；如果索引相等，则只选择一个元素
*如果Leftindex和Rightindex是空元组，则运算符返回空元组。如果这些参数或元组中只有一个是空元组，则会引发异常
*[6, 1, 2]

d:=[4,30,5,6,1,2,3,20,0]
tuple_select_rank (d,4, Selected4)
*先升序排序，再返回排序后指定索引的元素
*参数2：索引
*4

e:=['abc','liming','mKbc','5842']
f:=[1,2,0,3]
tuple_str_bit_select (e, 1, Selected5)
*返回指定索引的字符
*参数2：索引
*['b', 'i', 'K', '8']

g:=[0,0,1,1,1,2,0,1]
tuple_uniq (g, Uniq)
*连续相同元素只取一个
*允许在输入元组中混合字符串和数字
*[0, 1, 2, 0, 1]

字符串运算符

a:=['abc,mkb/jkb','tangu,liming/qwe']
b:=[',','/']

tuple_split (a, b, Substrings)
*分割字符串
*参数2：分隔符

•  如果就一个，那么所有元素都用这个分隔符
  

•  如果参数2与参数1元素个数相同，那么一一对应使用分隔符
  

*['abc', 'mkb/jkb', 'tangu,liming', 'qwe']

c:=[3,5]
tuple_str_first_n (a, c, Substring)
*从起始字符开始截取到指定索引位置(包含索引)
*参数2：索引
*['abc,', 'tangu,']

tuple_str_last_n (a, c, Substring1)
*从指定索引到末尾进行截取
*参数2：索引
*[',mkb/jkb', ',liming/qwe']

c1:=[',','/']
a1:=['ab/c,mk,b/jkb','tan/gu,liming/q,we']
tuple_strchr (a1, c1, Position)
*返回指定字符的索引--找到左边第一个匹配的字符就停止
*参数2：指定字符
*[4, 3]

tuple_strrchr(a1, c1, Position1)
*返回指定字符的索引--找到右边第一个匹配的字符就停止
*[7, 13]

a2:=['liming李明','tangu塘沽']
tuple_strlen (a2, Length)
*返回字符串的长度
*一个汉子算一个字符
*[8, 7]

a3:=['lim塘沽ing塘沽sgfe','ta李明ngu李明sdfghj']
c2:=['塘沽','李明']
tuple_strrstr (a3, c2, Position2)
*返回指定字符串的索引--找到右边第一个匹配的字符串就停止
*参数2：指定字符串
*[8, 7]

tuple_strstr(a3, c2, Position3)
*返回指定字符串的索引--找到左边第一个匹配的字符串就停止
*参数2：指定字符串
*[3, 2]