精华内容
下载资源
问答
  • 针对这一问题,引入了半耦合稀疏字典学习模型,松弛高低分辨率流形一致性假设,同时学习稀疏表达字典和稀疏表达系数之间的映射函数,提升高低分辨率判决特征的一致性,在此基础上,引入协同分类模型,实现半耦合特征...
  • 测量了光纤双锥的发射效率,并测量了锥腔耦合效率与半球腔的表面积、锥腔距离之间的关系。根据这种效应,可以制成塑料光纤活动耦合器;如果再加上调谐滤波器,可制成适合塑料光纤通信网用的信号上下载装置。
  • 为进一步研究封闭垂直空间内瓦斯和煤尘耦合爆炸的压力规律,自制了包括爆炸腔和传播管道以及配套设备的封闭垂直管道系统,其中爆炸腔和传播管道同时收集压力数据。在系统内进行25,50,100,200 g/m34种煤尘浓度...
  • 众所周知,当将自由狄拉克费米子放在旋转电场中时,可以实现称为Floquet Weyl金属的状态。 如果将强交互引入该系统,将会发生什么? 相互作用会冲刷Weyl金属的特征(如霍尔响应)吗? 是否存在稳态,其热力学...
  • 在本文中,我们开发了一种新的计算三点函数的新方法,该函数在经典状态下的N = 4 $$ \ mathcal {N} = 4 $$ super Yang-Mills理论的SU(2)扇区中 弱耦合,这与强耦合分析非常相似。 贯穿两个不同状态的结构是所谓...
  • 请问在HFSS中下面的这一步如何实现好像听说要在HFSS中需要设置频率转变为耦合系数的变量 但刚学HFSS不是很熟不知道如何实现 求高手能否帮忙写一下详细的操作步骤在线等待问题解决了送上200金币哦这个和用不用HFSS没...

    我仿真的是一个2阶的腔体耦合系数模型 请问在HFSS中下面的这一步如何实现好像听说要在HFSS中需要设置频率转变为耦合系数的变量 但刚学HFSS不是很熟不知道如何实现 求高手能否帮忙写一下详细的操作步骤

    在线等待问题解决了送上200金币哦

    这个和用不用HFSS没什么关系。

    下面是我用ads仿半波长微带谐振腔的步骤,你可以彷着做。

    2个端口和谐振腔弱耦合,

    S21出现2个峰,2个峰的频率分别是f1,f2,求出k就是2个谐振腔的耦合系数。

    谢谢版主哈 我要问的是 这个曲线图在HFSS中怎么生成 我通过仿这两阶的耦合系数生成的曲线图 我就可以根据这个图得出我后面要的腔要开多宽 这个步骤不得很明不知道我们本站有QQ群没 想交流一下

    1是要弱耦合,馈电端口离谐振腔远点。当然要能激起相应的模式。

    2是宽度W和k的关系要通过扫描得出,即取不同的W(在我的例子中是两个谐振腔之间的间隔)时求出k,然后画出k-W曲线。

    恩 就是第二点了版主的哪个图跟我的哪个一样的道理 但是我在HFSS中搞不出来版主能加你QQ吗?

    不用QQ很多年。

    啊哦这个得出这个数据我研究老久都没研究出来阿们。

    调节耦合宽度生成K值曲线,然后和理论计算的相比对,相信在曲线上找点的坐标你是会滴

    科学面前人人平等,即是是god's father's father‘s…也不例外

    .............................................................

    呵呵 找坐标哪是当然会的只是吗 生成哪图还在探索中

    申明:网友回复良莠不齐,仅供参考。如需专业解答,请学习易迪拓培训专家讲授的HFSS视频培训教程。

    展开全文
  • 在具有标量和轴向矢量双夸克的核子的旁观者模型中,我们显示了光子-夸克顶点中的Pauli耦合对非极化包容性深非弹性散射中核子的Parton分布函数(PDF)和方位角不对称的影响 (SIDIS)。 这种异常耦合对未极化和极化...
  • 本文对应原书第20章后部分 包的耦合性原则 无环依赖原则(ADP - The Acyclic Dependencies Principle ) 在包的依赖关系图中不允许存在环。 解除依赖环的方法 使用依赖倒置原则。 创建一个新包,把共同...

    本文为敏捷软件开发 - 原则、模式与实践系列的一部分。

    本文对应原书第20章后半部分

    包的耦合性原则

    无环依赖原则(ADP - The Acyclic Dependencies Principle )

    在包的依赖关系图中不允许存在环。

    解除依赖环的方法

    1. 使用依赖倒置原则。
    2. 创建一个新包,把共同依赖的类移动到新包里面。

    稳定依赖原则(SDP - The Stable-Dependencies Principle )

    朝着稳定的方向进行依赖

    稳定性和更改所需要的工作量有关。

    包稳定性度量

    一种方式是计算进、出该包的依赖关系的数目。我们可以使用这些来数值计算该包的位置稳定性。

    • Ca输入耦合度:指处于该包的外部并依赖于该包内的类的类的数目。
    • Ce输出耦合度:指处于该包的内部并依赖于该包外的类的类的数目。
    • 不稳定性II = Ce / (Ca + Ce)

    该度量的取值范围是[0, 1]。

    当一个包的I度量值为1时,就意味着没有任何其他的包依赖于该包(Ca=0),而该包依赖于其他的包(Ce > 0)。这是一个包最不稳定的状态;它是不承担责任并且有依赖性的。因为没有包依赖于它,所以它就没有不改变理由,而它所依赖的包会给它提供丰富的更改理由。

    另一方面,当一个包的I度量值为0时,就意味着其他包会依赖于该包(Ca > 0),但是该包却不依赖于任何其他的包(Ce=0)。它是负有责任且无依赖性的。这种包达到了最大程度的稳定性。它的依赖者使其难以更改,而且没有任何依赖关系会迫使它去改变。

    SDP规定一个包的I度量值应该大于它所依赖的包的I度量值(也就是说,I度量值应该顺着依赖的方向减少)。

    如果一个系统中所有的包都是最大程度稳定的,那么该系统就是不能改变的。这不是希望的情形。事实上,我们希望所设计出来的包结构中,一些包是不稳定的而另一个包是稳定的。

    可改变的包位于顶部并依赖于底部稳定的包。把不稳定的包放在图的顶部是一个有用的约定,因为任何向上的箭头都意味着违反了SDP。

    稳定抽象原则(The Stable-Abstractions Principle)

    包的抽象程度应该和其稳定程序一致

    该原则把包的稳定性和抽象性联系起来。它规定,一个稳定的包应该也是抽象的,这样它的稳定性就不会使其无法扩展。另一方面,它规定,一个不稳定的包应该是具体的,因为它的不稳定性使其内部的具体代码易于更改。

    SAP和SDP结合在一起形成了针对包的DIP原则。这样说是准确的,因为SDP规定依赖应该朝着稳定的方向进行,而SAP则规定稳定性意味着抽象性。因为,依赖应该朝着抽象的方向进行。

    包抽象度度量

    A是一个测量包抽象程度的度量标准。它的值就是包中抽象类的数目和全部类的数目的比值。

    • Nc- 包中类的总数
    • Na- 包中抽象类的数目
    • A = Na / Nc- 包的抽象性

    度量A的取值范围是从0到1。0意味着包中没有任何抽象类。1意味着包中只包含抽象类。

    自下而上设计包

    包结构应该是随着系统的增长、变化而逐步演化的。

    事实上,包的依赖关系图和描绘应用程序的功能之间几乎没有关系。相反,它们是应用程序可构建性的映射图。这就是为何不在项目开始时设计它们的原因。在项目开始时,没有软件可构建,因此也无需构建映射图。但是,随着实现和设计初期累积的类越来越多,对依赖关系进行管理,避免项目开发中出现循环依赖的需求就不断增长。此外,我们也想尽可能地保持更改的局部化,所以我们开始关注SRP和CCP,并把可能会一同变化的类放在一起。

    随着应用程序的不断增长,我们开始关注创建可重用的元素。于是,就开始使用CRP来指导包的组合。最后,当环出现时,就会使用ADP,从而包的依赖关系图会出现抖动以及增长。

    完整内容请查看敏捷软件开发 - 原则、模式与实践系列

    展开全文
  • 线程池实现的同步/反应堆模型,使用工作队列实现主线程和工作线程的通信,利用加锁(互斥锁、信号量)实现同步操作,有点类似于“生产者-消费者...1、主线程和工作线程间没有耦合关系,通用性强; 2、利用操作系...

    线程池实现的半同步/半反应堆模型,使用工作队列实现主线程和工作线程的通信,利用加锁(互斥锁、信号量)实现同步操作,有点类似于“生产者-消费者”的通信模型。

    缺点:

    1、利用锁实现工作线程对工作队列的访问,锁的加入降低了系统效率;

    2、必须保证所有客户请求都是无状态的,因为同一个连接上的不同请求可能会由不同线程处理;

    优点:

    1、主线程和工作线程间没有耦合关系,通用性强;

    2、利用操作系统自带的信号量唤醒机制,工作线程基本可以实现公平调度(工作线程负载均衡),程序实现简单。

    #ifndef THREADPOOL_H
    #define THREADPOOL_H
    
    #include <list>
    #include <cstdio>
    #include <exception>
    #include <pthread.h>
    #include "locker.h"//对互斥锁、信号量的封装,代码略
    
    template< typename T >
    class threadpool//线程池类
    {
    public:
        threadpool( int thread_number = 8, int max_requests = 10000 );//thread_number为线程池线程数,max_requests为工作队列中最大的等待数
        ~threadpool();
        bool append( T* request );//向工作队列中添加请求,需要加锁操作
    
    private:
        static void* worker( void* arg );//工作线程的运行函数,不断从工作队列中取出任务并执行,同样需要加锁操作
        void run();
    
    private:
        int m_thread_number;
        int m_max_requests;
        pthread_t* m_threads;//线程池数据
        std::list< T* > m_workqueue;//工作队列,FIFO
        locker m_queuelocker;//互斥锁
        sem m_queuestat;//信号量
        bool m_stop;
    };
    
    template< typename T >
    threadpool< T >::threadpool( int thread_number, int max_requests ) :
            m_thread_number( thread_number ), m_max_requests( max_requests ), m_stop( false ), m_threads( NULL )
    {
        if( ( thread_number <= 0 ) || ( max_requests <= 0 ) )
        {
            throw std::exception();
        }
    
        m_threads = new pthread_t[ m_thread_number ];//创建线程描述符数组
        if( ! m_threads )
        {
            throw std::exception();
        }
    
        for ( int i = 0; i < thread_number; ++i )
        {
            printf( "create the %dth thread\n", i );
            if( pthread_create( m_threads + i, NULL, worker, this ) != 0 )
            {
                delete [] m_threads;
                throw std::exception();
            }
            if( pthread_detach( m_threads[i] ) )//分离属性
            {
                delete [] m_threads;
                throw std::exception();
            }
        }
    }
    
    template< typename T >
    threadpool< T >::~threadpool()
    {
        delete [] m_threads;
        m_stop = true;
    }
    
    template< typename T >
    bool threadpool< T >::append( T* request )
    {
        m_queuelocker.lock();//加锁
        if ( m_workqueue.size() > m_max_requests )
        {
            m_queuelocker.unlock();
            return false;
        }
        m_workqueue.push_back( request );
        m_queuelocker.unlock();//解锁
        m_queuestat.post();//信号量+1,有1个工作线程会被唤醒
        return true;
    }
    
    template< typename T >
    void* threadpool< T >::worker( void* arg )// 工作线程运行函数,详细说明见下文
    {
        threadpool* pool = ( threadpool* )arg;
        pool->run();
        return pool;
    }
    
    template< typename T >
    void threadpool< T >::run()
    {
        while ( ! m_stop )
        {
            m_queuestat.wait();//信号量-1
            m_queuelocker.lock();//加锁
            if ( m_workqueue.empty() )
            {
                m_queuelocker.unlock();
                continue;
            }
            T* request = m_workqueue.front();
            m_workqueue.pop_front();
            m_queuelocker.unlock();
            if ( ! request )
            {
                continue;
            }
            request->process();//处理请求
        }
    }
    
    #endif
    

    关于线程运行函数:

    在C++程序中使用pthread_create函数时,第3个参数必须指向一个静态函数,不能是一个对象的成员方法。因此在threadpool中要把线程运行函数定义为static。同时,要在一个静态函数中使用类的动态成员(成员函数和成员变量),可以将类的对象作为参数传递给该静态函数,通过引用该对象调用方法或访问变量。此处在pthread_create创建线程时传入this指针

    高性能服务器编程半同步/半反应堆的线程池模板

    转载于:https://www.cnblogs.com/xjyxp/p/11488908.html

    展开全文
  • 局部分数瞬时子

    2020-04-19 01:37:19
    我们在带有标量场和相应的ℂPN − 1 $$ \ mathbb {C} {P} ^ {N-1} $$和... 阿贝尔规范和非阿贝尔规范理论中的瞬时子分别具有负和正瞬时子电荷,这与像Seiberg一样的对偶关系有关,该对偶改变了瞬时子电荷的符号。
  • 对于一个巨大的,最小耦合的场,找到一个“小Λ”解,由关系m2≃4.89707×1012Λ固定。 我们强调,在这个框架中,在标准公式中,旧的宇宙常数问题没有作用,因为在经典方程式中仅存在物理Λ,因此没有Λ的裸对...
  • 该线程池的通用性高的多,因为它使用一个工作队列完全解除了主线程和工作线程之间的耦合关系:主线程网工作队列中插入任务,工作线程通过竞争来取得任务并执行它。不过,如果要将该线程池应用到实际服务器程序中,...
    0027b2e0214b4ab7314ebde044bf5d97.png

    该线程池的通用性高的多,因为它使用一个工作队列完全解除了主线程和工作线程之间的耦合关系:

    主线程网工作队列中插入任务,工作线程通过竞争来取得任务并执行它。

    不过,如果要将该线程池应用到实际服务器程序中,那么我们必须保证所有客户请求都是无状态的,因为同一个连接上的不同请求可能会由不同的线程处理

    示例代码如下,代码中的locker.h引自多线程编程 - 线程同步机制

    #ifndef THREADPOOL_H#define THREADPOOL_H#include #include #include #include #include "locker.h"/*线程池类,将它定义为模板类是为了代码复用。模板参数T是任务类*/template class threadpool{public:    /*参数thread_number是线程池中线程的数量,    max_request是请求队列中最多允许的、等待处理的请求的数量*/    threadpool(int thread_number = 8, int max_requests= 10000);    ~threadpool();    /*往请求队列中添加任务*/    bool append(T* request);private:    /*工作线程运行的函数,它不断从工作队列中取出任务并执行之*/    static void* worker(void* arg);    void run();private:    int m_thread_number; /*线程池中的线程数*/    int m_max_requests; /*请求队列中允许的最大请求数*/    pthread_t * m_threads; /*描述线程池的数组,其大小为m_thread_number*/    std::list m_workqueue; /*请求队列*/    locker m_queuelocker; /*保护请求队列的互斥锁*/    sem m_queuestat; /*是否有任务需要处理*/    bool m_stop; /*是否结束线程*/};templatethreadpool::threadpool(int thread_number, int max_requests):    m_thread_number(thread_number), m_max_requests(max_requests),    m_stop(false), m_threads(NULL){    if(thread_number <= 0 || max_requests <= 0){        throw std::exception();    }    m_threads = new pthread_t[m_thread_number];    if(!m_threads){        throw std::exception();    }    /*创建thread_numbers个个数,并将它们都设置为脱离线程*/    for(int i = 0; i < thread_number; ++i){        printf("create the %dth thread", i);        if(pthread_create(m_threads+i, NULL, worker, this) != 0){            delete [] m_threads;            throw std::exception();        }        if(pthread_detach(m_threads[i])){            delete[] m_threads;            throw std::exception();        }    }}templatethreadpool::~threadpool(){    delete [] m_threads;    m_stop = true;}templatebool threadpool::append(T* request){    /*操作工作队列时一定要加锁,因为它被所有线程共享*/    m_queuelocker.lock();    if(m_workqueue.size > m_max_requests){        m_queuelocker.unlock();        return false;    }    m_workqueue.push_back(request);    m_queuelocker.unlock();    m_queuestat.post();    return true;}templatevoid *threadpool::worker(void* arg){    threadpool * pool = (threadpool*)arg;    pool->run();    return pool;}templatevoid threadpool::run(){    while(!m_stop){        m_queuestat.wait();        m_queuelocker.lock();        if(m_workqueue.empty()){            m_queuelocker.unlock();            continue;        }        T* request = m_workqueue.front();        m_workqueue.pop_front();        m_queuelocker.unlock();        if(!request){            continue;        }        request->process();    }}#endif

    这里需要注意的是,在C++程序中使用pthread_create函数时,该函数的第三个参数必须指向一个静态函数。而要在一个静态函数中使用类的动态成员(包括成员函数和成员变量),则只能通过如下两种方式实现:

    • 访问类的静态对象来调用。如果单例模式中。静态函数可以通过类的全局唯一实例来访问动态成员函数
    • 将类的对象作为参数参数传递给该静态函数,然后在静态函数中应用这个对象,并调用其动态代码

    上述代码中,使用的是第二种方式:将线程参数设置为this指针,然后在worker函数中获取该指针并调用其动态方法run。

    展开全文
  • 该线程池的通用性高的多,因为它使用一个工作队列完全解除了主线程和工作线程之间的耦合关系:主线程网工作队列中插入任务,工作线程通过竞争来取得任务并执行它。不过,如果要将该线程池应用到实际服务器程序中,...
  • spring总结

    2019-10-24 07:56:48
    通过IoC容器,可以将对相间的依赖关系交给spring进行控制,避免硬编码造成的过度耦合. 控制反转的思想可以集成其他框架 将service,dao的创建权交给spring 将权力交出去这样的过程叫做控制反转 AOP编程的支持 声明式...
  • 我们使用AdS / CFT对应关系来计算无质量基本费米子(2 + 1)维系统在强耦合耦合到(3 + 1)维Super Yang-Mills理论的交流电导率。 我们认为系统处于有限的电荷密度,沿着缺陷的电场为恒定,而磁场为正交。 我们...
  • 使用定位方法和耦合的3d / 5d颤动规范理论的扭曲手性环关系,我们计算了控制这些表面算子的红外特性的扭曲手性超电势。 我们对局域积分物进行了详细的分析,并与扭曲手性环方程的结果进行比较,获得了对3d和5d ...
  • 扩展指的是NLSM介子与双伴随标量的耦合,而阿贝尔情况涉及在表征Z理论幅值的颜色顺序之一上的部分对称。 替代地,部分对称化对应于潜在的开放超弦振幅中的阿贝尔状态与非阿贝尔状态之间的混合相互作用。 我们通过...
  • 我们通过考虑解析度和耦合通道统一性的色散关系来计算振幅,并准确地描述实验。 通过将这些振幅与手性摄动理论的振幅进行比较,可以获得ππ→ππ散射振幅的NC依赖性。 通过改变NC来研究局部对偶性。 我们的结果...
  • 标准偏差,偏差,Beta和下行Beta。 我们发现,全球金融危机具有去耦合效应,因为在危机后时期,全球金融市场之间的回报关联性下降。 我们还观察到替代风险度量之间存在高度正相关,这意味着资产定价测试应对风险...
  • 设计了一种基于天线理论的锚杆长度无损测量仪,通过添加一根金属参考线的方式,将单根金属锚杆等效为波偶极子天线,采用AD9913作为天线馈源产生0~100MHz的正弦扫描信号耦合进金属锚杆,检测金属锚杆首次发生谐振时对应...
  • 鉴于电子技术教材的阻容耦合射极输出器都是静态工作点不稳定的电路形式,都没有分析静态工作点的稳定性对电路动态性能影响的问题,因而有射极输出器是否需要稳定的静态工作点的疑点问题。针对疑点问题,研究了射极...
  • 鉴于电子技术教材的阻容耦合射极输出器都是静态工作点不稳定的电路形式,都没有分析静态工作点的稳定性对电路动态性能影响的问题,因而有射极输出器是否需要稳定的静态工作点的疑点问题。针对疑点问题,研究了射极...
  • 北风客户关系管理源码 CRM

    千次下载 热门讨论 2013-01-16 14:16:11
    北风网推出的CRM项目除了在业务上的特色之外,还综合了Struts 2+ Spring + Hibernate+ Jfreechart+JQuery+AJAX的技术实现:利用Spring来解耦合,管理依赖,将整个应用进行整合;持久化层采用轻量级的ORM解决方案...
  • 数据挖掘原语

    2012-12-10 18:57:36
    数据挖掘原语主要包含以下方面内容: ...数据挖掘系统与数据库/数据仓库的关系:不耦合、松散耦合紧密耦合和紧密耦合。一个良好设计的数据挖掘系统应当提供与数据库/数据仓库的紧密或紧密耦合
  • 矩形波导CO

    2021-02-07 01:41:39
    实验研究了波导纵横比m=2的外腔矩形波导CO2激光器的输出功率与谐振腔光学结构参数之间的关系, 对比了平面反射镜紧贴波导口激光器的输出功率, 得到谐振腔模式耦合进入波导口的损耗与谐振腔全反镜曲率半径R以及全...
  • Linux线程池

    2014-09-14 12:53:45
    该线程池使用一个工作队列完全解除了主线程和工作线程的耦合关系:主线程往工作队列中插入任务,工作线程通过竞争来取得任务并执行它。不过,如果要将该线程池应用到实际服务器程序中,那么我们
  • 框架:成品的软件.可以在框架的设计基础上进行软件...(耦合性:通俗的理解例如别人写的一个方法,他的返回值做为了我的参数,我会受他的改变而改变,模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系、...
  • 最近,通过利用AdS / CFT对应关系,在强耦合下规范理论算子的异常尺寸的计算方面取得了进展。 在弦论方面,它们是由古典制度中的色散关系给出的。 我们重新讨论在AdS4×CP3背景下简单古典弦的色散关系的大电荷...
  • 框架

    2017-07-20 19:36:54
    面向对象是从软件工程基本原则(如耦合、聚合、封装)的基础上发展起来的,而关系数据库则是从数学理论发展而来的,两套理论存在显著的区别。为了解决这个不匹配的现象,对象关系映射技术应运而生。 对象关系

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 124
精华内容 49
关键字:

半耦合关系