个人觉得软件耦合，是用来判断一个模块（功能，野可以简单理解为一个xx.c文件）与其他模块之间的耦合联系的，通过理论分析我们可以确定出两个模块之间的必须耦合元素有哪些，然后由于C语言@jonah_king的灵活性，我们必须选择出最合适的耦合方式。
 
  耦合按照标准的定义一共分为以下7个类别：
 
1、内容耦合 
 
内容耦合是最高程度的耦合
 
如果出现下列情况之一，两个模块间就发生了内容耦合：
 
 1.1、一个模块A访问另一个模块B的内部数据@jonah_king（不是全局变量）；
 
 缺点:模块A的运行会被模块B内部的数据修改影响(甚至是被修改的时间)。
 
      （1）模块A依赖模块B的内部运作，要想了解A,必须先了解模块B的内部变量，降低了可读性。
 
      （2）模块B很有可能不知道模块A的存在，若更改模块B，很可能导致A的动作，但是B却不知道。
 
更改建议：
 
     程序中不允许存在内容耦合，如果必须耦合的话，设计相应访问借口。
 
1.2、一个模块不通过正常入口转到另一个模块的内部@jonah_king（C语言）
 
   goto语句会造成此现象。
 
 更改建议：
 
   程序中禁止使用goto语句，此语句会严重增加代码的复杂度和可读性。
 
1.3、两个模块有一部分程序代码重叠；汇编
 
1.4、一个模块有多个入口。                 汇编
 
2、公共耦合
 
   两个或两个以上的模块共同引用一个全局数据项（不是单独的变量，也不是通过函数参数传递），这种耦合被称为公共耦合。
 
公共耦合的可以是数据结构，共享通讯区，公共覆盖区.......
 
2.1、公共耦合的必要性
 
首先需要说明的是，公共耦合是必定要存在的，我还没有见过那么一个工程，不用全局结构体的。前面我们已经提到过如何计算一个模块的耦合度，
 
如果好多个模块都需要使用一个结构体，那么将这个结构体设置为全局数据项还是很有必要的。
 
2.2、公共耦合的缺点
 
     （1）任意一个模块，对于公共数据的修改，都会影响其他模块的运行。
 
     （2）不同模块对于公共数据的修改，可能会产生冲突。
 
     （3） 公共耦合会降低程序可读性。
 
              对于这条说法，我是邮电意见的，公共耦合是增加了程序的复杂度，不利用程序分析。但是其实并没有降低可读性。
 
补充一点：不同模块对于公共数据的操作权限可能不同，只读，只写或者读写。
 
一般来说，当模块之间共享数据较多且不具有统一性时，我们选择使用公共耦合
 
3、外部耦合
 
一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合
 
 
外部耦合和公共耦合是相似的，只不过一个是数据结构，一个是简单变量，其本质是一样的，详细说明见公共耦合
 
4、控制耦合
 
如果一个模块通过传递控制信息，明显地控制选择另一模块的功能，就是控制耦合。
 
  这种耦合的实质是在单一接口上选择多功能模块中的某项功能。
 
缺点： 
 
     （1） 调用函数必须了解被调用函数的内部处理机制或者所有能够执行的功能，然后选择控制被调函数执行相应功能。
 
     （2） 被调用函数的其中一部分需改，会导致整个函数的改变，所以所有调用者（即使调用其他控制功能）都可能受影响。
 
建议： 省去控制信息，将函数分为多个接口，每个接口执行不同的功能。
 
5、标记耦合
 
如果一组模块通过参数表传递记录信息，就是标记耦合。
 
事实上，这组模块共享了这个记录，它是某一数据结构的子结构，而不是简单变量。这要求这些模块都必须清楚该记录的结构，并按结构要求对此记录进行操作。在设计中应尽量避免这种耦合，它使在数据结构上的操作复杂化了。如果采取“信息隐蔽”的方法，把在数据结构上的操作全部集中在一个模块中，就可以消除这种耦合
 
6、数据耦合
 
如果一个模块访问另一个模块时，彼此之间是通过数据参数(不是控制参数、公共数据结构或外部变量)来交换输入、输出信息的，则称这种耦合为数据耦合
 
7、非直接耦合
 
如果两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的，这就是非直接耦合。这种耦合的模块独立性最强
 
 
 
 
模块之间的耦合关系，按照操作权限进行以下分类：
 
1、读权限0x01
 
     模块需要读取其他模块数据的状态。
 
其中读取的数据根据耦合计算公式可知，包括输入参数（数据和控制）、全局变量（数据和控制）。
 
2、写权限0x02
 
    模块需要修改其他模块数据的状态。
 
其中读取的数据根据耦合计算公式可知，包括输出参数（数据和控制）、全局变量（数据和控制）。
 
3、执行权限0x04
 
   模块需要调用其他模块内的功能（调用）。
 
其中读取的数据根据耦合计算公式可知，包括调用函数、被调用函数。
 
 
模块之间的耦合关系可能是上述三者中的一个，也可能是上述三者中的或组合，其全部耦合关系如下：
 
 
   
 
数值
权限
耦合严重度
001
读
1
010
写
1
011
读写
2
100
执行
1
101
读+执行
2
110
写+执行
2
111
读+写+执行
3

 
 
 
我们总得找出一种计算方法来计算模块耦合的程度，一般采用以下的公式：
 
 
                           
 
 
                                    （1）di: 输入数据参数的个数
 
                                    （2）ci: 输入控制参数的个数
 
                                    （3）do: 输出数据参数的个数
 
                                    （4）co: 输出控制参数的个数 全局耦合：
 
                                    （5）gd: 用来存储数据的全局变量
 
                                    （6）gc: 用来控制的全局变量 环境耦合：
 
                                    （7）w: 此模块调用的模块个数（扇出）
 
                                    （8）r: 调用此模块的模块个数（扇入）
 
若Coupling(C)数值越大，表示模块耦合的情形越严重，@jonah_king数值一般会界于0.67（低度耦合）到1.0（高度耦合）之间。
 
举例，若一模块只有一个输入数据参数，一个输出数据参数：
 
 
 
 
 
若一模块的输入数据参数、输入控制参数、输出数据参数及输出控制参数都是5个，访问10个全局变量，扇出和扇入的模块个数别是3个及4个：
 
 
 
 

 通用公式：

计算平均的并发用户数： C = nL/T

C是平均的并发用户数；n是login session的数量；L是login session的平均长度；T指考察的时间段长度。

并发用户数峰值： C’ ≈ C+3根号C

C’指并发用户数的峰值，C就是公式（1）中得到的平均的并发用户数。该公式的得出是假设用户的login session产生符合泊松分布而估算得到的。



实例：

假设有一个OA系统，该系统有3000个用户，平均每天大约有400个用户要访问该系统，对一个典型用户来说，一天之内用户从登录到退出该系统的平均时间为4小时，在一天的时间内，用户只在8小时内使用该系统。

则C = 400*4/8 = 200

C’≈200+3*根号200 = 242



F=VU * R / T

其中F为吞吐量，VU表示虚拟用户个数，R表示每个虚拟用户发出的请求数，T表示性能测试所用的时间

R = T / TS

TS为用户思考时间

计算思考时间的一般步骤：

A、 首先计算出系统的并发用户数

C=nL / T F=R×C

B、 统计出系统平均的吞吐量

F=VU * R / T R×C = VU * R / T

C、 统计出平均每个用户发出的请求数量

R=u*C*T/VU

D、根据公式计算出思考时间

TS=T/R





缺陷检测有效性百分比DDE=TDFT/(TDFC+TDFT)×100%

其中:TDFT=测试过程中发现的全部缺陷(即由测试组发现的),TDFC=客户发现的全部缺陷(在版本交付后一个标准点开始测量,如,半年以后)



缺陷排除有效性百分比DRE=(TDCT/TDFT)×100%

其中:TDCT=测试中改正的全部缺陷,TDFT=测试过程中发现的全部缺陷



测试用例设计效率百分比TDE=(TDFT/NTC)×100%

其中:TDFT=测试过程中发现的全部缺陷,NTC=运行的测试用例数



以下公式较适用于白盒测试

功能覆盖率= 至少被执行一次的测试功能点数/ 测试功能点总数 （功能点）

需求覆盖率= 被验证到的需求数量 /总的需求数量 （需求）

覆盖率= 至少被执行一次的测试用例数/ 应执行的测试用例总数 （测试用例）

语句覆盖率= 至少被执行一次的语句数量/ 有效的程序代码行数

判定覆盖率= 判定结果被评价的次数 / 判定结果总数

条件覆盖率= 条件操作数值至少被评价一次的数量 / 条件操作数值的总数

判定条件覆盖率= 条件操作数值或判定结果至少被评价一次的数量/(条件操作数值总数+判定结果总数)

上下文判定覆盖率= 上下文内已执行的判定分支数和/(上下文数*上下文内的判定分支总数)

基于状态的上下文入口覆盖率= 累加每个状态内执行到的方法数/(状态数*类内方法总数)

分支条件组合覆盖率= 被评测到的分支条件组合数/分支条件组合数

路径覆盖率= 至少被执行一次的路径数/程序总路径数



如果谁知道还有其他的计算公式请帮忙留言补充或给我发消息，谢谢

以上内容由zymaxs收集整理~~

串联系统的可靠性R=R1R2…RN; (R1,R2,RN 是各个子系统的可靠性。)



并联系统的可靠性R=1-（1-R1）（1-R2）…(1-RN)

自己做量化交易软件(41)自编仿通达信公式及自编因子公式的计算速度比较及因子公式结果排名
 自编仿通达信指标公式是对单只股票计算，如果对一批股票计算，只能用循环来逐个处理。
 自编因子指标公式是对一批股票同步计算，因此可以想象速度肯定会很快。
 我们下面做一个速度计算比较。为了能精确计算速度，我们预先读取沪深300指数的300只股票行情，再进行计算比较。
 因Python的显示对速度影响很大，我们只显示计算所花费的时间。
 计算结果比较请看上一篇博客《自己做量化交易软件(40)小白量化实战13–Alpha101及自编因子公式》
 下面给出全部程序，和最后计算速度比较结果。
 
#  仿通达信单只股票计算和因子公式计算速度比较

#购买<零基础搭建量化投资系统>正版书,送小白量化软件源代码。
# https://item.jd.com/61567375505.html
#独狼荷蒲qq:2775205
#通通python量化群:524949939
#电话微信:18578755056
#微信公众号：独狼股票分析
import time
import numpy as np
import pandas as pd
from scipy.stats import rankdata
import HP_tdx as htdx  #小白量化通达信行情库
from HP_formula2 import *  #小白量化仿通达信公式函数库
    
#连接行情主站
htdx.TdxInit(ip='183.60.224.178',port=7709)

#获取板块的所有股票代码
bkn='沪深300'
codes=htdx.getblock2(bkn) #返回板块中的股票
print(bkn,' 板块的所有股票 :',codes)

print('开始获取行情数据!')
#小白量化数据池
stocks_dict = {}  #小白量化数据池
for c in codes:
    stock =htdx. get_security_bars(nCategory=5,nMarket = 0,code=c,nCount=800)
    # 小白量化仿通达信公式数据格式化
    mydf=stock.reset_index(level=None, drop=True ,col_level=0, col_fill='')  
    CLOSE=mydf['close']
    LOW=mydf['low']
    HIGH=mydf['high']
    OPEN=mydf['open']
    VOL=mydf['volume']
    C=mydf['close']
    L=mydf['low']
    H=mydf['high']
    O=mydf['open']
    V=mydf['volume']    
    mydf['rtn']=100*(C-REF(C,1))/C   #收益率，又称回报率
    mydf['vwap']=SUM(C*V, 10)/SUM(V, 10)  #成交量加权平均价
    #加入小白量化数据池
    stocks_dict[c] = mydf

#创建小白量化股票数据池
mdf=MDF(stocks_dict)

print('获取行情数据结束!获取了%d 只股票数据。'%len(codes))

#  1.首先计算单只股票KDJ指标的速度

## KDJ指标,只能个股计算
def KDJ(N=9, M1=3, M2=3):
    RSV = (CLOSE - LLV(LOW, N)) / (HHV(HIGH, N) - LLV(LOW, N)) * 100
    K = SMA(RSV,M1,1)
    D = SMA(K,M2,1)
    J = 3*K-2*D
    return K, D, J

#获取股票池中股票代码表
codes=mdf.get_code()

start=time.time()   #获取开始时间    
gpc= {}  #小白量化数据池
#循环计算单只股票的KDJ指标值
for c  in  codes:
    mydf=mdf.get_data(c)

    # 小白量化仿通达信公式数据格式化
    #mydf=mydf.reset_index(level=None, drop=True ,col_level=0, col_fill='')  
    CLOSE=mydf['close']
    LOW=mydf['low']
    HIGH=mydf['high']
    OPEN=mydf['open']
    VOL=mydf['volume']
#    C=mydf['close']
#    L=mydf['low']
#    H=mydf['high']
#    O=mydf['open']
#    V=mydf['volume']
    #计算个股KDJ指标值
    mydf['k'],mydf['d'],mydf['j']=KDJ()      #KDJ指标

    #数据加入股票数据池
    gpc[c] = mydf

end=time.time()   #获取结束时间    
print('全部股票循环计算仿通达信指标公式所需时间：')
print('时间:',round(start,2),round(end,2),'花费时间：',round(end-start,4),'秒')
#创建小白量化股票数据池
mdf2=MDF(gpc)

#  2. 计算股票自编因子公式mKDJ指标的速度
#创建小白量化股票数据池,以股票代码为key的字典
#小白量化因子数据初始化
mCLOSE=mdf.to_df('close')
mLOW=mdf.to_df('low')
mHIGH=mdf.to_df('high')
mOPEN=mdf.to_df('open')
mVOL=mdf.to_df('volume')
mRTN=mdf.to_df('rtn')
mVWAP=mdf.to_df('vwap')

##下面是Alpha因子及自编因子公式的演示

# mKDJ因子指标,不能计算单只股票
def mKDJ(N=9, M1=3, M2=3):
    """
    mKDJ 因子随机指标
    """
    RSV = (mCLOSE - mLLV(mLOW, N)) / (mHHV(mHIGH, N) - mLLV(mLOW, N)) * 100
    K = mEMA(RSV, (M1 * 2 - 1))
    D = mEMA(K, (M2 * 2 - 1))
    J = K * 3 - D * 2
    return K, D, J

start2=time.time()   #获取开始时间    
# 计算mKDJ因子公式
mK,mD,mJ=mKDJ()

end2=time.time()   #获取循环结束时间
print('全部股票计算因子指标公式所需时间：')
print('时间:',round(start2,2),round(end2,2),'花费时间：',round(end2-start2,4),'秒')

 
程序计算结果：
 
开始获取行情数据!
获取行情数据结束!获取了300 只股票数据。
全部股票循环计算仿通达信指标公式所需时间：
时间: 1613804417.7 1613804422.77 花费时间： 5.067 秒
全部股票计算因子指标公式所需时间：
时间: 1613804424.25 1613804424.37 花费时间： 0.127 秒
 
从上面比较可知，因子公式计算一批股票数据值有很快的速度。
 另外因子公式的第2个强项就是快速对指标计算结果排序，
 可在上面程序加入下面几行代码。
 
#获取最后一行结果
result=mK.tail(1)
#获取排名代码
print('获取最后一行结果,并获取排名在前20名的股票代码')
codes3=get_rank(result,20)
print(codes3)
 
程序最后运行的结果如下：
 
沪深300  板块的所有股票 :。。。
开始获取行情数据!
获取行情数据结束!获取了300 只股票数据。
全部股票循环计算仿通达信指标公式所需时间：
时间: 1613804644.75 1613804649.39 花费时间： 4.644 秒
全部股票计算因子指标公式所需时间：
时间: 1613804650.81 1613804650.93 花费时间： 0.127 秒
获取最后一行结果,并获取排名在前20名的股票代码
['600763', '300015', '000708', '002493', '600519', '000568', '600309', '002594', '300347', '600176', '603259', '603799', '600346', '600436', '601166', '600809', '601888', '002601', '688036', '000786']
 
是不是自编因子公式是对自编仿通达信公式的超越，应用范围更加广泛。
 
请持续关注我的博客，我的进步，就是你的进步！