出现这个提示是什么原因？Error：flash download failed -could not load file

eSDK CloudVC V600R019C10 接口参考 01 (SMC, Java Native) \SiteInfoEx(会场信息)\dialingMode字段是否指创建不可管理会场中的“连接模式”但是使用这个默认加的都是“拨出”（MCU呼叫会场）模式请问哪个参数可以使添加会场的时候“连接模式”可以选成“拨入”呼叫方式。默认为1。0：MCU 呼叫会场1：会场主动呼入说明：不指定该参数时，系统默认按照1 去值

软件可变性的相关思考（一）作者：陈星亮（华为云开天aPaaS专家）软件可变性（Software Variability）是指在一定上下文中一个软件系统被有效改变（扩展、配置、调整）的能力。在许多软件系统的开发运行阶段乃至整个生命周期中，软件可变性都是其设计开发者所要面对的基本问题。       在大多数系统中，可变性表现为软件在某个或某些可变点处对变体的绑定。其中可变点是指软件中可以发生变化（绑定变体）的位置，而变体则是变化发生时，人或机器可以在相应位置做出的选择。       可以看出，在软件的运行实例中，变化发生的位置、变化发生的程度是在设计阶段预定义的。而这种定义又在很大程度上依赖于软件的需求分析以及在此基础上做出的种种假设。系统虽然具有变体绑定能力来满足既定的需求，但可变性模型（可变点、变体以及它们之间的关系）本身没有变化，导致软件在应对变化的需求或环境时存在一定限制。       在传统意义上，软件运行时可变性模型被认为是静态的。在许多研究工作中，模型被以只读的方式访问，以支持软件适应外部的环境。人们将注意力集中在可变性绑定方面（即为什么（重新）绑定变体、绑定什么变体、怎样绑定），而忽视了对运行时可变性模型本身蕴含的限制的突破。随着计算机技术的发展进步、用户需求的增多及变化的加快、系统驻留环境的开放、外界对系统灵活性和可伸缩性要求的提高，这种限制显得愈加突出。       针对软件可变性，开发者们根据软件实现要求和成本投入，采取软件预留配置点、动态软件产品线、运行时可变性动态绑定、多变非核心功能的快速开发等方法来应对。1、软件预留配置点：软件预留配置点可以自动地根据环境的变化来调整自身。换言之，它可以收集和分析有关环境的信息，基于分析的结果决定是否改变自己的行为，如果是，再采取调整动作。系统设计者指出或假设系统所面对环境变化等信息，确定系统所能够感知和收集的环境数据，进而以一定的数据结构将其表示在计算机内，而后才能设计相应的算法对这些信息进行分析并做出决策。在执行环节对于自身的调整，实际上是软件在可变点处对于变体的动态绑定，这是其运行时可变性的表现。关键点：1）设计者难以在系统部署运行之前设想所有的需求或环境的变化，当超过预期的变化出现时，已经成型的系统无法自动地收集与其相关的信息。2）并未改变可变性要素的数量、属性或关系。只能在设计开发时预定的范围内，进行选择。2、动态软件产品线：动态软件产品线包括一组核心资产和从资产开发而来的一系列具有共同特征的软件产品。与传统软件产品线对比，动态软件产品线更关注软件的运行时可变性，本质上是建立具备可配置能力的一系列软件。关键点：1）产品线自身的设计者可以快速开发出具有运行时可变性的软件产品，并赋予其自主选择绑定变体的能力。2）其关注的运行时可变性大部分都是封闭的而非开放的，这意味着运行时可变性应对的是开发者在设计期设想的环境变化，导致软件产品难以应对超过预期的环境变化。3、运行时可变性动态绑定运行时可变性动态绑定机制描述一个运行中的软件如何在一个可变点绑定相应的变体，是软件可变性实现的核心。绑定机制涉及对构件内部结构和行为的调整，包括对子构件的重配置和动态绑定。关键点：1） 对构件行为的调整往往通过重新组织构件的工作流或是重新设置构件内部参数来实现。2） 对于突破了原有设计范围内的变化，需要能被系统识别，并自动生成对应的逻辑。4、多变非核心功能的快速开发为应对行业应用不断变化的情况，亦有思路是降低软件应用开发的难度，将软件的稳定的核心功能与多变的功能分开。对于多变非核心功能，以提供低码开发的方式，便于开发者能快速的根据诉求，进行近场快速开发并投入使用。关键点：1） 软件设计者需要能识别出稳定的核心功能、多变的非核心功能。并且能够在两者之间建立好连接。2） 提供便捷的工具，使得多变的非核心功能能够被近场开发者，甚至是使用者自己能快速实现。如何提升软件的可变性，让软件能够从容应对业务的变化，一直都是软件工程领域的一个重要话题。针对上述4种在应对软件可变性经常用到的方法，各自都有其特点，分别在不同的场景下使用。

虽然效率上还有点问题，但是功能上从逻辑上是已经完成了的。 限于本人水平有限，如果有不合理之处，你也别bb，因为谁也不比谁强多少。 认真的讲，可以揭示许多黑盒的本质问题，而不是对着CPU说明书照本学科。D_BIT_ZERO = '0' D_BIT_ONE = '1' D_TRUE = D_BIT_ONE D_FALSE = D_BIT_ZERO D_TEN_ONE = '1' D_TEN_TWO = '2' D_TEN_THREE = '3' D_TEN_FOUR = '4' D_TEN_FIVE = '5' D_TEN_SIX = '6' D_TEN_SEVEN = '7' D_TEN_EIGHT = '8' D_TEN_NINE = '9' D_TEN_ZERO = '0' D_ONE = '00000001' D_TWO = '00000010' D_THREE = '00000011' D_FOUR = '00000100' D_FIVE = '00000101' D_SIX = '00000110' D_SEVEN = '00000111' D_EIGHT = '00001000' D_NINE = '00001001' D_ZERO = '00000000' D_TEN = '00001010' D_LENGTH = D_EIGHT D_BLANK = '' def d_bit_is(a, b): """位操作-是""" if a == D_BIT_ZERO: if b == D_BIT_ZERO: return D_TRUE if b == D_BIT_ONE: return D_FALSE if a == D_BIT_ONE: if b == D_BIT_ZERO: return D_FALSE if b == D_BIT_ONE: return D_TRUE def d_bit_isnt(a, b): """位操作-非""" return d_bit_not(d_bit_is(a, b)) def d_bit_and(a, b): """位操作-与""" if a == D_BIT_ZERO: if b == D_BIT_ZERO: return D_FALSE if b == D_BIT_ONE: return D_FALSE if a == D_BIT_ONE: if b == D_BIT_ZERO: return D_FALSE if b == D_BIT_ONE: return D_TRUE def d_bit_not(a): """位操作-取反""" if a == D_BIT_ZERO: return D_BIT_ONE if a == D_BIT_ONE: return D_BIT_ZERO def d_bit_or(a, b): """位操作-或""" if a == D_BIT_ZERO: if b == D_BIT_ZERO: return D_FALSE if b == D_BIT_ONE: return D_TRUE if a == D_BIT_ONE: if b == D_BIT_ZERO: return D_TRUE if b == D_BIT_ONE: return D_TRUE def d_bit_xor(a, b): """ 位操作-异或 简单的说，位的异或结果就是相同为0，不同为1 """ return d_bit_or(d_bit_and(d_bit_not(a), b), d_bit_and(a, d_bit_not(b))) def d_xor(m, n): res = '' ml = list(m) nl = list(n) while ml and nl: mlp = ml.pop() nlp = nl.pop() xor = d_bit_xor(mlp, nlp) res = xor + res return res def d_is(m, n): """ 判断两个数相等 数的表示和值是满射，直接复用字符串的比较方法，提升效率 下面段1使用栈的方式更接近本质一点 段2无法避开index的数值运算 段3是异或串联的思路，只要有一位是不同的，串联结果即不同 段4的并行迭代貌似不是扁平了，暂时不讨论了 """ if m == n: return D_TRUE else: return D_FALSE # 段1 # res = D_TRUE # ml = list(m) # nl = list(n) # while ml: # mlp = ml.pop() # nlp = nl.pop() # if d_bit_isnt(mlp, nlp) == D_TRUE: # res = D_FALSE # break # return res # 段2 # res = D_TRUE # i = D_ZERO # # i in range(d_len(num1)) # while D_TRUE == D_TRUE: # if d_not(d_bit_and(d_less_or_is(D_ZERO, i), d_less(i, d_len(num1)))) == D_TRUE: # break # # b1 = num1[i] # b1 = d_index(num1, i) # # b2 = num2[i] # b2 = d_index(num2, i) # if d_bit_isnt(b1, b2) == D_TRUE: # res = D_FALSE # break # i = d_next(i) # 段3 # xor = d_xor(num1, num2) # # 当且仅当xor各位同为0时两数相等 # s_xor = d_serials_or(xor) # if s_xor == D_FALSE: # return D_TRUE # 段4 # for m, n in zip(num1, num2): # if d_bit_is(m, n) == D_FALSE: # return D_FALSE def d_s_and(num): """ 串联与 """ res = D_TRUE for n in num: res = d_bit_and(res, n) return res def d_serials_or(num): """ 串联或 """ res = D_FALSE for n in num: res = d_bit_or(res, n) return res def d_next(num): """ 位操作-后继 注意注释的代码，这里next调用了index,而index又调用了next，这是一个循环算法，导致栈溢出 TODO 自增溢出问题 """ res = '' num_l = list(num) carry = D_TRUE while num_l: b = num_l.pop() if carry == D_TRUE: # 吞掉进位标识 if d_bit_is(b, D_BIT_ZERO) == D_TRUE: carry = D_FALSE # 0变1，1变零（进位自旋） b = d_bit_not(b) res = b + res return res # 失败尝试1 # res = d_xor(num, D_ONE) # return res # 失败尝试2 # # index为-1即length-1 # # res = num[-1] # res = d_index(num, d_prev(d_len(num))) # # 进位标识 # b_carry = D_FALSE # # 如果最低位为1 # if d_bit_is(res, D_BIT_ONE) == D_TRUE: # # 结果最低位置0 # res = D_BIT_ZERO # # 进位 # b_carry = D_BIT_ONE # # 如果最低位为0 # if d_bit_is(res, D_BIT_ZERO) == D_TRUE: # # 结果最低位置1 # res = D_BIT_ONE # # i in range(1, len(num)) # i = D_ONE # while d_bit_and(d_less_or_is(D_ONE, i), d_less(i, d_len(num))) == D_TRUE: # # 自右往左取第i位 # # index = -(i+1) 即 length-1-i # index = d_minus(d_minus(d_len(num), i), D_ONE) # # bi = num[-i - 1] # -2,-3,...,-8 # bi = d_index(num, index) # # 如果第i位为0，且前i-1位进位的情况 # if d_bit_and(d_bit_is(bi, D_BIT_ZERO), d_bit_is(b_carry, D_BIT_ONE)) == D_TRUE: # # 本位置1 # bi = D_BIT_ONE # # 进位标识置0 # b_carry = D_BIT_ZERO # # 低位全置0 TODO # res = d_zero(d_len(res)) # # 如果第i位为1，且前i-1位进位的情况 # if d_bit_and(d_bit_is(bi, D_BIT_ONE), d_bit_is(b_carry, D_BIT_ONE)) == D_TRUE: # # 本位置0，继续进位 # bi = D_BIT_ZERO # res = bi + res # i = d_next(i) # # 溢出 # if b_carry == D_TRUE: # res = d_zero(d_len(res)) # return res def d_bit_less(a, b): """位操作-小于""" if d_bit_is(a, D_BIT_ONE) == D_TRUE: if d_bit_is(b, D_BIT_ZERO) == D_TRUE: return D_FALSE if d_bit_is(a, D_BIT_ZERO) == D_TRUE: if d_bit_is(b, D_BIT_ONE) == D_TRUE: return D_TRUE def d_less_compare(m, n): res = D_FALSE ml = list(m) nl = list(n) # TODO and # TODO 对于等于的讨论 while ml: mlp = ml.pop() nlp = nl.pop() if d_bit_less(mlp, nlp) == D_TRUE: res = D_TRUE if d_bit_less(nlp, mlp) == D_TRUE: res = D_FALSE # TODO 关于负数的特殊讨论 return res def d_less(m, n): if m == d_bound(d_len(m)): # TODO m = d_zero(d_len(m)) # TODO # 先进行有效位数的比较提高效率 m_len = d_len(d_cut_left_zeros(m)) n_len = d_len(d_cut_left_zeros(n)) m_len, n_len = d_alin(m_len, n_len) if d_less_compare(m_len, n_len) == D_TRUE: return D_TRUE return d_less_compare(m, n) def d_less_or_is(num1, num2): """小于等于""" dp = d_less(num1, num2) di = d_is(num1, num2) return d_bit_or(dp, di) def d_plus(m, n): """加法""" # 比较交换，保证左侧是大数 if d_less(m, n) == D_TRUE: m, n = n, m res = m # 溢出标识 of = D_FALSE zero = d_zero(d_len(m)) count = zero while d_less(count, n) == D_TRUE: # 溢出之后,res会归零重新处理 res = d_next(res) if d_bit_is(res, zero): of = D_TRUE # 即使溢出，也继续运算，方便后续处理 count = d_next(count) return res, of def d_zero(n=D_LENGTH): """返回n位的0""" # 8位直接返回常量 if d_is(n, D_EIGHT) == D_TRUE: return D_ZERO # 其他位数直接拼接 # TODO 关于异常输入的判断问题，何时抛异常，何时逻辑处理 else: res = D_BLANK i = D_ZERO while D_TRUE == D_TRUE: if d_is(i, n) == D_TRUE: break # TODO += res = res + D_BIT_ZERO i = d_next(i) return res def d_bound(n): """返回n位的越界数""" return d_ones(n) def d_one(n=D_LENGTH): """返回8位的1""" # TODO 校验方法调用 if d_is(n, D_EIGHT) == D_TRUE: return D_ONE else: res = D_ONE i = D_ZERO # 循环 n-1 次 while D_TRUE == D_TRUE: if d_is(i, n) == D_TRUE: break res = D_ZERO + res i = d_next(i) return res def d_ones(n=D_LENGTH): """返回8位全1""" return d_not(d_zero(n)) def d_one_neg(n=D_LENGTH): """返回负1""" # TODO 校验方法调用 return d_not(d_one(n)) def d_mul(m, n): """ 乘法 效率： 1.比较交换 """ if d_less(m, n): m, n = n, m res = m # 溢出标识 of = D_FALSE # 乘法扩容问题 i = d_next(d_zero(d_len(m))) while D_TRUE == D_TRUE: # jump = d_bit_not(d_less(i, n)) if d_is(i, n) == D_TRUE: break res, off = d_plus(res, m) i = d_next(i) # 越界 if off == D_TRUE: of = D_TRUE # TODO 溢出问题 return res, of def d_power(m, n): """幂""" res = m if d_is(n, d_zero(d_len(m))) == D_TRUE: return d_one(d_len(m)) count = d_one() # 执行n-1次 while D_TRUE == D_TRUE: if d_is(count, n) == D_TRUE: break res, _ = d_mul(res, m) count = d_next(count) return res def d_not(num): """并列取反""" res = D_BLANK for n in num: res = res + d_bit_not(n) return res def d_prev(num): """前一元素""" # one_neg = d_ones_neg() # res, _ = d_plus(num, one_neg) res = D_BLANK # 借位标识 borrow = D_TRUE nl = list(num) while nl: b = nl.pop() if borrow == D_TRUE: if d_bit_is(b, D_BIT_ONE) == D_TRUE: # 共轭 borrow = D_FALSE # 自旋 b = d_bit_not(b) res = b + res return res # # # # i in range(0, d_len(num)) # while d_bit_and(d_less_or_is(D_ZERO, i), d_less(i, d_len(num))) == D_TRUE: # # 自右往左取第i位 # index = d_minus(d_minus(d_len(num), D_ONE), i) # # bi = num[-(i + 1)] # -1, -2,-3,...,-8 # bi = d_index(num, index) # # 如果第i位为1，且前i-1位借位的情况 # if d_bit_and(d_bit_is(bi, D_BIT_ONE), borrow) == D_TRUE: # # 本位置0，借位标识置0，后续位数均置1 # bi = D_BIT_ZERO # borrow = D_FALSE # res = d_ones(d_len(res)) # res = bi + res # i = d_next(i) # # 溢出 # if borrow == D_TRUE: # res = d_zero(d_len(res)) # return res def d_minus(m, n): """减法""" res = m i = d_zero(d_len(m)) # 执行n次 while D_TRUE == D_TRUE: if d_is(i, n) == D_TRUE: break res = d_prev(res) i = d_next(i) # 对于结果为0的特殊处理（存在两个零的问题） TODO 待完善 if d_is(res, d_bound(d_len(n))) == D_TRUE: res = d_zero(d_len(m)) return res def d_right(num): """右移""" res = '0' i = D_ZERO # i in range(d_len(num) - 1) while D_TRUE == D_TRUE: if d_is(i, d_prev(d_len(num))) == D_TRUE: break res = res + d_index(num, i) i = d_next(i) return res def d_left(num): """左移""" res = '0' i = D_ZERO # i in range(d_len(num) - 1) while D_TRUE == D_TRUE: if d_is(i, d_prev(d_len(num))) == D_TRUE: break index = d_minus(d_minus(d_len(num), D_ONE), i) # res = num[-i - 1] + res res = d_index(num, index) + res i = d_next(i) return res def d_frac(m, n): """除法""" # 如： 127/10 127-10=117 if d_less(m, n) == D_TRUE: return d_zero(d_len(m)), m remainder = m quotient = d_zero(d_len(m)) while True: remainder = d_minus(remainder, n) quotient = d_next(quotient) if d_less(remainder, n) == D_TRUE: break return quotient, remainder def d_bin_exp(num): """整数的二进制表示""" exp = D_ZERO i = D_ZERO # i in range(d_len(num)): dlen = d_len(num) while D_TRUE == D_TRUE: if d_is(i, dlen) == D_TRUE: break index = d_minus(d_minus(dlen, D_ONE), i) # b = num[-i-1] b = d_index(num, index) bb = d_ten_to_bin(b) m, _ = d_mul(bb, d_power(D_TEN, i)) exp, _ = d_plus(exp, m) i = d_next(i) return exp def d_ten_exp(num): """ 整数的十进制表示 循环商10取余 以123为例说明： 123/10 = 12...3 12/10 = 1...2 1/10 = 0...1 则3为最低位 2为次位 1为最高位 """ # 以123为例说明： 123/10 = 12...3 12/10 = 1...2 1/10 = 0...1 # 3为最低位 2为次位 1为最高位 exp = D_BLANK while D_TRUE == D_TRUE: num, r = d_frac(num, D_TEN) bt = d_bin_to_ten(r) exp = bt + exp if d_is(D_ZERO, num) == D_TRUE: break if exp == D_BLANK: exp = D_BIT_ZERO return exp def d_cut_right_zeros_align(num): """截掉右侧的零，并对齐""" res = d_cut_right_zeros(num) i = D_ZERO # i in range(d_len(res), d_len(num)) dlen = d_len(num) while D_TRUE == D_TRUE: if d_is(i, dlen) == D_TRUE: break res = D_BIT_ZERO + res i = d_next(i) return res def d_cut_right_zeros(num): """截掉右侧的零""" res = D_BLANK join_flag = D_FALSE i = D_ZERO # i in range(d_len(num)) dlen = d_len(num) while D_TRUE == D_TRUE: if d_is(i, dlen) == D_TRUE: break index = d_minus(d_minus(dlen, D_ONE), i) # b = num[-i-1] b = d_index(num, index) # 出现第一个0后则不再继续截断 if join_flag == D_FALSE: if b == D_BIT_ONE: join_flag = D_TRUE if join_flag == D_TRUE: res = res + b i = d_next(i) return res def d_ten_dec_exp(num): """ 小数部分的十进制表示 放大位数，循环乘二进制的10，截取整数位，直至小数位为0 例如： 0.d1 d2 ... dn = d1*10^-1 + d2*10^-2 + ... + dn*10^-n d1.d2 ... dn = d1 + d2*10^-1 + ... + dn*10^-(n-1) TODO 效率低 """ exp = D_BLANK num_d = num while D_TRUE == D_TRUE: # num_d = 11111110 if d_is(num_d, D_ZERO) == D_TRUE: break num_ex = d_expand_left(num_d) num_mul, _ = d_mul(num_ex, d_expand_left(D_TEN)) num_i, num_d = d_float_bin_parts(num_mul) num_i_ten = d_bin_to_ten(num_i) exp = exp + num_i_ten return exp def d_ten_to_bin(num): """十进制位转为二进制位""" if num == D_TEN_ONE: return D_ONE if num == D_TEN_TWO: return D_TWO if num == D_TEN_THREE: return D_THREE if num == D_TEN_FOUR: return D_FOUR if num == D_TEN_FIVE: return D_FIVE if num == D_TEN_SIX: return D_SIX if num == D_TEN_SEVEN: return D_SEVEN if num == D_TEN_EIGHT: return D_EIGHT if num == D_TEN_NINE: return D_NINE if num == D_TEN_ZERO: return D_ZERO # 表示错误，方便调试，实际应该抛出一个异常 ex = Exception("二进制转换异常！") raise ex def d_bin_to_ten(num): """二进制位转为十进制位""" if d_is(num, D_ONE) == D_TRUE: return D_TEN_ONE if d_is(num, D_TWO) == D_TRUE: return D_TEN_TWO if d_is(num, D_THREE) == D_TRUE: return D_TEN_THREE if d_is(num, D_FOUR) == D_TRUE: return D_TEN_FOUR if d_is(num, D_FIVE) == D_TRUE: return D_TEN_FIVE if d_is(num, D_SIX) == D_TRUE: return D_TEN_SIX if d_is(num, D_SEVEN) == D_TRUE: return D_TEN_SEVEN if d_is(num, D_EIGHT) == D_TRUE: return D_TEN_EIGHT if d_is(num, D_NINE) == D_TRUE: return D_TEN_NINE if d_is(num, D_ZERO) == D_TRUE: return D_TEN_ZERO # 表示错误，方便调试，实际应该抛出一个异常 ex = Exception("十进制转换异常！") raise ex def d_float_ten_exp(num): """浮点数的十进制表示""" i, d = d_float_bin_parts(num) exp_int = d_ten_exp(i) exp_deci = d_ten_dec_exp(d) exp = exp_int + '.' + exp_deci return exp def d_float_bin_exp(num): """浮点数的二进制表示""" dot = '.' dlen = d_len(num) index = d_bin_exp(str(num.index(dot))) # i = num[0:index] i = d_slice(num, D_ZERO, index) # d = num[index + 1:] d = d_slice(num, d_next(index), dlen) exp_i = d_bin_exp(i) exp_d = d_bin_dec_exp(d) return exp_i + exp_d def d_cut_left_zeros(num): res = D_BLANK join_flag = D_FALSE i = D_ZERO # i in range(d_len(num)) dlen = d_len(num) while D_TRUE == D_TRUE: if d_is(i, dlen) == D_TRUE: break # b = num[i] b = d_index(num, i) # 出现第一个0后则不再继续截断 if join_flag == D_FALSE: if b == D_BIT_ONE: join_flag = D_TRUE if join_flag == D_TRUE: res = b + res i = d_next(i) return res def d_cut_left_zeros_align(num): """截掉左侧的零，然后右侧补零""" res = d_cut_left_zeros(num) i = d_len(res) # i in range(d_len(res), d_len(num)) dlen = d_len(num) while D_TRUE == D_TRUE: if d_is(i, dlen) == D_TRUE: break res = res + D_BIT_ZERO i = d_next(i) return res def d_align_right(num): """右侧补零""" # i in range(d_len(num), D_LENGTH) i = d_len(num) while D_TRUE == D_TRUE: if d_is(i, D_LENGTH) == D_TRUE: break num = num + D_BIT_ZERO i = d_next(i) return num def d_float_bin_parts(num): """浮点数整数部分和小数部分的二进制表示""" le = d_len(num) # d_len_half = int(d_len(num) / 2) d_len_half, _ = d_frac(le, D_TWO) # int_part = num[:d_len_half] int_part = d_slice(num, D_ZERO, d_len_half) # decimal_part = num[d_len_half:] # from to # 00000000 00001000 # from to # 00001000 00010000 decimal_part = d_slice(num, d_len_half, le) return int_part, decimal_part def d_mul_float(f1, f2): """ 浮点数乘法 以1.5*1.25为例: i1 = 1 d1=0.5 i2 = 1 d2=0.25 p1 = i1*i2 = 1 p2 = i1*d2 = 0.25 p3 = i2*d1 = 0.5 p4 = 0.5*0.25 = 0.125 """ # 预留浮点数越界标识 TODO 扩容处理， 科学计数法 of = D_FALSE i1, d1 = d_float_bin_parts(f1) i2, d2 = d_float_bin_parts(f2) # 记p1=i1*i2 p2=i1*d2 p3=i2*d1 p4=d1*d2 p1_i, _ = d_mul(i1, i2) # f1整数部分乘f2小数部分 p2_i, p2_d = d_mul_int_dec(i1, d2) # f2整数部分乘f1小数部分 p3_i, p3_d = d_mul_int_dec(i2, d1) # f1小数部分乘f2小数部分 p4_d = d_mul_dec(d1, d2) i, _ = d_plus(p1_i, p2_i) i, _ = d_plus(i, p3_i) d, _ = d_plus(p2_d, p3_d) d, _ = d_plus(d, p4_d) res = i + d return res def d_expand_left(num): """扩容，长度变为原来的二倍，前面补零""" return d_zero(d_len(num)) + num def d_expand_right(num): """扩容，长度变为原来的二倍，后面补零""" return num + d_zero(d_len(num)) def d_cut_right(num): """截掉右侧长度的一半""" # d_len_half = int(d_len(num) / 2) d_len_half, _ = d_frac(d_len(num), D_TWO) # res = num[:d_len] res = d_slice(num, D_ZERO, d_len_half) return res def d_cut_left(num): """截掉左侧长度的一半""" # d_len = int(d_len(num) / 2) d_len_half, _ = d_frac(d_len(num), D_TWO) # res = num[d_len:] res = d_slice(num, d_len_half, d_len(num)) return res def d_mul_int_dec(m, n): """ 整数部分与小数部分相乘 主要考虑越界问题，先扩充位数，再相乘，然后截出整数和小数部分 """ m_ex = d_expand_left(m) n_ex = d_expand_left(n) num, _ = d_mul(m_ex, n_ex) i, d = d_float_bin_parts(num) return i, d def d_mul_dec(m, n): """ 小数部分相乘 0.m * 0.n = m/10 * n/10 = mn/100 """ m_cut = d_cut_right_zeros(m) n_cut = d_cut_right_zeros(n) ma, na = d_alin(m_cut, n_cut) res, _ = d_mul(ma, na) res = d_align_right(res) res = d_right(res) res = d_right(res) return res def d_alin(m, n): """ 两个数对齐 以长度较大的数为基准 """ if d_len(m) < d_len(n): i = D_ZERO # i in range(d_len(n) - d_len(m)) max = d_minus(d_len(n), d_len(m)) while D_TRUE == D_TRUE: if d_is(i, max) == D_TRUE: break m = D_BIT_ZERO + m i = d_next(i) if d_len(m) > d_len(n): i = D_ZERO # i in range(d_len(m) - d_len(n)) max = d_minus(d_len(m), d_len(n)) while D_TRUE == D_TRUE: if d_is(i, max) == D_TRUE: break n = D_BIT_ZERO + n i = d_next(i) return m, n def d_align_right(num): """右侧补零""" i = D_ZERO # i >=0 且 i < D_LENGTH 即i in range(0, D_LENGTH) while D_TRUE == D_TRUE: if d_is(i, D_LENGTH) == D_TRUE: break num = num + D_BIT_ZERO i = d_next(i) return num def d_len(o_set): """ 返回num长度 num可以是任意的有序集合，只需提供一个遍历方法 """ res = D_ZERO for n in o_set: res = d_next(res) return res def d_index_of(o_set, e): """ 返回o_set中元素e的索引 如果不存在则返回负一(注意不是-1) """ i = D_ZERO for n in o_set: if d_is(n, e) == D_TRUE: return i i = d_next(i) return d_one_neg() def d_equal(o1, o2): """ 比较两个集合是否相等 """ i1 = D_ZERO for e1 in o1: i2 = D_ZERO for e2 in o2: if d_is(i2, i1) == D_TRUE: break i2 = d_next(i2) # 元素比较是集合的应有之义 if not e1 == e2: return D_FALSE i1 = d_next(i1) return D_TRUE def d_index(o_set, index): """ 返回index位置的o_set集合元素 index从0开始 """ # TODO 关于ZERO长度不足的问题 # 关于负索引，-i即length-i-1 # TODO 关于负数的规定 i = D_ZERO # while d_bit_and(d_less_or_is(D_ZERO, i), d_less(i, d_len(o_set))) == D_TRUE: for n in o_set: if d_is(i, index) == D_TRUE: return n i = d_next(i) return '-1' def d_slice(o_set, index_from, index_to): res = D_BLANK i = D_ZERO for n in o_set: if d_bit_and(d_less_or_is(index_from, i), d_less(i, index_to)) == D_TRUE: res = res + n i = d_next(i) return res def d_bin_dec_exp(num): # 25 = 2*10^2 + 5*10^1 """ 十进制转二进制小数部分表示 首先取各十进制位t1 t2 ... tn 对于一个形如.t1 t2 ... tn的十进制数，其值为 t1*10^-1 + t2*10^-2 +... + tn*10^-n 乘以10^n转为t1*10^(n-1) + t2*10(n-2) + ... + tn 求出此数的二进制表示，然后除以10^n的二进制表示 如0.25，放大100倍得25 25 = (d*2^-1 + d*2^-2 + ... + d*2^-n) * 100 两侧再同时乘以 2^n 25 * 2^n = (d*2^(n-1) + d*2^(n-2) + ... + d) * 100 然后再用(25 * 2^n)/100，得整数即为要求的小数部分 这里的越界问题用增加位数处理 """ num_bin = d_bin_exp(num) scale_idx = d_bin_exp(str(len(num))) scale = d_power(D_TEN, scale_idx) num_bin_ex = d_expand_left(num_bin) d_ones_expand = d_next(d_expand_left(d_ones())) mul_ex, _ = d_mul(num_bin_ex, d_ones_expand) scale_ex = d_expand_left(scale) q, _ = d_frac(mul_ex, scale_ex) res = d_cut_left(q) return res def test(): global D_LENGTH # test_d_ten_dec_exp() # pass # test_d_mul() # pass # test_d_bin_dec_exp() # pass # test_d_mul_float() # TODO # test_d_float_bin_exp() # pass # test_d_bin_exp() # pass # test_d_float_ten_exp() # pass # test_d_ten_exp() # pass # test_d_next() # pass # test_d_frac() # pass # test_d_minus() # pass # test_d_ones_neg() # pass # test_d_prev() # pass # test_d_plus() # pass # test_d_len() # pass # test_d_index() # pass # test_d_xor() # pass # test_d_bit_xor() # pass # test_d_less() # pass # test_d_zero() # pass # test_py() # test_d_power() # pass def test_d_power(): m = '00001010' n = '00000010' r = d_power(m, n) print(d_ten_exp(r)) def test_d_zero(): n = D_TEN r = d_zero(n) print(r) def test_d_less(): m = '0000000000000001' n = '0000000000001010' r = d_less(m, n) print(r) def test_d_plus(): m = '00000010' n = '00000111' r, _ = d_plus(m, n) print(r) def test_py(): s = '123' sl = list(s) print(sl.pop()) def test_d_bit_xor(): m = '1' n = '1' r = d_bit_xor(m, n) # 0 print(r) m = '0' n = '0' r = d_bit_xor(m, n) # 0 print(r) m = '1' n = '0' r = d_bit_xor(m, n) # 1 print(r) m = '0' n = '1' r = d_bit_xor(m, n) # 1 print(r) def test_d_is(): num1 = "00000000" num2 = "00000010" r = d_is(num1, num2) print(r) def test_d_xor(): # m = n 当且仅当 m xor n = 零 # m = '00000000' # n = '00000000' # r = d_xor(m, n) # # 00000000 # print(r) # m = '11111111' # n = '11111111' # r = d_xor(m, n) # print(r) m = '11111011' n = '11111011' r = d_xor(m, n) print(r) def test_d_index(): num = '123' index = D_TWO r = d_index(num, index) print(r) def test_d_len(): num = '123' l = d_len(num) print(l) def test_d_ten_dec_exp(): num = '00100000' r = d_ten_dec_exp(num) print(r) def test_d_mul(): # m = '4' # n = '4' # m_bin = d_bin_exp(m) # n_bin = d_bin_exp(n) # r, o = d_mul(m_bin, n_bin) # r_ten = d_ten_exp(r) # print(r_ten) # '0000000011111110' # '0000000000001010' m_bin = '0000000011111110' n_bin = '0000000000001010' r, o = d_mul(m_bin, n_bin) # 10011110110 # 0000000100010000' # r_ten = d_ten_exp(r) print(r) def test_d_bin_dec_exp(): m = '25' r = d_bin_dec_exp(m) print(r) def test_d_mul_float(): m = '10.5' n = '10.25' # m = d_float_bin_exp(m) m = '0000101010000000' # n = d_float_bin_exp(n) n = '0000101001000000' r = d_mul_float(m, n) # rt = d_float_ten_exp(r) print(r) def test_d_float_bin_exp(): m = '1.01' r = d_float_bin_exp(m) print(r) def test_d_bin_exp(): m = '127' r = d_bin_exp(m) print(r) def test_d_float_ten_exp(): # '7654321001234567' m = '0000000100011001' r = d_float_ten_exp(m) print(r) m = '0000000110000000' r = d_float_ten_exp(m) print(r) def test_d_ten_exp(): m = '01111111' r = d_ten_exp(m) print(r) def test_d_next(): m = '11111111' r = d_next(m) print('test_d_next: ', r) def test_d_prev(): # m = '01111111' # r = d_prev(m) # print(r) # m = '11111111' # r = d_prev(m) # print(r) m = '00001010' r = d_prev(m) print(r) def test_d_ones_neg(): r = d_one_neg(D_LENGTH) print(r) def test_d_minus(): m = '00000000' n = '00000010' r = d_minus(m, n) print("test_d_minus:", r) def test_d_frac(): m = '01111111' # 127 n = '00001010' # 10 d, r = d_frac(m, n) print("test_d_frac:", d_ten_exp(d), d_ten_exp(r)) def pi_ele(k): kex = d_expand_right(k) ONE = d_expand_right(D_ONE) TWO = d_expand_right(D_TWO) dm, _ = d_mul(TWO, kex) dp, _ = d_plus(dm, ONE) res, _ = d_frac(ONE, dp) return res def pi(k): # pi / 4 = 1 - 1/3 + 1/5 - 1/7 + ..... + (-1)^k (1 / (2k+1) ) + .... pi = d_expand_left(D_ZERO) i = D_ZERO while D_TRUE == D_TRUE: if d_is(i, k) == D_TRUE: break _, r = d_frac(i, D_TWO) if d_is(r, D_ZERO): pi = d_plus(pi, pi_ele(i)) else: pi = d_minus(pi, pi_ele(i)) i = d_next(i) print(pi) # 主方法 if __name__ == '__main__': # TODO 科学计数法解决乘法效率问题 test() pi(D_FOUR)

正在直播！2022华为开发者大赛·中国区·黑龙江区域启动仪式开始了！齐聚龙江，蓄势待发创想无限，邀你挑战↓↓↓点击观看视频直播

我们公司有一个流程；电话呼入流程，然后在流程外呼一个固话号码；有2个问题麻烦帮忙解答一下：1：如何在流程中判断固定电话的占线，久不应答，拒接这三种情况2：固话占线或久不应答时，首层欢迎语放音收号后事件处理cell(cell的id869，如下图)事件过程，多达8秒，影响用户体验；流程源文件见附件；

【功能模块】工作项中的统计【操作步骤&问题现象】1、点击统计中的新建报表，点击自定义报表2、数据设置中的分析维度、汇总项内容较少，想要增加自定义的数据【截图信息】【日志信息】（可选，上传日志内容或者附件）

大型项目周期长、规模大、涉及范围广、风险因素数量多且种类繁杂，在项目进行期间会产生多种多样的风险，比如成本、进度、质量等风险。那么，项目风险事件如何及时监测、提早预警，快速反应，避免损失？泛微协助组织用数字化的方式，实现项目风险智能识别，主动预警，实时监控；建立项目风险库，对项目验收超期、项目需求变更、项目付款延期等风险进行提醒。发现、处置、整改过程全周期记录，避免损失。泛微低代码构建项目风险管控平台项目阶段细化管理，实时监控对于大型项目，泛微通过划分项目阶段，对每个项目阶段进行监控，统计风险信息，精细化项目管理。（项目阶段管控）按各个项目所处阶段形成图表，清晰统计展现，可详细查看每次风险评分信息和评分历史记录列表。（风险统计）风险预设，及时预警通过预先设置规则公式，进行风险的识别判断，识别出的风险自动归类形成风险规则库。风险可通过门户、流程等多种方式提醒负责人，系统自动推送预警、问题自动认领。处理通过流程进行，过程有痕迹，事后可追踪，事毕形成处理档案库，方便后续查阅。（风险库）风险专业评分由于在风险识别阶段的主要任务是找出各种潜在的危险并做出对其后果的定性估量，主要依靠专家进行风险识别评分。项目人员建立项目风险评估后，需要专业评分人员进行评分，形成流程直接推动给相应专家，即可参与评分。（风险评分）风险上报风险评分通过后，该项目风险自动进行上报，形成风险库。风险库中可快速、穿透查询风险评分过程、数据和详情信息。（风险上报库）有效管控项目过程中的各类风险① 防项目进度超期风险泛微以项目生命周期为基础，围绕执行中的问题、变化、时间等因素，以流程穿透项目过程，岗位配合度、各环节执行效率，直观展示、信息透明。（项目进度）并且可将项目分解为任务，任务的负责人、时间安排、进展情况台账一一记录。项目、任务都有时间节点，项目人员通过流程汇报进度，反馈问题，确保项目质量安全，防止超期。② 防项目质量问题风险泛微为项目人员提供专门的问题提交通道，用手机就能随时反映现场情况，确保项目质量安全。项目人员通过企业微信与客户建立联系，随时推送项目关键信息，开放项目进度，分享项目文档，让客户更安心，减少项目质量风险，保质保量。③ 防项目财务风险预算成本防超出：泛微以项目为核心，从多个维度将各类成本汇总，让项目经理知道哪一块成本高、费用投放比例等。通过对项目采购及人员成本的动态统计分析，对项目预算进行实时监控。泛微OA系统以项目为维度进行预算费用控制，通过预算管控、流程管控、定额管控等方式实现全方位、精细化费用管控体系。（项目预算编制）合同收款执行合规化：通过项目进度联动制合同的收款执行、收入确认执行，用数字化的方式让项目收款、付款规范化。应收、收款管理台账完整清晰记录合同收款条件、余额台账等信息；系统根据项目进度自动触发收款提醒及收入确认，可追溯，可控制。（合同收付款管理）④ 防项目人员流失风险为了防止因为项目人员离职而导致项目进度停滞不前，可以直接通过企业微信把离职人员的客户分配给其他项目人员继续跟进。原有的项目文档、服务记录、项目进度、客户需求、备注一键同步交接，确保服务不中断，项目资源不流失。⑤ 防项目知识丢失风险项目文档自动进行汇总形成资料库，查找方便，也避免人员离职导致组织知识资产丢失的风险。价值总结泛微数字化的项目风险管理方案，助力组织项目风险及时监测、提早预警，快速反应，减少损失。

一、技术阅读文章  hw_008619970710721_02二、破冰实践Demo  hw_008619970710721_021.发票文字识别Demo  hw_008619970710721_022.安卓应用检测Demo  hw_008619970710721_02三、沙箱实验  hw_008619970710721_021.代码上云实验  hw_008619970710721_022.黑白棋游戏开发实验  hw_008619970710721_02

创新无限，一切皆服务华为云在本届华为伙伴暨开发者大会继发布了15大云服务新能力后还在今天的技术论坛上带来了重磅技术解读和更多黑科技「一切皆服务」华为云云原生2.0全景图再升级为赋能云原生企业智能升级，实现“资源高效、极致体验、万物互联、应用敏捷、业务智能、安全可信、行业使能”，华为云云原生2.0全面升级。01 在基础设施即服务方面华为云进一步打造一致体验的分布式云原生基础设施；通过安全云脑，把AI融入云原生安全体系，提升检测能力和运营效率，让安全更智能。02 在技术即服务方面为了企业能够更好的快速构建新型生产方式，华为云整合打造了四大生产线及多种云原生技术，让企业快速获取新的技术能力，提升生产效率，从而支撑企业的持续创新和快速发展。 03 在经验即服务方面华为云继续增强基础aPaaS能力，将华为积累的更多基础能力开放出来。 四大生产线技术干货图所见即所得华为云持续打造技术即服务对数字内容生产线MetaStudio、AI开发生产线ModelArts和软件开发生产线DevCloud进行服务升级并发布全新的数据治理生产线DataArts四大生产线服务“长剑出鞘”帮助各行各业的软件开发更简单快速地完成SaaS化在云上创造更多新价值数据治理生产线DataArts帮助企业更便捷高效地管理和使用数据，释放数据价值。AI开发生产线ModelArts让AI开发更加简单高效。数字内容生产线MetaStudio让各行业可以便捷地在云上生产数字内容、开发3D应用，打造虚拟演唱会、虚拟展会、办公协作、工业数字孪生等各种元宇宙应用场景，让海量用户在其中实时无缝沟通。例如：湖南多豆乐漫娱传媒基于MetaStudio数字内容生产线打造“方小锅”数字人IP，结合AI实现单摄像头驱动，动作准确度超过90%，口型准确度达到95%以上，实现数字人直播体验的质变。软件开发生产线DevCloud把华为的全流程软件开发经验放到华为云上，提供给开发者使用。例如：德邦快递通过软件开发生产线半年便实现从线下到云端开发流水线的转型，上线运行半年完成了750多个流水线业务交付，迁移80个+业务系统，代码问题下降71.74%。更多精彩，直接上图除此之外，还有华为云将继续和合作伙伴、开发者一起通过 经验即服务技术即服务基础设施即服务实现一切皆服务，共创新价值

请问你是有谁比较清楚 摸得透的..

通过【一行代码秒上云应用开发实训营】的3个案例，完成java、nodejs、C#在DevCloud上的体验。整个体验过程非常流畅，从代码托管检查 构建部署等方面体会了平台的便利性，看到还有规划、迭代、测试等各项便于软件开发的功能。另外代码修改后构建部署都非常快，能够批量部署应用。如果使用本地编辑器的话，云上部署还需要进行很多其他配置，而平台的构建和部署集成度高，可以随时修改，比单独部署方便太多。#体会#1 功能全且界面清晰明了，既可以傻瓜化编辑部署，也有自定义各项功能。2 实现软件开发的全流程管理，能够快速批量部署。3 将华为云的功能集中在一起，操作便捷，学会之后会逐步开始使用。

我是天津市大学软件学院的唐文龙（学号2150310108），产品设计十分人性化，实验手册操作步骤十分清晰。希望未来小到学生学习大到公司开发均能被广泛熟知并运用。三次打卡产品体验都特别完美，页面清晰，操作简易，反馈迅速暂无优化建议

我是天津市大学软件学院的唐文龙（学号2150310108），设计十分人性化，实验手册操作步骤十分清晰。三次打卡产品体验都特别完美，页面清晰，操作简易，反馈迅速暂无优化建议！

通过华为云软件开发平台的学习，让面向软件开发者提供研发工具服务，让软件开发简单高效，开发者更容易的获取开发资源，对于与主流的编程语言如C/C++、Java、Python，语言也可以通过安装插件方式来支持。总得来说，对于开发者能有更好的创新能力。