精华内容
下载资源
问答
  • jQuery定义类及扩展

    2011-07-30 16:52:00
    这个自定义类还是有点困惑滴。先看网上有个人做滴,模仿jQuery定义一个jQuery对象。...function $(selector){//定义了名为jQuery的对象 用滴是构造 return new $.prototype.init(selector);//有点怪 为什...

    这个自定义类还是有点困惑滴。先看网上有个人做滴,模仿jQuery定义一个jQuery对象。

    <script type="text/javascript">
    // zchain-0.1.js
    function $(selector){//定义了名为jQuery的对象  用滴是构造法
    	return new $.prototype.init(selector);//有点怪 为什么会有return呢?
    }
    $.prototype={
    	init:function(selector){
    		if(selector === undefined){
    			this.length = 0;
    			return this;
    		}
    		if(selector.nodeType==1){//怀疑这句有问题
    		    alert("div");
    			this[0] = selector;
    		}else{
    		    alert("test");
    			this[0]=document.getElementById(selector);
    		}
    		this.length=1;
    	},
    	css:function(name,value){
    		this[0].style[name] = value;
    		return this;//链式调用
    	},
    	hide:function(){
    		var self=this;
    		setTimeout(function(){
    			self[0].style.display="none";
    		},3000);
    		return this;//链式调用
    	}
    }
    $.prototype.init.prototype=$.prototype;
    //var obj = $();   
    //console.dir(obj); 
    </script>
    <div id='content'>3 seconds later I will hide.</div>
    
    </body>
    </html>
    <script type="text/javascript">
    	//alert(document.getElementsByTagName('div'));
    	$('content').css("color","red").hide();
    </script>
    

    刚开始看这段代码时晕晕滴,先定义一个类吧:function $(..)名字为$,让我看得很疑惑,原来它是定义一个jQuery的类呀。然后在后面调用的时候又发现一个问题:$('content'),这个content命名是一个#id类型嘛,然后他在构造函数中既然有:selector.nodeType==1。(感觉那个网友有错)。

     

    接下来总结下类滴扩展吧:方法一、通过jQuery.extend扩展 

    还是先看下个例子(摘录别人滴,但自己有测试了下):

    <script type="text/javascript">
    function fun(){}//定义一个类(函数)
    
    //为该类(函数)添加一个静态方法extend
    fun.extend=function(obj){
    	for(var a in obj)
    		this[a] = obj[a];//注意:这里的tihs即fun
    }
    
    //调用extend为该类添加了静态属性name,静态方法method1
    fun.extend({name:"fun",method1:function(){}});
    
    //输出name,prototype,extend,method1
    console.dir(fun);//输出fun的方法(为什么没有包括属性)
    console.log("%o",fun);
    </script>
    

    上面有注释,entend也是fun的一个静态方法,这不是扩展吗?怎么会是一个方法呢?于是我把entend方法注释掉。运行在firebug就出错,提示:fun.extend is not a function。哦,再看看extend做了什么吧。

    传了一个参数,然后吧这些参数赋值给fun类。原来是这样,如果没有先定义extend的话,那接下去就无法对其进行扩展了。至少我现在还没有发现其他方法。

     

    扩展方法2:通过jQuery.fn.extend扩展 

    这个方法跟通过jQuery.extend扩展方法基本一样,感觉没差别。只要吧通过jQuery.fn.extend 替换下通过jQuery.extend就行啦。

     

    转载于:https://www.cnblogs.com/huaizuo/archive/2011/07/30/2122068.html

    展开全文
  • 线性筛扩展

    千次阅读 2015-07-17 20:44:03
    以下代码中的定义: mindiv[i]:i的最小质因子 phi[i]:欧拉函数i的值 mindivq[i]:i的最小质因子的个数 d[i]:i的约数个数 sumd[i]:i的约数和 miu[i]:莫比乌斯函数i的值 inv[i]:i在mod n意义下的乘法逆元标准筛...

    以下代码中的定义:
    mindiv[i]:i的最小质因子
    phi[i]:欧拉函数i的值
    mindivq[i]:i的最小质因子的个数
    d[i]:i的约数个数
    sumd[i]:i的约数和
    miu[i]:莫比乌斯函数i的值
    inv[i]:i在mod n意义下的乘法逆元


    标准筛法

    欧拉筛法,可以保证每个数只被自己最小的质因子筛去,时间复杂度O(n)
    两种等价实现
    易于理解版:

    void solve(int n){
        for(int i=2;i<=n;i++){
            if(!mindiv[i])
                mindiv[i]=pris[++cnt]=i;
            for(int j=1,k;j<=cnt&&(k=i*pris[j])<=n;j++){
                mindiv[k]=pris[j];
                if(i%pris[j]==0)break;
            }
        }
    }

    又短又快版(避免了取模运算):

    void solve(int n){
        for(int i=2;i<=n;i++){
            if(!mindiv[i])
                mindiv[i]=pris[++cnt]=i;
            for(int j=1,k;j<=cnt&&(k=i*pris[j])<=n;j++){
                if(i%pris[j]==0)break;
                mindiv[k]=pris[j];
            }
        }
    }

    扩展:求积性函数

    积性函数定义:对于一个数论函数f(x),满足:若gcd(a,b)=1,则f(a*b)=f(a)*f(b)的函数f
    由于这个性质,我们可以在筛法的同时求出积性函数的值
    先看几个简单的积性函数:

    id函数

    定义id(i)=i,显然满足积性。
    这就不用筛了,直接得到值

    e函数

    又称单位函数,定义e(1)=1,e(other)=0

    phi函数

    欧拉函数,很有用,可以用来求逆元
    定义phi(i)=sigma{e(gcd(j,i))|1<=j<=i},即1..n中,与n互质的数的数量
    易得对于质数,phi(p)=p-1,
    对于合数有以下公式:
    n=p1^q1*p2^q2*…*pr^qr
    phi(n)=n*(1-1/p1)*(1-1/p2)…
    将n带入可得phi(n)=π{(pi-1)*pi^(qi-1)}
    这就很容易发现它的积性性质
    用筛法怎么求呢?
    稍微改一下就行了:

    void solve(int n){
        for(int i=2;i<=n;i++){
            if(!mindiv[i]){
                mindiv[i]=pris[++cnt]=i;
                phi[i]=i-1;
            }
            for(int j=1,k;j<=cnt&&(k=i*pris[j])<=n;j++){
                mindiv[k]=pris[j];
                if(i%pris[j]==0){
                    phi[k]=phi[i]*pris[j];
                    break;
                }
                phi[k]=phi[i]*(pris[j]-1);
            }
        }
    }

    为什么呢?
    1.对于i%pris[j]!=0的项,它的最小质因子一定是pris[j],则由积性函数性质可得phi[k]=phi[i]*phi[pris[j]],其中phi[pris[j]]=pris[j]-1
    2.对于i%pris[j]==0的项,则说明pris[j]已经在i中已经出现了,而且是最小的,观察phi函数的计算式,可知此时应乘pris[j]

    最小质因数的指数

    这个就很简单了:

    void solve(int n){
        for(int i=2;i<=n;i++){
            if(!mindiv[i]){
                mindiv[i]=pris[++cnt]=i;
                mindivq[i]=1;
            }
            for(int j=1,k;j<=cnt&&(k=i*pris[j])<=n;j++){
                mindiv[k]=pris[j];
                if(i%pris[j]==0){
                    mindivq[k]=mindivq[i]+1;
                    break;
                }
                mindivq[k]=1;
            }
        }
    }

    约数个数

    首先约数个数如何求?
    分解质因数,得到n=p1^q1*p2^q2*…*pr^qr
    则其约数个数=π(qi+1)
    这个结论由乘法原理易得,每个质因子有qi+1种选法
    积性就不证了,比较显然。
    怎么求呢?观察筛法的过程,i是质数时或i%pris[j]!=0时都比较容易,主要是i%pris[j]==0时需要考虑好。
    下面来分析一下:
    关键在于如何由d(i)转移到d(i*pris[j])
    首先筛法保证了pris[j]一定是最小质因子,那么由于i%pris[j]==0,则意味着最小质因子的指数会+1,这一点在上面的mindivq求解过程中也体现了。
    +1会导致什么?
    很自然会想到d(k)=d(i)/(mindivq[i]+1)*((mindivq[k]=mindivq[i]+1)+1)
    就是这样。

    void solve(int n){
        for(int i=2;i<=n;i++){
            if(!mindiv[i]){
                mindiv[i]=pris[++cnt]=i;
                mindivq[i]=1;
                d[i]=2;
            }
            for(int j=1,k;j<=cnt&&(k=i*pris[j])<=n;j++){
                mindiv[k]=pris[j];
                if(i%pris[j]==0){
                    mindivq[k]=mindivq[i]+1;
                    d[k]=d[i]/(mindivq[i]+1)*(mindivq[k]+1);
                    break;
                }
                mindivq[k]=1;
                d[k]=d[i]*d[pris[j]];
            }
        }
    }

    约数和

    约数和又如何求?
    分解质因数,得到n=p1^q1*p2^q2*…*pr^qr
    则其约数和=π i ( sigma j {pi^j|0<=j<=qi} )
    看起来也是比较显然,我们直接讨论如何利用筛法来求:
    依然是利用和上面的类似思路:
    只讨论i%pris[j]==0的情况:
    需要除以sigma(pris[j]^(0..mindivq[i]))
    再乘以sigma(pris[j]^(0..mindivq[k])
    其中mindivq[k]=mindiv[i]+1
    这样开两个辅助数组记录
    t1[i]=sigma(mindiv[i]^(0..mindivq[i]))
    t2[i]=mindiv[i]^mindivq
    就可以做了:

    void solve(int n){
        for(int i=2;i<=n;i++){
            if(!mindiv[i]){
                mindiv[i]=pris[++cnt]=i;
                sumd[i]=1+i;
                t1[i]=1+i;
                t2[i]=i;
            }
            for(int j=1,k;j<=cnt&&(k=i*pris[j])<=n;j++){
                mindiv[k]=pris[j];
                if(i%pris[j]==0){
                    t2[k]=t2[i]*pris[j];
                    t1[k]=t1[i]+t2[k];
                    sumd[k]=sumd[i]/t1[i]*t1[k];
                    break;
                }
                sumd[k]=sumd[i]*sumd[pris[j]];
                t1[k]=1+pris[j];
                t2[k]=pris[j];
            }
        }
    }

    miu函数

    莫比乌斯函数,定义miu(1)=1,miu(i|i is square free number)=0,miu(other)=(-1)^(质因数个数)
    用筛法求也很简单:

    void solve(int n){
        for(int i=2;i<=n;i++){
            if(!mindiv[i]){
                mindiv[i]=pris[++cnt]=i;
                miu[i]=-1;
            }
            for(int j=1,k;j<=cnt&&(k=i*pris[j])<=n;j++){
                mindiv[k]=pris[j];
                if(i%pris[j]==0){
                    miu[k]=0;
                    break;
                }
                miu[k]=-miu[i];
            }
        }
    }

    乘法逆元

    由求逆元的欧拉定理方法易知乘法逆元也是积性的,而且有一个很优美的性质:它是完全积性的。
    所以求它变得很简单:
    inv[p]=p^(phi(n)-1)%n
    inv[k]=inv[i]*inv[pris[j]],gcd(k,n)=1

    然而乘法逆元有一个递推的方法,更加简单:
    首先逆元满足以下等式(定义):
    inv[P mod i]*(P mod i)=1
    将P mod i展开:
    inv[P mod i]*(P-P/i*i)=1
    进一步展开:
    inv[P mod i]i(-P/i)=1
    会发现一个神奇的等式:
    i*(-P/i)*(inv[P mod i])=1
    此时(-P/i)*(inv[P mod i])就是i的逆元!

    总结

    线性欧拉筛法简洁,积性函数性质优美,充分结合才能发挥更大的效果。同时又要注意到不同函数的性质,用筛法求积性函数的本质是根据积性函数的定义和运算式,利用筛法的特点,构造合适的转移方法。

    展开全文
  • 指出了传统的扩展等面积准则(EEAC)暂态稳定裕度定义方法的局限性及其适用范围,提出了可在电力系统状态变量的较大变化范围内,仍能正确反映系统受扰严重程度的EEAC广义哲态稳定裕度定义数学模型及...
  • 扩展欧几里得求逆元 例子:求67-1mod 119 开始填表的初值 轮数 Q X1 X2 X3 Y1 Y2 Y3 0 1 0 119 0 1 67 1 2 … 计算公式: 首先定义当前行的变量为:Q, X1 , X2 ,X3 , Y1 ...

    扩展欧几里得求逆元

    例子:求67-1mod 119

    开始填表的初值
    轮数 Q X1 X2 X3 Y1 Y2 Y3
    0 1 0 119 0 1 67
    1
    2
    计算公式:

    首先定义当前行的变量为:Q, X1 , X2 ,X3 , Y1 , Y2 ,Y3

    定义上一行的变量为:Q, X1 , X2 ,X3 , Y1 , Y2 ,Y3

    各变量公式为:
    Q=X3 / Y3
    X1 = Y1
    X2 = Y2
    X3 = Y3
    Y1 = X1 - Q·X1
    Y2 = X2 - Q·X2
    Y3 = X3 - Q·X3

    计算过程

    计算到Y3=1为止,此时同一行的Y2即为所求结果

    轮数 Q X1 X2 X3 Y1 Y2 Y3
    0 1 0 119 0 1 67
    1 1 0 1 67 1 -1 52
    2 1 1 -1 52 -1 2 15
    3 3 -1 2 15 4 -7 7
    4 2 4 -7 7 -9 16 1

    那么67-1mod 119=16,即(67·16) mod 119=1

    代码的话就可以自己写了

    展开全文
  • 文章目录ES6 对象的扩展一、属性表示1、ES52、ES6二、Object的方法1、Object.is()ES5ES62、Object.assign()三、super关键字四、对象的扩展运算符 一、属性表示 1、ES5 let name = '张无忌' function sayMe() { ...

    ES6 对象的扩展

    一、属性表示法

    1、ES5

    let name = '张无忌'
    function sayMe() {
        console.log('this is 张无忌');
    }
    // ES5 定义对象属性方法 的方式
    var obj = {
        name: name, //第二个name表示变量名
        sayMe: sayMe
    }
    console.log(obj.name); //张无忌
    

    2、ES6

    ES6 允许将变量名和函数名直接作为对象的属性和方法的方式

    // ES6 允许将变量名和函数名直接作为对象的属性和方法的方式
    let name = '张无忌'
    function sayMe() {
        console.log('this is 张无忌');
    }
    var obj = {
        name,
        sayMe
    }
    console.log(obj.name);//张无忌
    

    二、Object的方法

    1、Object.is()

    ES5

    ECMAScript 5比较两个值是否相等,使用的是相等运算符
    全等运算符。但这两个运算符在使用时都具有缺点:

    • 相等运算符在比较之前,会自动转换数据类型。
    • 全等运算符导致NaN与自身不等,+0等于-0等问题。
    // ES5
    console.log(+0 === -0);//true
    console.log(NaN === NaN);//false
    

    ES6

    提出了Object.is()方法,对同值相等算法的具体实现

    // ES6
    console.log(Object.is(+0, -0));//false
    console.log(Object.is(NaN,NaN));//true
    

    2、Object.assign()

    Object.assign()

    作用:用于将所有可枚举属性的值从一个或多个源对象复制到目标对象

    参数:

    • target:目标对象
    • sources:源对象
    • 返回值:目标对象
    var obj = {
        name: 'zhangwuji'
        ,
        age : 19
    }
    var target = {}
    
    var result = Object.assign(target, obj)
    console.log(target, result);//{ name: 'zhangwuji', age: 19 } { name: 'zhangwuji', age: 19 }
    target.name = 'zhouzhirou'
    console.log(target, result, '\n',obj.name);//	{ name: 'zhouzhirou', age: 19 } { name: 'zhouzhirou', age: 19 } 
     //zhangwuji
    
    

    三、super关键字

    ES6新增了super关键字,指向当前对象的原型对象

    var prop = {
        age : 18
    }
    var obj = {
        name: '张无忌',
        sayMe() {
            console.log(super.age);
        }
    }
    // 将prop对象作为obj对象的原型对象
    Object.setPrototypeOf(obj, prop)
    console.log(obj.name, obj.age);//张无忌 18
    obj.sayMe()//18
    
    

    注意:super关键字表示原型对象时,只能用在对象的方法上,其他地方都会报错

    四、对象的扩展运算符

    可扩展运算符(…)等价于assign方法,都是将源对象的可枚举属性复制到目标对象

    var obj = {
        name: 'zhangwuji',
        age: 18
    }
    // 将源对象的可枚举属性复制到目标对象
    var target = { ...obj }
    console.log(target);//{ name: 'zhangwuji', age: 18 }
    
    展开全文
  • 使用MultiMarkdown表语法扩展Obsidian中的基本表。 介绍 黑曜石的只能定义表格的基础。 当用户尝试应用带有colspan或多个标题的复杂表时,他们唯一的选择是使用原始HTML,这很难阅读和编辑。 该插件将带到了...
  • 辗转相除(欧几里得算法)和扩展欧几里得算法实现及证明 今天看了好长时间的数论知识点,学完之后,过了一个假期,再回头看扩展欧几里得时已经是 懵 懵 懵 于是我上网找到了它的证明! (叙述的可能会非常...
  • 作为一种建模语言,UML的定义包括UML语义和UML表示两个部分。 (1) UML语义 描述基于UML的精确元模型定义。...此外UML还支持对元模型的扩展定义。 (2) UML表示 定义UML符号的表示,为开发者或开发工具...
  • Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
  • 基于抽象类的模板设计模式 模板设计模式: 在一个方法中定义一个算法的骨架(在父类中定义),将一些步骤延迟到子类。 模板方法使得子类可以在不改变...星巴克咖啡冲泡 将水煮沸 用沸水冲泡咖啡 将咖啡倒进...
  • 但是有了前面CMath的学习经验,在学习的时候有些自己的体会,与大家分享一下:关于算法的形式化定义部分讲到了定义的四元组,在这一节的习题第9题,说的是如何用一个计算方法模拟另外一个计算方法,扩展一下此题就是...
  • mongoose 中除了以前创建索引的方式,我们也可以在定义 Schema 的时候指定创建索引。 var DeviceSchema = new mongoose.Schema({ sn: { type: Number, // 唯一索引 unique: true }, nam
  • Java运行时无限制的类和资源的重定义。新智云(www.enncloud.cn) HotSwapAgent 项目的主要目的是避免臭名昭著的开发周期,即“更改->重启+等待->检测”。在开发期间保存并重新加载是标准的流程,而且其他...
  • 扩展名使您可以在任何网页上将单词翻译成法语手语。 当您阅读文本并遇到不知道的单词时,突出显示该单词,右键单击并单击“签名”图标:LSF中的符号和法语单词的定义将显示在窗口中。 如果LSF中没有可用的单词,...
  • 扩展欧几里得算法

    2020-10-20 13:34:21
    algorithm),顾名思义就是欧几里得算法(辗转相除)的扩展。 已知整数a,ba,ba,b,扩展欧几里得算法可以在求a,ba,ba,b的最大公约数的同时,能找到整数x,yx,yx,y(其中一个很可能是负数),使它们满足贝祖等式:ax+...
  • 针对弹靶裂纹等不连续因素导致常规有限元方法计算量大和结果精度低的问题,设计一种将水平集扩展有限元相结合的方法。以具体的杆弹侵彻实验为依据,采用指数间断函数来表征裂纹对位移的影响,利用水平集理论...
  • 自相关函数的定义为: 调用自定义函数 zxcor()对砖墙面和大理石面纹理进行分析: 自定义函数 zxcor(): function [epsilon,eta,C] = zxcor( f,D,m,n ) % 自相关函数zxcor(),f为读入的图像数据,D为偏移...
  • 编写一个函数,给定一个链表的头指针,要求只遍历一次,将单链表中的元素顺序反转过来。 由于是单链表且只能遍历...这就需要定义三个指针prior、pCurrent、pNext,指向如下图: 代码清单: node * reverseLinklist
  • 扩展欧几里得

    2019-02-11 21:09:40
    定义 欧几里德算法又称辗转相除,是指用于计算两个正整数a,b的最大公约数。 结论与证明 对于a,b两个正整数(a&gt;b),gcd(a,b)=gcd(a,a mod b)gcd(a,b)=gcd(a,a mod b)。  gcd(a,b)gcd(a,b)即为a与b的...
  • 该规范使用JSON表示法定义了具体的消息定义,并允许定义其他协议。 DIDComm Messaging协议的此扩展引入了协议缓冲区(Protobuf),作为消息合同的语言定义。 Protobuf是语言无关的,平台无关的可扩展机制,用于序列...
  • 根据此最终规则,FDA将FD&C法案中的FDA的“烟草制品”权限扩展到FD&C法案中符合“烟草制品”法定定义的所有其他类别的产品,但此类新认定的附件除外烟草制品。此最终规则还禁止向18岁以下的人出售“隐蔽的烟草制品...
  • 前言 微元前言定义扩展 定义扩展
  • 欧拉筛扩展

    2019-03-05 18:07:33
    不难发现,如果我们用它的最小质因子来筛选,就可以保证每个合数只被筛选一次,这便是欧拉筛。 而欧拉筛的扩展就在于它可以在筛素数的同时求积性函数。 积性函数定义:对于一个函数f(x)满足:若gcd(a,b)=1,则f...
  • 文章目录Church Numeral的定义品味:定义的合理性合理性1:同构合理性2:设计扩展:整数和有理数负数和减法除参考 Church Numeral的定义 定义参考1 zero s z = z incr n s z = n s (s z) -- = s (n s z) -- data ...
  • 从Java到C++——常量值的使用和定义

    千次阅读 2014-04-10 15:37:17
    程序中常常会用到常量值来定义一些相对固定的有实际意义值。比如,你要定义一个扑克牌的类,扑克牌有花色和...如果某一天扑克出现新玩增加一个花色,只有增加一个常量值就可以,扩展性强; Java中常量的定义  Jav
  • 牛顿

    2021-03-24 19:52:24
    定义函数:,考虑等式:,通过线性近似可获得牛顿的更新规则。假设已知靠近最优解,在处对函数做一阶泰勒展开有: , 则可近似为: 。 在某些条件下,若将视作最优的近似,则有: , (1) 式(1)即为牛顿的更新...
  • 欧几里得与扩展

    2018-06-17 08:36:00
    gcd递归定义:对于任意正整数b,gcd(a,b)= gcd(b,a mod b)。 证明:    只需要证明上面两者能相互整除。  设gcd(a,b)= d,所以d | a 且 d | b。由带余除可以得出:  a mod b = a - qb。...
  • 从Java到C++——常量值的使用和定义 程序中常常会用到常量值来定义一些相对固定的有实际意义值。比如,你要定义一个扑克牌的类,...如果某一天扑克出现新玩需增加一个花色,只有增加一个常量值就可以,扩展性强;
  • ES6对象的扩展

    2018-02-02 18:03:00
    对象的扩展 对象类别 普通对象: 拥有JS对象所有默认的内部行为; 奇异对象: 其内部行为在某些方面别于默认行为; 标准对象: 在ES6中被定义的对象, 如 Date, 标准对象既可以是 普通对象, 也可以是 奇异对象; 内置对象:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 996
精华内容 398
关键字:

扩展法定义