[原创][python] 用爬虫做翻译--pstr程序的注释翻译举例

这里只有作者精心编写的学习经历!
回复
头像
hellohappy
网站管理员
网站管理员
帖子: 269
注册时间: 2018年11月18日, 14:27
Been thanked: 1 time

#1 [原创][python] 用爬虫做翻译--pstr程序的注释翻译举例

未读文章 hellohappy » 2018年12月20日, 02:49



目录:写了很多内容,所以需要加一下目录:

第一帖:
    为什么要用python文字翻译
    采用模拟人类使用浏览器访问网页
        第一步,我们可以把这个源代码复制到一个txt文件里面
        第二步,我们要去找一个能做翻译的网站
        第三步,开始分析网站是如何请求数据的
        第四步,尝试第一次post请求,发现搜狗翻译做了反爬。
    本人觉得后面反反爬的部分不适合直接公开,所以另外开一贴。
    翻译的结果和杂碎的文件。

第二帖:
    引言和版权申明
    检查搜狗翻译的反爬机制
    找加密算法的方法是:
        
1.先ctrl+F5强制刷新浏览器,这样可以排除你后来乱点时候加载进来的js文件。
        2.再把所有的js文件下载下来,或复制下来。
        3.搜索关键字尝试读懂源代码
    找到“s”的参数的加密方法:
    找到uuid参数的加密方法:
    破译完整个搜狗翻译的反爬逻辑框架!下面开始写相应的python代码。
    你该如何修改源代码以保证你还能使用?


第三帖:
    pstr代码和法语注释翻译代码


pstr的Rats版本法语源代码:
gtvd.zip
(9.99 KiB)
gtvd.zip
(9.99 KiB) 尚未被下载



首先,为什么要用python文字翻译,而不直接用网上的翻译网站直接翻译?
    pstr是指面板平滑转换回归。他的Rats的程序是用法文注释的。要看懂程序,看注释是十分必要的!
    所以就产生了以下需求:
        1.要翻译法文注释,数量庞大的要翻译的内容,而且内容不是连续的;
        2.要把翻译出来的内容,放在注释的附近,翻译出来的内容我需要自己排版,而不是连成一片的。
    所以就需要借用python来完成这一件事啦!

    用python去翻译有两个策略:
        一个是,模拟人类使用浏览器访问网页,让网页把你识别成人类的正常访问。
        另一个是申请 翻译网站的合法api密匙,以开发者的角色正常访问人家的翻译服务器。
        前者在正常频率的访问下一般不会被拒绝或者被判定为非法,后者一定不会判定为非法,而且速度一般要快的多,但是后者一般有次数限制,超过次数你可以购买次数。


由于本身要翻译的内容不多,而且图方便,这里是采用模拟人类使用浏览器访问网页。看到后面你会知道,根本没有方便!人家都已经做了防爬了,如果一开始知道这么复杂,宁愿一开始就用api。
    那么第一步是观察要翻译的内容都有什么特征(我随便抽一段出来看看):
pstr法语源代码截图1.png
pstr法语源代码截图1.png (24.61 KiB) 查看 444 次
pstr法语源代码截图1.png
pstr法语源代码截图1.png (24.61 KiB) 查看 444 次

    显然,这个程序的注释是以 * 开头的,而我们要翻译的文字一般就在 * 的后面,但是为了防止把乘法看成 * 号,我们应该对每一行检测最后一个 * ,只翻译最后一个 * 后面的法文注释。另外,开头以第一个是 * 的,基本上可以肯定是注释。

    第一步,我们可以把这个源代码复制到一个txt文件里面,保存成比如 123.txt 这样做他会自动给txt编码,这样就不用在python里面识别文件的编码形式了。因为我们也不知道src为后缀的原来的代码到底是用什么格式编码的。。我将这个123.txt文件放在了D盘。

    第二步,我们要去找一个能做翻译的网站,比如搜狗翻译,谷歌翻译,有道云翻译,百度翻译等等。
emmm。。。十分可惜,我本来想着可以偷懒直接拿以前写的代码出来分享的,但是原来的代码用的是有道云翻译,他现在已经反爬了,原来的方法已经用不了了,后面我可以附上原来有道云的代码(代码已失效)
    其中有道云翻译,OMG,他做了反爬!基本可以放弃。或者你没事干故意对着干也行,我大概看了一下,有道云的加密还是在主要还是在客户端这边,请求的时候只需要你的关键参数符合要求,就可以返回正确的结果,包括以下参数啦:salt、sign:、ts、bv;由于是在客户端做的计算,你可以自己查看返回的静态代码,然后找到这些参数是怎么算出来的
    谷歌翻译默认是https连接的,这样对于每一次请求翻译的量不大,而请求次数多很不利,返回也比较慢。而且https本身也会增加我们的代码量,所以也放弃。
    最后选了搜狗翻译。http连接,虽然也有反爬。。。
    (至于怎么查看是否反爬?我其实也没什么经验,接触的比较少主要是反爬的技术很多很多,如果是针对别的网站,肯定不只是这么简单的反爬,比如对同一个ip地址过高频率的访问设置验证码,直接替换掉某些返回的字段,用js在某些字之间插入某些字符,对返回的数字进行运算以后再显示,随机用图片替换某些文本,通过js计算某些校验值,校验没通过就返回错误信息,等等。直接去读取返回的值有可能会得不到正确的想要的值,不过看post请求的header大概能看出来看出来请求的时候是否有反爬验证,其他的可能还真看不出来,下面会仔细分析我懂的部分。)

    第三步,开始分析网站是如何请求数据的

        来到搜狗翻译首页,由于我们要翻译的内容是法语到中文,先改成法语到中文。
搜狗翻译首页.png

        然后打开浏览器的开发者工具,我用的是搜狗高速浏览器,直接按F12就可以打开。别的浏览器一般也是F12,只是开发者工具的界面可能不一样。
        点击打开 Network -> XHR :
开发者工具.png

        然后我们观察输入文字或者点击翻译按钮的时候,会有哪些文件多出来:
        发现每点一次翻译按钮,都会多出一个文件,这个文件叫 translateV1。然后我们点击这个文件,可以直接看到这个请求的headers:
点开这个请求文件_可以看到header.png

        点击response可以看到返回的结果,里面还包含了我们要的翻译结果:
点击response可以看到我们要的翻译结果.png
点击response可以看到我们要的翻译结果.png (25.94 KiB) 查看 440 次
点击response可以看到我们要的翻译结果.png
点击response可以看到我们要的翻译结果.png (25.94 KiB) 查看 440 次

        所以我们要做的事情可以概括为,模拟一次post请求,请求要求送给服务器的内容就在这个headers里面都写了,然后接受返回的数据,找到我们的翻译结果。

        前面说了这个搜狗翻译有没有做请求上的反爬,可以通过headers看出来:
        方法是,换一个要翻译的内容,然后再看一下这个新的文件的headers,看看哪些值变了,如果除了要查询的内容变了(不用看cookies),其他值都没变,一般就没有做请求反爬。
变了哪些内容.png
变了哪些内容.png (12.25 KiB) 查看 439 次
变了哪些内容.png
变了哪些内容.png (12.25 KiB) 查看 439 次

    第四步,尝试第一次post请求,发现搜狗翻译做了反爬。

        可以看到搜狗翻译的uuid和要翻译的内容text都发生了变化!当换一个浏览器访问同一个网页或者换一个要翻译的内容时候,s也发生了改变。所以它可能也做了请求反爬!如果他对请求的s和uuid进行检测的话。但是仔细看请求的url,他是这样的(为了防止被解析成链接,我加了个空格)
        http: //fanyi.sogou.com/#fr/zh-CHS/explicatives%20non%20inclues%20dans%20les%20variables%20de%20threshold%20%E8%90%A8%E8%8A%AC
        而且直接复制这条url到另外一个浏览窗口可以直接打开并得到翻译结果。这就是说,有可能可以用get的方法获得翻译。另外,如果他不设防,也就是uuid和s如果是一个无关紧要的参数的话,那post方法也可以得到翻译结果。(用get的方法直接请求url会返回整个页面,由于页面通常很大,这样会导致我们的程序很慢,而且要解析的内容也会变多。最好是用post(应该说是用XHR),动态请求数据,返回的结果就是前面看到的 response 里的那一点点。)
       我们看一下正常的post请求的返回值response:在浏览器上面的开发者工具上面的 NetWork -> XHR -> translateV1 -> response 上

Code: 全选

{"data":
  {
    "detect":
    {
      "zly":"zly",
      "detect":"fr",
      "errorCode":"0",
      "language":"法语",
      "id":"a23d58e0-a89f-441f-b478-c38a6ee7ad13",
      "text":"*\t\tsur la troisième carte supplémentaire. Si exoz=0 cette troisième liste est absente de l'appel de la"
    },
    "translate":
    {
      "qc_type":"1",
      "zly":"zly",
      "errorCode":"0",
      "index":"content0",
      "from":"fr",
      "source":"sogou",
      "text":"*\t\tsur la troisième carte supplémentaire. Si exoz=0 cette troisième liste est absente de l'appel de la",
      "to":"zh-CHS","id":"a23d58e0-a89f-441f-b478-c38a6ee7ad13",
      "dit":"*在第三张附加卡上。如果exz = 0,则调用中缺少第三个列表",
      "orig_text":"*\t\tsur la troisième carte supplémentaire. Si exoz=0 cette troisième liste est absente de l'appel de la",
      "md5":""
    }
  },
"zly":"zly",
"info":"success",
"status":0
}
        post请求的返回值response里,我们要的数据在 data -> translate -> dit 。
        只需要将返回的数据,用 json 解析,然后找到这个 dit 即可。
        下面是我第一次尝试的post请求,看看搜狗翻译是否能正常返回结果:
搜狗翻译第一次post常数.png
搜狗翻译第一次post常数.png (30.52 KiB) 查看 433 次
搜狗翻译第一次post常数.png
搜狗翻译第一次post常数.png (30.52 KiB) 查看 433 次

        结果不行,返回的数据十分奇怪, dit 是一个随机码,根本不是翻译结果!如图:
第一次post结果.png
第一次post结果.png (10.86 KiB) 查看 433 次
第一次post结果.png
第一次post结果.png (10.86 KiB) 查看 433 次

        好吧,看样子人家也是做了防机器人的手段的。既然如此只好继续攻破它了。本来只是想分享一下以前的战果,没想到现在大家都搞反爬了,又要自己再去研究一遍!

    由于我觉得,后面这一部分应该是用来学习的,我不希望有人把他变成商业用途,或者一直消耗搜狗的服务器,所以剩下的部分,你需要登录才能查看。
    再三强调,我只是尝试教你怎么爬取,仅仅用于学习,不是教你去搞人家的服务器。我还是建议大家用api去合理合法爬取人家的信息!



最后,我把pstr的Rats程序的法文注释的翻译的结果给你们呈上!
以前的程序的翻译结果:

带翻译的源代码.zip
(15.36 KiB) 下载 2 次

这个结果有个缺陷,因为当时是用自动识别来翻译的,有时候他会自动识别成别的语言,从而翻译的不准,新的程序就直接把这个识别成法语,所以一定程度上更有参考价值。

新的pstr的Rats程序的法文注释的翻译的结果:
456.txt
(56.13 KiB)
456.txt
(56.13 KiB) 尚未被下载

最后附上一些杂碎的东西!

123.txt
(38.75 KiB)
123.txt
(38.75 KiB) 尚未被下载

hellohappy

谢谢老板~

使用微信扫描二维码完成支付


Link:
Hide post links
Show post links

头像
hellohappy
网站管理员
网站管理员
帖子: 269
注册时间: 2018年11月18日, 14:27
Been thanked: 1 time

#2 Re: [原创][python] 用爬虫做翻译--pstr程序的注释翻译举例

未读文章 hellohappy » 2018年12月20日, 09:56

请不要用于非法用途,这样的话搜狗很快就会改算法,而且只会让反反爬越来越难!
二是尊重一下作者,转载请保留我的链接地址。


检查搜狗翻译的反爬机制

    首先,上面返回的错误结果说明,搜狗翻译post请求里面,uuid和s等地方的参数都是有效信息。搜狗翻译发现你的uuid和s是错误的,他就会返回给你一个错误的结果,也就是那个随机数字!其实还有一种手法,服务器随机返回正确的结果或错误的结果,这样的话你甚至很难调试,因为你根本不知道你的到底算法有木有弄对!现在你只要检查一下是否返回一堆随机数和字母就知道是不是失败了!
    想要找到解密的算法,当然要先去看一下每一次post请求,到底调用了哪些文件。
    由前面我们知道,每一次点击翻译按钮,只有一个文件在 开发者工具 -> NetWork ->XHR 下发生了改变,也就是那个 translateV1 文件,然后我们需要看一下,每一次点击翻译按钮 NetWork -> All 下有哪些文件发生了变化 浏览器调试工具下的 NetWork -> All 就在 NetWork -> XHR隔壁
all下变化的文件.png
all下变化的文件.png (6.23 KiB) 查看 428 次
all下变化的文件.png
all下变化的文件.png (6.23 KiB) 查看 428 次
    All的意思是全部,也就是每次post有三个文件发生了变化,其中一个就是 translateV1 ,另外两个不知道是什么,但是我们需要点进去看一下这两个的返回值(也就是他们的response),看看是不是从服务上返回了什么数据。如果有从这两个文件这里返回数据,那你可能在找解密算法时候,要考虑服务器返回值是不是变了。
看all下的更改的文件是不是有返回值.png
    这里我亲自看过两个文件,两个都没有返回值。也就是,这个uuid和s参数的值发生变化的来源是在本地。既然在本地生成,那来源就可以直接从静态文件(也就是服务器返回给我们浏览器的静态的文件)里面找。
    所以我们要去找静态文件,一般加密算法会放在js文件中(一般这些js都经过了压缩和混淆)。

    找加密算法的方法是,在打开开发者工具的情况下,

        1.先ctrl+F5强制刷新浏览器,这样可以排除你后来乱点时候加载进来的js文件。

        2.再把所有的js文件下载下来,或者说,复制下来。同时建议你用一些工具把代码进行标准格式化,请自行搜索“ JavaScript/HTML格式化工具” 如图:
        点开source下的所有文件
展开这里的所有静态文件.png
展开这里的所有静态文件.png (27.34 KiB) 查看 428 次
展开这里的所有静态文件.png
展开这里的所有静态文件.png (27.34 KiB) 查看 428 次
        点开所有的 source后,source就在NetWork旁边找到所有的js文件,并把他们复制下来,放到 txt 或者 新建的js文档 里面。
复制所有的js文件源码.png
复制所有的js文件源码.png (37.93 KiB) 查看 428 次
复制所有的js文件源码.png
复制所有的js文件源码.png (37.93 KiB) 查看 428 次
        当然你也可以不用这么麻烦,直接按ctrl+s整个网页全部保存起来自己去找所有的js文件就可以了。但是自己亲自像上面这样去点开js,有利于你一开始就排除掉一些一看就知道不是的js文件。

        3.搜索关键字尝试读懂源代码

            我们前面已经把js文件里面的源代码已经复制下来了,下面就应该尝试读懂他们。如果太复杂的源代码,我们可能要学会放弃!
            由于有些关键字,比如这里传参的关键字(from、to、client、fr、text、pid、useDetect、useDetectResult、needQc、uuid、oxford、isReturnSugg、s)等,他们在js中一般是会有保留的,这样他们才能在本地处理这个加密的算法并把结果传给浏览器,什么情况会变,或者说即使给你找到,你也拿他没办法?没有和关键字一一对应他怎么给浏览器传参?(其实也可以传参啊,他可以通过调用函数的方法,用函数或者别的机制(比如数组?传过去他按顺序解析就可以了,前20个字符是啥,后面几个字符是啥这样)传参,这样的话传参时候顺便把参数的名字给换了,调用多几个函数,你可能就找不到原始参数被调用到哪里了。(也就是进一步的混淆)当然现在搜狗翻译没有做的这么绝情
            由于我们大概知道uuid和s是重要关键字,所以可以把重点放在这两个变量上(当然搜索s这个变量说真的没什么用,s是单字符,压缩代码或者人家随意弄几个同样的变量名字还是比较容易混淆的,你随便一搜可能一大堆的 s ),然后你会搜索到这么一个地方:当然还有几个别的地方也是包含了uuid、s等的字样,但是明显没有这个这么整齐的对应,所以找到这个位置还是比较正常的!比如你找到这一段:
var v = d("" + a + c + n + "41ee21a5ab5a13f72687a270816d1bfd"), 
 y = {
                 "from": a,
                  "to": c,
                  "text": n,
                  "useDetect": "on", 
                  "useDetectResult": "on",
                  "needQc": 0, 
                  "uuid": h,
                  "oxford": "on",
                  "isReturnSugg": "off",
                  "isStroke": "on", 
                  "fr": "selection",
                  "s": v                },
这个其实就是当你不是点翻译按钮,而是你划词时候调用的,他也是和相应的post请求一一对应。
等你看完后面,你再回来看这一段话:
这里这一段的加密函数是d(),仔细分析d函数是在哪里定义的,没错,就是一个叫 n(39) 的地方定义的!这个n是从function的最外层传进来的,这个结论和我后面分析时候是一致的,大家的加密函数都是n(39),都是从最外层的function的第三个参数传进来!最后我们都知道这是一个md5加密程序。
js源码中的数组.png
js源码中的数组.png (18.97 KiB) 查看 428 次
js源码中的数组.png
js源码中的数组.png (18.97 KiB) 查看 428 次
            哇这么会有这么整齐的~~赋值过程,完全和post请求上面的Data参数的值一一对应嘛,没错,从这里开始看。

找到“s”的参数的加密方法:

            “s”参数是由F给出的,而F的定义就在这张图的最上面一行!然后看一下这段代码:

Code: 全选

var F = s("" + L + O + B + "41ee21a5ab5a13f72687a270816d1bfd"),
            F是由一个叫s的函数算出来的,其中的参数就是这一个长长的字符串,字符串由from的值L,to的值O,text的值B和一个不变的字符串连起来。
            事实上,如果 搜狗翻译 懒的话(懒得修改整个验证代码),他可以直接修改这个所谓的不变的字符串,以此来直接修改整个的结果的值。从而即使你拿到别人写好的代码也一样用不了,你还是必须亲自找到这个源代码中的这一窜字符串。比如 搜狗翻译 每七天换一次这个字符串,那你就每七天就要重新找一下这个字符串的值,一定程度上这个方法还是可以搞定很大一部分的 “机器人”的!

            然后你去找s函数在哪,一般都在同一个js文件里面。
            这里要细心,仔细看这个是小写的s,我们选中 s ,然后向上找,看到大写的S记得忽略,比如这里:
找到加密函数1.png
找到加密函数1.png (9.04 KiB) 查看 426 次
找到加密函数1.png
找到加密函数1.png (9.04 KiB) 查看 426 次
          这个叫translate的函数下面有一个参数 S=n(46) ,难道是这里传进来的? 看清楚,人家是大写,不是这里,然后继续向上找,我这里向上找的意思,其实准确来说是指代码逻辑的“上”,也就是如果是按照规范缩进的代码,同级的就是有相同缩进的代码,而自己的上一级的,就是缩进比你少一个的代码,这里说的“上”是指上一级的代码,因为如果 s 不是在本级定义,那他就是在上一级定义或者上上级定义,反正一定会有定义的。
          果然在不远处,找到了这样的一段代码:
找到加密函数2.png
找到加密函数2.png (18.93 KiB) 查看 426 次
找到加密函数2.png
找到加密函数2.png (18.93 KiB) 查看 426 次
          这里说的是: s 在 n(39)的地方定义,从而我们要找n是在哪里定义,直接就找到了最外层的函数function了,n是直接通过function的第三个参数定义的。这里说function是最外层是不准确的,明显最外层是 webpackJsonp 函数嘛,我们的函数function是 webpackJsonp 函数的第二个参数,位于第二个参数的第不知道多少个逗号之后

          现在总算知道这个加密函数哪里来的了,但是他是外面传进来的,我们怎么找?
          这个内容需要知道一点webpack的加载顺序,加载逻辑的知识,由于这一段不好讲,我们先跳过。
          我们先忽略这个n(39)到底是怎么找到他的,大概知道他是一个md5的加密。
          对那一大串字符串进行md5运算,然后赋值给 “s”。

找到uuid参数的加密方法:

          现在终于找到了s的计算方法,那uuid呢?uuid怎么算出来的?回到这张图片:
js源码中的数组.png
js源码中的数组.png (18.97 KiB) 查看 428 次
js源码中的数组.png
js源码中的数组.png (18.97 KiB) 查看 428 次
          uuid的值是 M 给的,我们向上找到 M 的值,M是由 o 给的,o的get()方法给的,注意这个是小写 o ,千万不要看成大写然后以为 o 是 t 和 d 给的。。。
找到第二个加密函数1.png
找到第二个加密函数1.png (4.83 KiB) 查看 424 次
找到第二个加密函数1.png
找到第二个加密函数1.png (4.83 KiB) 查看 424 次
          继续向上找小写 o ,然后找到了o是由n(13)给的,n是最外层的function的第三个参数传进来的。
找到第二个加密函数2.png
找到第二个加密函数2.png (3.1 KiB) 查看 424 次
找到第二个加密函数2.png
找到第二个加密函数2.png (3.1 KiB) 查看 424 次
          前面没有讲找 s 参数时候,怎么知道他是md5加密函数加密的,因为那个有点难讲,这次这个 n(13) 可以仔细的讲一下他是怎么来的。你可以类比前面md5怎么来。
              首先我们搜索“ "13":  ” 没错,就是搜索 "13":  ,不是叫你搜索13 找到他在另外一个js里面,有一段是长这样的:
找到第二个加密函数3.png
找到第二个加密函数3.png (12.47 KiB) 查看 423 次
找到第二个加密函数3.png
找到第二个加密函数3.png (12.47 KiB) 查看 423 次
              可以看到这个函数刚好有个get的方法(或者说函数),大概读一下他的意思:

Code: 全选

 "get": function() {
                    var t, e, n = "";
                    for (t = 0; t < 32; t++)
                       e = 16 * Math.random() | 0,
                       8 !== t && 12 !== t && 16 !== t && 20 !== t || (n += "-"),
                       n += (12 === t ? 4 : 16 === t ? 3 & e | 8 : e).toString(16);
                    return n
                }
              这一段代码确实有点难读懂,因为他已经经过混淆了。没有js基础的话需要你自己先去自学一下哦,虽然可能你不懂js也能看懂,如果你学过别的编程语言的话。for语句对应的内容是一个逗号表达式,依次执行。
              来看for ,这个for里面的t,明显只是用来数数字用的,从1数到32。仔细观察 uuid的值:f0a41cdd-2f60-41ee-873b-43ebf19fe441,去掉 “ - ”这个符号,刚刚好32位!
                  逗号表达式的第一句,Math.random() 是生成一个0到1的小数,根据运算符顺序,应该先执行乘法 16 * Math.random() ,这保证了生成一个随机的0到16的小数;再加上右边的 | 0 ,这个的意思是取小数的整数部分。由于不可能刚好取到16,所以第一个逗号表达式的意思是生成一个0到15的随机整数。
                  逗号表达式的第二句,|| 的意思是 或 运算,他有个特点就是,一旦前面(左边)的运算结果为真,后面(右边)就不执行了,看一下左边表达式,他的意思是,当t=8,12,16,20的时候为假,其他都为真,所以当循环到8,12,16,20个字符的时候,就会执行 n += "-" ,这个不就刚好是uuid的斜杠的位置嘛! += 号的意思都不懂的话可能还是需要再学习一下哦
                  逗号表达式的第三句,t = 12 的时候,值为4 ,你仔细观察一下,是不是无论怎么点浏览器,怎么修改要翻译的文本,uuid的第12个数字总是4呢,对啊!然后 t=16 的时候,执行balabala这个balabala的意思是,16进制一共有4位,把16进制的前两位变成 1 0 。,t不等12也不等16的时候,就取e。反正这里就是生成一个随机数,规则就是这样。然后最后有一个 .toString(16) 这个的意思是转换为16进制!也就是把1到16转换为: 123456789ABCDEF 。
              整一段代码的意思是生成一个大概长这个鬼样的uuid:f0a41cdd-2f60-41ee-873b-43ebf19fe441 ,没有调用别的函数了。
              到此,我们已经破译了uuid的算法了。

        下面我们可以开始写我们的python代码妈呀!怎么这么久才破译完!唉,要是他不反爬我早就睡觉了,还在这里码字!

破译完整个搜狗翻译的反爬逻辑框架!下面开始写相应的python代码:这里说破译完,其实是后话,没成功之前你是不知道还有什么障碍的!
    由于精力不足(我想睡觉了!),我就随便写了一下,也不进行代码规范整理了
 

Code: 全选

 #CopyRight 2018 ZWYang
#www.postgraduate.top

import urllib.request
import urllib.parse
import math
import random
import hashlib
import binascii
import json
import time
import re

#sogoufanyi是进行搜狗翻译post的主函数
def sogoufanyi(content):
    #data的参数直接改下面的内容即可!
    url="http://fanyi.sogou.com/reventondc/translateV1"
    data={}
    data["from"]="fr"
    data["to"]="zh-CHS"
    data["client"]="pc"
    data["fr"]="browser_pc"
    data["text"] = content
    data["pid"] = "sogou-dict-vr"
    data["useDetect"]="on"
    data["needQc"] = 1
    data["oxford"] = "on"
    data["isReturnSugg"] = "on"
    
    #构建uuid(完全复原他原来构建uuid的手法)
    #(虽然后来我发现其实搜狗翻译服务器并没有去校验这个uuid是否合法)
    n = ""
    for t in range(32):
        #这是常用的取一位随机数的手法
        e=hex(math.floor((random.random()+1) * 16)).split('0x1')[1]
        if 8 == t or 12 == t or 16 == t or 20 == t:
            n = n + "-"
        if 12 == t:
            n = n + "4"
        else:
            if 16 == t:
                n = n + str(3 & int(e,16) | 8)
            else:
                n = n + e
    data["uuid"] = n
    
    #加密算法 s 
    s = '' + data["from"] + data["to"] + content + '41ee21a5ab5a13f72687a270816d1bfd'
    F = hashlib.md5()
    F.update(s.encode('utf-8'))
    data["s"] = F.hexdigest()
    data=urllib.parse.urlencode(data).encode("utf-8")

    # 增加headers,模拟登陆,而不是对服务器识别为机器登陆。
    headers={}
    headers["User-Agent"]="Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36 SE 2.X MetaSr 1.0"
    headers["Referer"]="http://fanyi.sogou.com/"
    headers["Host"]="fanyi.sogou.com"
                
    req=urllib.request.Request(url,data,headers)
    response=urllib.request.urlopen(req)
    html=response.read().decode("utf-8")

    #不要给人家服务器太大负载,要不可能封了你的ip
    #我的意思是,万一你的ip是学校的ip,
    #你是不是就害你们学校的人都用不了这个搜狗翻译了?
    #所以我等1秒爬一次
    time.sleep(1)

    #解析并返回json格式的数据
    #(这里没有直接返回翻译结果,
    # 是想着将来如果要再用上面这个代码干别的事,
    # json里面的其他数据还是有用的!)
    target=json.loads(html,strict=False)["data"]
    return target
    
def main():
    #123.txt就是我们要翻译的pstr程序的txt文档啦!
    #456.txt就是翻译成功以后,输出的txt文件。
    readr = open("D:\\123.txt",'r+',encoding= 'gbk')
    read = open("D:\\456.txt",'w+',encoding= 'gbk')
    line = readr.readline()
    read.write("\n*********************************翻译结果****************************\n")
    while line:
        #read.write(line)
        #read.write("^^^^^^^原^^^^^^^\n")
        if line[0]=='*':
            if line[1]=='*' or line[1]=='-':
                read.write('\n')
                #print(line)
                read.write(line)
            else:
                #print(line)
                read.write(line)
                content=line
                #调用post程序
                target = sogoufanyi(content)
                try:
                    dit=target["translate"]["dit"]
                    if dit==' ':
                        read.write('\n')
                    else:
                        read.write("**--------** ")
                        print(dit)
                        read.write(dit)
                        read.write('\n')
                except:
                    print("出错了")
                    read.write("\n* !!!!!!!出错了!!!!!!!!!!!!!!!!!!")
        else:
            words = re.split('([ * ])',line)
            l = len(words)
            if l==1 or words[l-1][-2]=='$':
                #print(line)
                read.write(line)
            else:
                for i in range(0,l-1):
                    #print(words[i])
                    read.write(words[i])
                content=words[l-1]
                read.write(content)
                #调用post程序
                target = sogoufanyi(content)
                try:
                    dit=target["translate"]["dit"]
                    if dit==' ':
                        read.write('\n')
                    else:
                        read.write("                                      **--------** ")
                        print(dit)
                        read.write(dit)
                        read.write('\n')
                except:
                    print("出错了")
                    read.write("\n* !!!!!!!出错了!!!!!!!!!!!!!!!!!!")

                    
        line=readr.readline()#如果没有这行会造成死循环
        #print("//////////////////////////////////////////////////////////////////////////////////////////")
    time.sleep(0)
    read.close
    readr.close

if __name__=="__main__":
    main()


    上面的程序不是很精炼,但是应该能看的懂吧!你如果不想要他在python的idle输出信息,你可以自己把print的地方注释掉。
基本上就是照着post请求的时候的headers上的内容抄下来,然后亲自算一下uuid和s参数,然后post请求,然后解析出翻译结果,打印到txt文档中。

你该如何修改源代码以保证你还能使用?


    这里如果你发现上面的代码用不了了,又返回一堆乱码的翻译结果,那有可能是搜狗翻译修改了那一长串的所谓的不变的字符串。你需要的是找到这个js文件,然后搜索相应的代码段,找到这一串所谓的不变的字符串,替换掉上面的程序中的这个字符串。
找到这个js.png
找到这个js.png (24.12 KiB) 查看 411 次
找到这个js.png
找到这个js.png (24.12 KiB) 查看 411 次
搜索下面这个程序:(注意,这里的所有字母都可能会变化,比如F、L、O、B、W等),你一个搜索哪些不变的,比如"clinet"、"useDetectResult"、"uuid"
 

Code: 全选

var F = s("" + L + O + B + "41ee21a5ab5a13f72687a270816d1bfd"),
            W = {
                "from": L,
                "to": O,
                "client": "pc",
                "fr": "browser_pc",
                "text": B,
                "pid": "sogou-dict-vr",
                "useDetect": "on",
                "useDetectResult": "auto" === L ? "on": "off",
                "needQc": _.need,
                "uuid": M,
                "oxford": "on",
                "isReturnSugg": "on",
                "s": F
            };
替换掉字符串"41ee21a5ab5a13f72687a270816d1bfd"即可。
最后附上python的源码,因为有可能你从上面复制下来的代码没办法直接在python对齐使用(python对缩进极其严格!)
法文翻译2018.zip
(2.09 KiB) 尚未被下载

Link:
Hide post links
Show post links

头像
hellohappy
网站管理员
网站管理员
帖子: 269
注册时间: 2018年11月18日, 14:27
Been thanked: 1 time

#3 Re: [原创][python] 用爬虫做翻译--pstr程序的注释翻译举例

未读文章 hellohappy » 2018年12月21日, 17:10

pstr带法语注释源代码:

Code: 全选

* proc gtvd depvar
* #x1 x2 ...
* #q1 q2 ...
* #z1 z2 ...
*
* avec :
* depvar = nom de l'expliquée
* x1 x2 = liste des explicatives sur lesquelles portent la ou les transitions
* q1 q2 = liste des variables de transition
* z1 z2 = liste des explicatives non affectées par la ou les transitions. Liste présente si exoz=1
*
* remarque :
* - Le nombre de variables de transition,r , définit le nombre de fonctions de transition.
* Par exemple '#q1 q1' définit deux fonctions de transition ayant comme argument q1
* - Les données doivent être décrites par une instruction allocate/calendar de type données de panel
*
* Options :
* m = Vecteur ayant r composantes spécifiant le nombre de restrictions pour chacune des fonctions de transitions.
* Par exemple m=||3,2|| spécifie deux fonctions de transitions, la première ayant 3 restrictions et la seconde
* en ayant 2. Dans ce cas, on doit avoir deux variables de transition dans l'appel de la procédure.
*
* grilleg = Vecteur spécifiant une grille de valeurs initiales potentielles positives pour les pentes
* des fonctions de transition. Cette grille est identique pour chacune des pentes.
* Par défaut grilleg=||.2|.5|.8|1.3|2.0|2.8|3.7|4.7|5.5|7.0|| (... sans justification particulière)
*
* paramini = [partial]/ all
* Indicatrice gerant la prise des valeurs initiales. Si paramini=all alors toutes les valeurs potentielles
* sur c et gamma sont considérés. Si paramini=partial, les valeurs de gamma et de c du modele ayant
* r fonctions de transition sont pour les (r-1) premières egalisees aux valeurs optimales obtenues avec
* l'estimation du modele a (r-1) fonctions de transition, et seules les valeurs des parametres de la derniere
* fonction sont recherchees dans les grilles. Ce paramètre est actif uniquement si methodini=grid et
* si rc n'est pas defini ou est au plus egal à 1.
*
* nbvalinic = Nombre de valeurs initiales potentielles pour chacun des paramètres de restriction.
* Ce nombre est commun mais naturellement les valeurs sont prises dans les variables
* de transition propre à chacun. Les valeurs correspondant à trimc et (1-trimc) sont
* obligatoirement prises; en conséquence nbvalinic doit être >=2. [10]
*
* trimc = % d'observations utilisées pour le trimming sur les variables de transition [15%].
* Par exemple la valeur par défaut prend des valeurs initiales pour le paramètre
* de restriction depuis le fractile à 15% inclus jusqu'au fractile à 85% inclus de la
* variable de transition correspondante (et dans cet espace la procédure prend nbvalininc-2
* autres valeurs également réparties).
*
* exoz = Indicatrice de la présence de variables explicatives du type z1 z2. Si exoz=1, leurs noms sont lus
* sur la troisième carte supplémentaire. Si exoz=0 cette troisième liste est absente de l'appel de la
* procédure. [0]
*
* mlin = Puissance maximale à considérer sur la variable de transition dans les tests : linéarité vs PSTR
* (eq.4 p. 3 de GTvD). Le développement de Taylor considéré porte sur la dernière variable de
* transition du modèle ajusté. Au premier tour il s'agit de la première de la liste q1 q2 ...).
* Si mlin=0 (valeur par défaut), ce test n'est pas réalisé. [0]
*
* mh = Puissance maximale à considérer dans les tests de constance des coefficients (eqs 13 et 14 p. 7 de GTvD)
* Si mh=0 (valeur par défaut), ce test n'est pas réalisé. [0]
*
* piters = Nombre d'itérations réalisées avec la méthode du simplex si difficulté de convergence avec les
* valeurs initiales prises dans les grilles. [6]
*
* rc = nombre de fonctions de transitions que doit incorporer le seul modèle estimé.
* Si rc est non défini dans l'appel la procédure met en oeuvre un traitement séquentiel. Par exemple
* #q1 q2 demande l'estimation d'un modèle avec q1 comme variable de transition puis d'un modèle avec
* q1 et q2 comme variables de transition. Dans ce cas le nombre de variables de transition doit être
* égal au nombre de valeurs spécifiées dans le vecteur m.
* Si rc est défini alors seul le modèle avec rc variables de transition est ajusté et m doit spécifier
* au moins rc valeurs. Si le nombre de variables de transition est supérieur à rc, les tests de linéarité
* versus PSTR sont réalisés avec ce seul modèle ajusté et successivement pour chacune des variables de
* transition en excès (ceci uniquement si mlin>0). Si rc est défini alors il doit être >0.
*
* methodini = simplex / [genetic] / grid.
* Spécifie le mode de calcul des valeurs initiales sur les pentes et les parametres de restriction des
* fonctions de transition. Les valeurs initiales des pentes avec les deux premières options sont prises
* au hasard où spécifiées lors de l'appel de la procédure, avec une seule valeur par fonction de transition.
* Les paramètres de restriction sont déterminés par une grille qui peut normalement avoir moins de valeurs
* (ce nombre étant donné par nbvalinic) que lorsque l'on emploie une recherche complète dans les grilles, ce
* dernier cas correspondant à l'option GRID. Dans tous les cas, une fois les valeurs initiales obtenues par
* l'une de ces trois méthodes la procédure utilise une maximisation bfgs pour la recherche des valeurs
* finales des estimateurs des pentes et des paramètres de restriction.
*
* graphd = yes / [no]
* Si graphd=yes la procédure calcule et graphe les dérivées par rapport à chacune des explicatives affectées par
* la ou les transitions. Actuellement, les formules utilisées supposent qu'aucune de ces explicatives n'est
* présente dans la ou les variables de transition. On affiche d'une part les résultats afférents à chaque individu
* en tout point des temps et d'autre part les moyennes sur le temps pour chaque individu. Les graphes concernent
* l'évolution dans le temps des dérivées estimées, un graphe est réalisé pour chaque individu.
*
* name = Vecteur de string dont chaque composante est le nom des individus et qui est utilisé pour donner un titre
* aux divers graphiques. L'ordre des noms devant correspondre à celui des entrées du fichier de données. La
* dimension de ce vecteur doit être égale au nombre d'individus étudiés. En son absence, les individus sont
* repérés par leur ordre (1, 2, 3, ...).
*
* Remarques :
* - Il est obligatoire de préciser l'option m= .
*
* - En cas d'observations manquantes, les estimations sont réalisées (y compris les centrages pour éliminations
* des effets fixes individuels) sur les observations non manquantes pour la totalité des variables expliquée,
* explicatives de type x ou z), et de transitions spécifiées dans l'appel de la procédure. En conséquence un
* appel avec par exemple #q1 q2, supprimera notamment les observations pour lesquelles q2 n'est pas renseignée
* et ceci même dans la première étape d'estimation, cad dans le modèle ou seule q1 est utilisée comme variable de
* transition.
*
*********************************************************************************************

************************************************
* définition de la fonction logistique
* améliore la précision des calculs pour x>>>>0
************************************************
function logistic x
type real logistic x
if x<=0{
compute logistic=1./(1.+exp(x))
}
else {
compute logistic=exp(-x)/(1.+exp(-x))
}
end function

*-------------------------------------------------------------
* calcul des élasticité ...... ATTENTION :
* - explicatives non inclues dans les variables de threshold
*-------------------------------------------------------------
proc derive trans_r nobs r m c gamma derive beta explic nbexoz nomsinds

type integer nobs r nbexoz
type vector[integer] trans_r explic
type vector gamma m beta
type vector[string] nomsinds
type rectangular c
type vector[series] *derive ;* derive = séries des dérivées pour chaque explicatives
local integer i j series obs nexplic nlignes
local real git qit
local vector[series] transf ;* transf = valeurs des r fonctions de transition
local vector[series] derive_means
local vector[string] noms_explic
local series rien

compute nexplic=fix(%rows(explic))

dimension transf(r) derive_means(nexplic) noms_explic(nexplic+1)
compute noms_explic(1)='individu'
do i=1,nexplic
compute noms_explic(i+1)=%l(explic(i))
end do i

* construction des r fonctions de transition
do i=1,r
clear transf(i)
end do i
compute i=0
dofor series=trans_r
compute i=i+1
do obs=1,nobs
compute git=1.0
compute qit=%seriesentry(series,obs)
if %valid(qit) {
do j=1,fix(m(i))
compute git=git*(qit-c(j,i))
end do j
compute transf(i)(obs)=logistic(-gamma(i)*git)
}
else {
compute transf(i)(obs)=%na
}
end do obs
end dofor

* calcul de la derivée
do j=1,nexplic
set derive(j) = beta(nbexoz+j)
do i=1,r
set derive(j) = derive(j) + beta(nbexoz+nexplic+r*(j-1)+i)*transf(i)
end do i
panel(indiv=1.0,compress) derive(j) / derive_means(j)
end do j
print(windows='derive,r='+%string(r)) / derive

*graphiques
compute nlignes=%indiv(nobs)/3
if %indiv(nobs)/3.0 - %indiv(nobs)/3 .ne. 0.;compute nlignes=nlignes+1
do j=1,nexplic
extremum(noprint) derive(j)
spgraph(vfields=nlignes,hfields=3,windows=noms_explic(j+1)+',r='+%string(r))
do i=1,%indiv(nobs)
sample(smpl=(%indiv(t)==i)) derive(j) / rien 1
graph(max=%maximum,min=%minimum,header=nomsinds(i)) 1
#rien 1 %period(nobs)
end do i
spgraphs(done)
end do j

display '--------------------'
display 'élasticités moyennes'
display '--------------------'
report(action=define,hlabels=noms_explic)
do i=1,%indiv(nobs)
report(row=new,atcol=1) nomsinds(i)
do j=1,nexplic
report(row=current,atcol=j+1,align=decimal) derive_means(j)(i)
end do j
end do i
report(action=show)
end derive

*--------------------------------------------------------------------------------------------
* construction des produits croisés variables explicatives x fonctions de transition centrées
*--------------------------------------------------------------------------------------------
proc transition trans_r explic nobs r m c gamma explictransf smpl

type integer nobs r
type vector[integer] trans_r explic
type vector gamma m
type rectangular c
type series smpl
type vector[series] *explictransf ;* explictransf = séries contenant les produits croisés explic*transf
local integer i j series obs
local real git qit
local vector[series] transf ;* transf = valeurs des r fonctions de transition

dimension transf(r)
do i=1,r
clear transf(i)
end do i


* construction des valeurs des r fonctions de transition
compute i=0
dofor series=trans_r
compute i=i+1
do obs=1,nobs
compute git=1.0
compute qit=%seriesentry(series,obs)
if %valid(qit) {
do j=1,fix(m(i))
compute git=git*(qit-c(j,i))
end do j
compute transf(i)(obs)=logistic(-gamma(i)*git)
}
else {
compute transf(i)(obs)=%na
}
end do obs
end dofor


* construction des produits croisés explic*transf et centrage sur les moyennes individuelles
compute i=0
dofor series=explic
do j=1,r
compute i=i+1
set explictransf(i) = transf(j)*series{0}
panel(entries=1.0,indiv=-1.0,smpl=smpl) explictransf(i)
end do j
end dofor
end transition


*--------------------------------------------------------------------------------------------
* construction de la grille sur c et du vecteur controle
*--------------------------------------------------------------------------------------------
proc grillec trans_r grillec m trimc nbvalinic nbparamc controle smpl

type vector[integer] trans_r
type integer nbvalinic nbparamc
type real trimc
type vector m *controle
type rectangular *grillec
type series smpl
local integer i j k nb_param_c series
local real minc maxc
local rectangular rien

compute i=0,nb_param_c=0
dofor series=trans_r
compute i=i+1
make(smpl=smpl) rien
#series{0}
compute minc=%fractiles(rien,trimc)(1), maxc=%fractiles(rien,1.-trimc)(1)
do k=1,fix(m(i))
compute nb_param_c=nb_param_c+1
do j=1,nbvalinic
compute grillec(nb_param_c,j)=minc+(j-1)*(maxc-minc)/(nbvalinic-1)
end do j
if k>1 {
compute controle(nb_param_c)=1
}
end do k
end dofor
disp 'valeurs initiales sur c'
write grillec
end grillec

*-----------------------------------------------------------------------------------------------
* verification de l'appartenance des paramètres de restriction à l'espace défini par le trimming
*-----------------------------------------------------------------------------------------------
proc verifc trans_r c m trimc smpl

type vector[integer] trans_r
type rectangular c
type real trimc
type vector m
type series smpl
local integer series i
local real minc maxc
local rectangular rien

compute i=0
dofor series=trans_r
compute i=i+1
make(smpl=smpl) rien
#series{0}
compute minc=%fractiles(rien,trimc)(1), maxc=%fractiles(rien,1.-trimc)(1)
do k=1,fix(m(i))
if c(k,i)<minc .or. c(k,i)>maxc {
display 'Attention : le paramètre estimé' +c(k,i) 'dans la fonction de transition numéro' +i
display @15 'est extérieur au domaine défini par le trimming (' +minc +',' +maxc +') pour' +%l(series)
}
end do k
end dofor
end verifc




*--------------------------------------------------------------------------------------------
* programme principal
*--------------------------------------------------------------------------------------------
proc gtvd depvar

*********************************************
* entrée des informations de base et controle
*********************************************
type series depvar
local integer rmax rmin r i j k ic ok obs nobs series mi g ilin methodini paramini graphd
local integer nb_valini_gamma nb_essai_gamma nbparamc nb_essai_c dl1 dl2 nbexoz nbreg
local real qit git objectif objectif_opt objectif_s stat
local vector grille_gamma
local vector cvec controle ;* cvec : vecteur constitue des nbparamc parametres c pris dans la grille grillec
;* controle : verifie que cvec correspond a un cas devant etre considere
local vector beta ;* beta contient les estimateurs OLS des coefficients obtenus à la fin de la seconde étape (utilisé par proc derive)
local vector gamma gamma_opt gamma_opt_preced ;* gamma = pentes des r fonctions de transition (rx1)
local rectangular grillec ;* grillec = grille des valeurs pour les restrictions c
local rectangular c copt copt_preced ;* c = valeur des restrictions (m_max x r)
local vect[integer] explic ;* explic = liste des variables explicatives sur lesquelles portent la ou les transition(s)
local vect[integer] trans ;* trans = liste des variables de transition
local vect[integer] iexoz ;* iexoz = liste des explicatives sur lesquelles ne portent pas la ou les transition(s)
local vect[integer] trans_r ;* trans_r = liste des variables de transition dans le modèle courant
local series smpl depvarc ;* smpl = repère les observations non manquantes, utilisé dans instruction panel pour que
;* le centrage ne porte que sur les observations complétement renseignées de chaque
;* individu en cas d'échantillon non cylindré
;* depvarc = depvar centrée sur moyennes individuelles
local vector[series] derive ;* derive = valeur des dérivées relativement aux explicatives
local vector[series] explictransf ;* explictransf = séries contenant les produits croisés explic*transf
local vector[series] explic_c ;* explic_c = series explic centrées sur leurs moyennes individuelles
local vector[series] explic_l ;* explic_l = series utilisées dans le test linéarité vs PSTR et de constance des coef.
local vector[integer] iexplic_l ;*iexplic_l = liste correspondant aux séries explic_l utilisée dans l'appel de proc transition
local vector[series] explic_lc ;* explic_lc = series utilisées dans le test de constance des coefficients
local vector[series] iexoz_c ;* iexoz_c = séries non soumises à transitions centrées sur leurs moyennes individuelles
local vector[string] nomsinds ;* reprend les éventuels noms passés par name
option vector m
option vector grilleg
option integer piters 6
option integer nbvalinic 10
option real trimc .15
option integer mlin 0
option integer mh 0
option integer exoz 0
option integer rc
option choice methodini 3 simplex genetic grid
option choice paramini 1 partial all
option choice graphd 2 yes no
option vector[string] name

enter(varying) explic
enter(varying) trans
if exoz {
enter(varying) iexoz
compute nbexoz = fix(%rows(iexoz))
}
else {
compute nbexoz=0
}
* calcul du nombre total d'observations
set depvarc = 1
stat(noprint) depvarc
compute nobs=%nobs

* liste des modèles à ajuster
if %defined(rc) {
if rc==0 {
display 'vous devez avoir rc>0. Ici vous demandez à ajuster un modèle sans transition'
return
}
compute rmin=rmax=rc
}
else {
compute rmax = fix(%rows(trans)),rmin=1
}

* verification de la definition de m
if %defined(m)==0 {
display 'vous devez definir les nombres de restrictions identificatrices pour chacune des fonctions de transition'
display 'avec une option : m=||m(1)|m(2)|....|m(r)|| ou r est le nombre de fonctions de transition'
return
}
if fix(%rows(m))!=rmax .and. (.not.%defined(rc)) {
display 'vous devez avoir autant de variables de transition que de composantes du vecteur m'
return
}
if fix(%rows(m))<rmax .and. %defined(rc) {
display 'vous devez avoir au moins' rc 'composantes dans le vecteur m'
return
}

* verification de le definition de grilleg lorsque genetic ou simplex est employe
if %defined(grilleg) .and. (methodini==1 .or. methodini==2) .and. %rows(grilleg)!=%rows(m) {
display 'avec methodeini = genetic ou methodini = simplex vous devez avoir autant de valeurs initiales pour gamma'
display 'que de fonctions de transition'
return
}
if nbvalinic<2 .and. methodini==3 {
display 'vous devez imposer un nombre de valeurs initiales pour les paramètres de transitions >= 2 lorsque methodini=grid'
return
}
if paramini==1 .and. %defined(rc) .and. rc>1 .and. methodini== 3 {
display 'avec methodini=grid et rc>1 vous ne pouvez pas imposer paramini=partial'
return
}

* verification de noms si graphd=yes et initialisation si absent
if graphd==1 {
if .not.%defined(name) {
dimension nomsinds(%indiv(nobs))
do i=1,%indiv(nobs)
compute nomsinds(i)=%string(i)
end do i
}
else {
if %rows(name) != %indiv(nobs) {
display 'vous devez donner' %indiv(nobs) 'noms aux' %indiv(nobs) 'individus présents dans vos données'
return
}
else {
compute nomsinds=name
}
}
}

*******************************************************************
* mise en place des objets ne dépendant pas d'un modèle particulier
*******************************************************************
* repérage des observations non manquantes sur {depvar, explic, trans, iexoz} : si besoin smpl=smpl disponible
compute i=1
set smpl = %valid(depvar)
dofor series = explic
set smpl = smpl+%valid(series{0})
compute i=i+1
end dofor
dofor series = trans
set smpl = smpl+%valid(series{0})
compute i=i+1
end dofor
if exoz {
dofor series = iexoz
set smpl = smpl+%valid(series{0})
compute i=i+1
end dofor
}
set smpl = %if(smpl==i,1,0)

* centrage de depvar et des variables explic sur leurs moyennes individuelles
panel(entries=1.0,indiv=-1.0,smpl=smpl) depvar / depvarc
dimension explic_c(fix(%rows(explic)))
do j=1,fix(%rows(explic))
panel(entry=1.0,indiv=-1.0,smpl=smpl) explic(j) / explic_c(j)
end do j
* centrage si besoin des variables iexoz sur leurs moyennes individuelles
if exoz {
dimension iexoz_c(nbexoz)
do j=1,nbexoz
panel(entry=1.0,indiv=-1.0,smpl=smpl) iexoz(j) / iexoz_c(j)
end do j
}

* gestion de la grille des valeurs initiales pour gamma : soit entree en option, soit prise par defaut
if %defined(grilleg) {
if %minvalue(grilleg)<=0 {
display 'les valeurs des pentes des fonctions de transition doivent être positives'
return
}
compute nb_valini_gamma = %rows(grilleg)
dimension grille_gamma(nb_valini_gamma)
compute grille_gamma=grilleg
}
else {
if methodini==3 {
compute nb_valini_gamma = 10
dimension grille_gamma(10)
compute grille_gamma=||0.2|0.5|0.9|1.4|1.9|2.5|3.0|3.5|4.0|5.0||
}
else {
compute nb_valini_gamma = %rows(m)
dimension grille_gamma(nb_valini_gamma)
compute grille_gamma=%uniform(.2,3.5)
}
}
* initialisation de l'objectif (à la RSS de la régression sans transition)
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c
}
compute objectif = %rss, objectif_opt=%rss


***************************************************************
* Test de linéarité vs PSTR pour le premier modèle à considérer
* (pour les modèles d'ordre r >1, le test est réalisé à l'issue
* de l'estimation du modèle d'ordre r-1)
***************************************************************
if mlin>0 {
dofor series=trans
display 'Linéarité vs PSTR sur variable' +%l(series) +'sans autre variable de transition'
* construction des produits croisés (explicatives x puissances de la variable de
* transition) centrés
do ic=mlin,1,-1
compute i=0
dimension explic_l(fix(%rows(explic)*ic))
do j=ic,1,-1
do k=1,fix(%rows(explic))
compute i=i+1
set explic_l(i) = [series]explic(k)*[series]series**j
panel(entry=1.0,indiv=-1.0,smpl=smpl) explic_l(i)
end do k
end do j
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explic_l
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explic_l
}
* LM correspond à la formule donnée par Gonzales, Terasvirta et van Dick (2004) page 10.
* F correspond à la formule (2.49) de Amemiya (chap. 6, p 349, Handbook of Econometrics, vol. 1, 1983).
* (et à celle de LMF donnée par Gonzales, Terasvirta et van Dick (2004) page 10).
* LRT correspond à la formule (2.58) de Amemiya (chap. 6, p 351, Handbook of Econometrics, vol. 1, 1983)
display @5 'Tests pour mlin =' ic
compute stat=%nobs*(objectif-%rss)/objectif
display @8 'LM = ' +stat 'sous H0, Chi2(' +i +')' $
'SL=' %chisqr(stat,i)
compute stat=((objectif-%rss)/i)/(%rss/(%nobs-i-%indiv(nobs)))
display @8 'F = ' +stat $
'sous H0, F(' +i +',' +%nobs-i-%indiv(nobs) +')' $
'SL=' %ftest(stat,i,%nobs-i-%indiv(nobs))
compute stat=%nobs*(log(objectif)-log(%rss))
display @8 'pseudo LRT = ' +stat 'sous H0, Chi2(' +i +')' $
'SL=' %chisqr(stat,i)
end do ic
end dofor
}

***************************************
* Traitement successif des rmax modèles
***************************************
do r=rmin,rmax
display
display 'ESTIMATION DU MODELE A' r 'VARIABLE(s) DE TRANSITION :'
do i=1,r
display @5 %l(trans(i))
end do i
display
* nb de paramètres de restriction dans le modèle courant
compute nbparamc=0
do j=1,r
compute nbparamc=nbparamc+fix(m(j))
end do j

dimension gamma(r) c(fix(%maxvalue(m)),r) gamma_opt(r) explictransf(%rows(explic)*r)
dimension grillec(nbparamc,nbvalinic) trans_r(r)
dimension controle(nbparamc) cvec(nbparamc)

* construction de la liste des variables de transition dans le modèle courant
do j=1,r
compute trans_r(j)=trans(j)
end do j

*initialisation de gamma_opt pour le premier modèle
if r==1;compute gamma_opt=%const(0.0)
* construction de la grille des valeurs initiales pour c et du vecteur controle
@grillec trans_r grillec m trimc nbvalinic nbparamc controle smpl

* PREMIERE ETAPE
* recherche des valeurs initiales dans une grille sur gamma et c lorsque methodini=grid
* recherche des valeurs initiales dans une grille sur c lorsque methodini=genetic ou simplex
* la boucle externe en g est faite sur les valeurs posibles de gamma
display 'PREMIERE ETAPE : RECHERCHE DES VALEURS INITIALES DANS LES GRILLES'
compute nb_essai_c=fix(nbvalinic**nbparamc)
if methodini==3 {
if paramini==2 {
compute nb_essai_gamma=fix(nb_valini_gamma**r)
}
else {
compute nb_essai_gamma=fix(nb_valini_gamma)
compute nb_essai_c=fix(nbvalinic**m(r))
}
}
else {
compute nb_essai_gamma=1
}
compute nbreg=0

do g=1,nb_essai_gamma
* construction de gamma :
* - lorsque methodini=grid et paramini=all, ce vecteur contient successivement chacune des combinaisons possibles de r éléments
* pris dans les nb_valini_gamma valeurs possibles (combinaisons au nombre de nb_essai_gamma)
* - lorsque methodini=grid et paramini=partial, ce vecteur contient successivement chacune des combinaisons possibles de r éléments
* dont les r-1 premiers sont égaux aux solutions optimales précédentes ( à l'exception du cas r=1) et la dernière prise
* dans les nb_valini_gamma valeurs possibles (combinaisons au nombre de nb_essai_gamma)
* - lorsque methodini=genetic ou simplex, ce vecteur contient pour chaque fonction de transition la valeur correspondante
* prise dans grille_gamma
do j=1,r
if methodini==3 {
if paramini==2 .or. r==1 {
compute gamma(j)=grille_gamma((%clock(g,(nb_valini_gamma**(r-j+1)))-1)/(nb_valini_gamma**(r-j))+1)
}
else if paramini==1 .and. r>1 {
do i=1,r-1
compute gamma(i)=gamma_opt_preced(i)
end do i
compute gamma(r)=grille_gamma(g)
}
}
else {
compute gamma(j)=grille_gamma(j)
}
end do j
* boucle sur les valeurs de c (uniquement celles respectant la relation d'ordre grace a controle)
do ic=1,nb_essai_c
* construction d'un vecteur contenant les valeurs initiales pour c
if paramini==1 .and. methodini==3 .and. r>1 {
compute k=0
do i=1,r-1
do j=1,fix(m(i))
compute k=k+1
compute cvec(k)=copt_preced(j,i)
compute controle(k)=0
end do j
end do i
do j=k+1,nbparamc
compute cvec(j)=grillec(j,(%clock(ic,(nbvalinic**(nbparamc-j+1)))-1)/(nbvalinic**(nbparamc-j))+1)
if j==k+1 {
compute controle(j)=0
}
else {
compute controle(j)=1
}
end do j
}
else {
do j=1,nbparamc
compute cvec(j)=grillec(j,(%clock(ic,(nbvalinic**(nbparamc-j+1)))-1)/(nbvalinic**(nbparamc-j))+1)
end do j
}
* selection des seuls vecteurs a considerer etant donne l'ordonnancement des valeurs de transition
compute ok=1
do j=1,nbparamc
if controle(j)==1 .and. cvec(j)<=cvec(j-1) {
compute ok=0
break
}
end do j
if ok {
compute nbreg=nbreg+1
* construction de c après initialisation à zéro
compute c=%const(0.0)
compute i=0
do j=1,r
do k=1,fix(m(j))
compute i=i+1,c(k,j)=cvec(i)
end do k
end do j
* construction des valeurs des r fonctions de transition et des produits croises avec explic
@transition trans_r explic nobs r m c gamma explictransf smpl
* calcul de la rss de la regression lineaire et gestion des valeurs initiales optimales
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explictransf
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explictransf
}
if %rss<objectif_opt .or. (g==1 .and. ic==1) {
compute objectif_opt=%rss, gamma_opt=gamma,copt=c
}
}
end do ic
end do g
display 'selection des valeurs initiales optimales dans les grilles :'
display 'gamma='; write gamma_opt
display 'c='; write copt
display 'objectif initial associé =' objectif_opt
display 'nombre de régressions effectuées :' nbreg

* initialisations
nonlin gamma c gamma>=0.
compute gamma=gamma_opt
compute c=copt
compute objectif=objectif_opt


* fin de premiere etape si methodini=genetic ou simplex
if methodini==1 .or. methodini==2 {
find(method=methodini,piters=piters) min objectif
{
* construction des valeurs des r fonctions de transition et des produits croises avec explic
@transition trans_r explic nobs r m c gamma explictransf smpl
* estimation des beta
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explictransf
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explictransf
}
* calcul de objectif
compute objectif=%rss
}
end find
if %converged {
compute gamma_opt=gamma
compute copt=c
compute objectif_opt=objectif
}
else {
if methodini==1 {
display 'absence de convergence avec methodini=simplex'
}
if methodini==2 {
display 'absence de convergence avec methodini=genetic'
}
display 'appel de bfgs avec les valeurs issues des grilles'
compute gamma=gamma_opt
compute c=copt
compute objectif=objectif_opt
}
}


* SECONDE ETAPE
display
display 'SECONDE ETAPE : OPTIMISATION BFGS A PARTIR DES VALEURS INITIALES PRECEDENTES'

find(notrace,method=bfgs,stderrs) min objectif
{
* construction des valeurs des r fonctions de transition et des produits croises avec explic
@transition trans_r explic nobs r m c gamma explictransf smpl
* estimation des beta
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explictransf
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explictransf
}
* calcul de objectif
compute objectif=%rss
}
end find
display
if %converged {
* aide à la lecture des résultats sur c
if r>1 {
display 'Rappel :'
display 'C(i,j) = Iieme parametre de location dans la Jieme fonction de transition'
display 'Dans cette estimation ne presentent un interet que les coefficients suivants :'
do i=1,r
display 'fonction de transition num.' +i +', variable de transition' %l(trans(i)) +', pente de la fonction :' +gamma(i)
display @5 'parametres de transition associes :'
do j=1,fix(m(i))
display c(j,i)
end do j
end do i
}

* estimation des coefficients beta avec c et gamma terminaux
if exoz {
linreg(print,smpl=smpl) depvarc
#iexoz_c explic_c explictransf
}
else {
linreg(print,smpl=smpl) depvarc
#explic_c explictransf
}

* aide à la lecture des résultats sur beta
display 'Rappels : signification des intitulés des variables :'
display 'variable expliquée :' %l(depvar)
display 'variables explicatives :'
compute i=0
dofor series=explic
compute i=i+1
display @5 'EXPLIC_C('+i+') =' %l(series)
end dofor
compute i=0
dofor series=explic
do j=1,r
compute i=i+1
display @5 'EXPLICTRANSF('+i+') =' %l(series) 'x' 'fonction de transition num.'+j
end do j
end dofor
if exoz {
display 'variables iexoz_c :'
compute i=0
dofor series=iexoz
compute i=i+1
display @5 'IEXOZ_C('+i+') =' %l(series)
end dofor
}
* critère de sélection
display
display 'critères de sélection dans ce modèle à' (%nreg+r+nbparamc) 'paramètres'
display ' AIC =' log(%rss/%nobs)+(%nreg+r+nbparamc)*2.0/%nobs
display ' BIC =' log(%rss/%nobs)+(%nreg+r+nbparamc)*log(%nobs)/%nobs
display
* verification de la valeur des paramètres de transition
*@verifc trans_r c m trimc smpl

*calcul des dérivées sur chacune des explicatives
if graphd==1 {
dimension derive(fix(%rows(explic)))
clear derive ;*initialisation
compute beta = %beta
@derive trans_r nobs r m c gamma derive beta explic nbexoz nomsinds
}

* sauvegarde des résultats optimaux des paramètres des fonctions de transition
compute gamma_opt=gamma
compute copt=c
compute objectif_s=%rss

* test linéarité vs PSTR la r+1 ième variable de transition sachant PSTR sur les
* r variables de transition déjà prises en compte et pour lesquelles on prend comme
* valeurs des paramètres initiaux celles du modèle qui vient d'être ajusté.
if mlin>0 .and. r<fix(%rows(trans)) {
do ilin= r+1,fix(%rows(trans))
display
display 'Linéarité vs PSTR sur variable' +%l(trans(ilin)) +'sachant la présence de' $
+r +'fonction(s) de transition'
do ic=mlin,1,-1
* initialisation des paramètres des fonctions de transition à leurs valeurs optimales
compute gamma=gamma_opt
compute c=copt
* reconstruction des valeurs des r fonctions de transition et des produits croises avec explic
* necessaire pour faire les tests sans réestimation des paramètres de transition
* (explictransf sera modifié lors de la construction des tests avec réestimation)
@transition trans_r explic nobs r m c gamma explictransf smpl
* construction des produits croisés (explicatives x puissances de la variable de
* transition testée) centrés
compute i=0
dimension explic_l(fix(%rows(explic)*ic))
do j=ic,1,-1
do k=1,fix(%rows(explic))
compute i=i+1
set explic_l(i) = [series]explic(k)*[series]trans(ilin)**j
panel(entry=1.0,indiv=-1.0,smpl=smpl) [series]explic_l(i)
end do k
end do j

*** Tests sans réestimation des paramètres c et gamma
display @5 'Tests pour mlin =' ic 'sans ré-estimation des paramètres de la transition'
* estimation des beta
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explictransf explic_l
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explictransf explic_l
}
compute dl1=%nreg ;*utilisé dans la construction des tests de linéarité vs PSTR y compris avec réestimation des paramètres
* LM et LMF correspondent aux formules données par Gonzales, Terasvirta et van Dick (2004) page 10
display @8 'SSR =' %rss
display @8 'LM = ' +%nobs*(objectif_s-%rss)/objectif_s 'sous H0, Chi2(' +i +')' $
'SL=' %chisqr(%nobs*(objectif_s-%rss)/objectif_s,i)
display @8 'LMF = ' +((objectif_s-%rss)/i)/(%rss/(%nobs-dl1-%indiv(nobs))) $
'sous H0, F(' +i +',' +%nobs-dl1-%indiv(nobs) +')' $
'SL=' %ftest(((objectif_s-%rss)/i)/(%rss/(%nobs-dl1-%indiv(nobs))),i,%nobs-dl1-%indiv(nobs))

*** Tests avec réestimation des paramètres c et gamma

find(method=bfgs,notrace,stderrs,noprint) min objectif
{
* construction des valeurs des r fonctions de transition et des produits croises avec explic
* pour les variables de transitions incluses
@transition trans_r explic nobs r m c gamma explictransf smpl
* estimation des beta
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explictransf explic_l
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explictransf explic_l
}
compute objectif=%rss
}
end find
display @5 'Tests pour mlin =' ic 'avec ré-estimation des paramètres de la transition'
* F correspond à la formule (2.49) de Amemiya (chap. 6, p 349, Handbook of Econometrics, vol. 1, 1983)
* LRT correspond à la formule (2.58) de Amemiya (chap. 6, p 351, Handbook of Econometrics, vol. 1, 1983)
if %converged {
compute stat=%nobs*(log(objectif_s)-log(%rss))
display @8 'SSR =' %rss
display @8 'pseudo LRT = ' +stat 'sous H0, Chi2(' +i +')' $
'SL=' %chisqr(stat,i)
compute stat=((objectif_s-%rss)/i)/(%rss/(%nobs-dl1-%indiv(nobs)-nbparamc-r))
display @8 'F = ' +stat $
'sous H0, F(' +i +',' +%nobs-dl1-%indiv(nobs)-nbparamc-r +')' $
'SL=' %ftest(stat,i,%nobs-dl1-%indiv(nobs)-nbparamc-r)
}
else {
display 'absence de convergence, test non effectué'
}
* reinitialisation de objectif à la valeur du modèle optimal
compute objectif=objectif_s
end do ic
end do ilin
}
* test de constance des coefficients du modèle qui vient d'être ajusté.
* actuellement on ré-estime l'équation 14 (correspondant à 11 linéarisée)
if mh>0 {
display
display 'Constance des paramètres du modèle avec ré-estimation des paramètres de la transition'
do ic=mh,1,-1
* initialisation des paramètres des fonctions de transition à leurs valeurs optimales
compute gamma=gamma_opt
compute c=copt
compute objectif=objectif_s
* construction des produits croisés (explicatives x puissances de la variable (t/T) centrés et non centrés
compute i=0
dimension explic_lc(fix(%rows(explic)*(ic+1)))
dimension explic_l(fix(%rows(explic)*(ic+1)))
dimension explictransf(fix(%rows(explic)*(ic+1))*r)
do j=ic,0,-1 ;* arret de j à zéro ce qui met les variables explic dans explic_l
do k=1,fix(%rows(explic))
compute i=i+1
set explic_l(i) = [series]explic(k)*((1.*%period(t))/%period(nobs))**j
panel(entry=1.0,indiv=-1.0,smpl=smpl) explic_l(i) / explic_lc(i)
end do k
end do j
find(method=bfgs,notrace,stderrs,noprint) min objectif
{
* construction de la liste iexplic_l
enter(varying) iexplic_l
#explic_l
* construction des valeurs des r fonctions de transition et de leurs produits croises avec explic_l
@transition trans_r iexplic_l nobs r m c gamma explictransf smpl
* estimation des beta
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_lc explictransf
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_lc explictransf
}
compute objectif=%rss
}
end find
display @5 'Tests pour mh =' ic
if %converged {
* F correspond à la formule (2.49) de Amemiya (chap. 6, p 349, Handbook of Econometrics, vol. 1, 1983)
* LRT correspond à la formule (2.58) de Amemiya (chap. 6, p 351, Handbook of Econometrics, vol. 1, 1983)
compute stat=%nobs*(objectif_s-%rss)/objectif_s,dl1=ic*fix(%rows(explic)*(r+1))
display @8 'pseudo LRT = ' +stat 'sous H0, Chi2(' +dl1 +')' $
'SL=' %chisqr(stat,dl1)
compute stat=((objectif_s-%rss)/(ic*fix(%rows(explic)*(r+1))))/(%rss/(%nobs-ic*fix(%rows(explic)*(r+1)-%indiv(nobs))))
compute dl1=ic*fix(%rows(explic)*(r+1)),dl2=%nobs-ic*fix(%rows(explic)*(r+1)-%indiv(nobs))
display @8 'F = ' +stat 'sous H0, F(' +dl1 +',' +dl2 +')' $
'SL=' %ftest(stat,dl1,dl2)
}
else {
display 'absence de convergence, test non effectué'
}
end do ic
}

*réinitialisation de objectif
compute objectif=objectif_s
* redimensionnement de explictransf modifié par le test de constante des coefficients
dimension explictransf(%rows(explic)*r)
}
else {
display 'ABSENCE DE CONVERGENCE....SORTIE DE LA PROCEDURE'
break
}

compute gamma_opt_preced=gamma_opt,copt_preced=copt
end do r

end gtvd
pstr带法语注释和中文翻译的源代码:

Code: 全选

*********************************翻译结果****************************
* proc gtvd depvar
**--------** * proc gtvd depvar
* #x1 x2 ...
**--------** * # x1 x2-我...。
* #q1 q2 ...
**--------** * # Q1 Q2-我...。
* #z1 z2 ...
**--------** * # Z1 z2-我...。
*
**--------** *
* avec :
**--------** *,包括:
* depvar = nom de l'expliquée
**--------** * =说明的名称
* x1 x2 = liste des explicatives sur lesquelles portent la ou les transitions
**--------** * x1 x2 =过渡所涉及的说明列表
* q1 q2 = liste des variables de transition
**--------** * \ Q1 Q2 =转移变数清单
* z1 z2 = liste des explicatives non affectées par la ou les transitions. Liste présente si exoz=1
**--------** * \ Z1 z2 =不受转变影响的说明列表。如果exz = 1,则列出
*
**--------** *
* remarque :
**--------** * :注意:
* - Le nombre de variables de transition,r , définit le nombre de fonctions de transition.
**--------** * -转移变数的数目r定义转移特征的数目。
* Par exemple '#q1 q1' définit deux fonctions de transition ayant comme argument q1
**--------** *例如# Q1 Q1定义两个转换函数,其引数为Q1
* - Les données doivent être décrites par une instruction allocate/calendar de type données de panel
**--------** * -必须使用allocate / calendar仪表板数据语句描述数据
*
**--------** *
* Options :
**--------** *选项:
* m = Vecteur ayant r composantes spécifiant le nombre de restrictions pour chacune des fonctions de transitions.
**--------** * * m =包含指定每个转接特征限制数目的元件的向量。
* Par exemple m=||3,2|| spécifie deux fonctions de transitions, la première ayant 3 restrictions et la seconde
**--------** *例如,m = | | 3.2 | |指定两个转接函数,第一个具有3个限制,第二个具有限制
* en ayant 2. Dans ce cas, on doit avoir deux variables de transition dans l'appel de la procédure.
**--------** 有两个。在这种情况下,过程调用中必须有两个转换变量。
*
**--------** *
* grilleg = Vecteur spécifiant une grille de valeurs initiales potentielles positives pour les pentes
**--------** * / grid eg =为坡度指定正潜在初始值栅格的矢量
* des fonctions de transition. Cette grille est identique pour chacune des pentes.
**--------** *过渡功能。对于每个坡度,此栅格都相同。
* Par défaut grilleg=||.2|.5|.8|1.3|2.0|2.8|3.7|4.7|5.5|7.0|| (... sans justification particulière)
**--------** *默认情况下,grieg = | | 2 | . 5 | . 8 | 1.3 | 2.0 | 2.8 | 3.7 | 4.7 | 5.5 | 7.0 | |-我...。(无特殊理由)
*
**--------** *
* paramini = [partial]/ all
**--------** * [部分] /全部
* Indicatrice gerant la prise des valeurs initiales. Si paramini=all alors toutes les valeurs potentielles
**--------** *指示符将获取初始值。如果param ini = all,则所有可能的值
* sur c et gamma sont considérés. Si paramini=partial, les valeurs de gamma et de c du modele ayant
**--------** *考虑c和gamma。如果param ini = partial,则模型的gamma和c值具有
* r fonctions de transition sont pour les (r-1) premières egalisees aux valeurs optimales obtenues avec
**--------** *对于第一个( r - 1 )转换函数,转换函数与通过以下方法获得的最佳值相匹配
* l'estimation du modele a (r-1) fonctions de transition, et seules les valeurs des parametres de la derniere
**--------** *模型a ( r - 1 )过渡函数的估计值,只包括最后一个过渡函数的参数值
* fonction sont recherchees dans les grilles. Ce paramètre est actif uniquement si methodini=grid et
**--------** *在网格中搜索函数。仅当method Odin = grid和时,此参数才处于活动状态
* si rc n'est pas defini ou est au plus egal à 1.
**--------** *如果RC未定义或不等于1。
*
**--------** *
* nbvalinic = Nombre de valeurs initiales potentielles pour chacun des paramètres de restriction.
**--------** * * nbvalnic =每个限制参数的可能初始值数。
* Ce nombre est commun mais naturellement les valeurs sont prises dans les variables
**--------** *此数字是常见的,但值自然是在变量中获取的
* de transition propre à chacun. Les valeurs correspondant à trimc et (1-trimc) sont
**--------** 每个人的过渡。trimc和( 1 - trimc )的值如下
* obligatoirement prises; en conséquence nbvalinic doit être >=2. [10]
**--------** *必须采取的行动;因此,nbvalnic必须大于或等于2。[ 10 ]
*
**--------** *
* trimc = % d'observations utilisées pour le trimming sur les variables de transition [15%].
**--------** * \ trimc = %用于修剪过渡变量的观测值[ 15 % ]。
* Par exemple la valeur par défaut prend des valeurs initiales pour le paramètre
**--------** *例如,缺省值为参数的初始值
* de restriction depuis le fractile à 15% inclus jusqu'au fractile à 85% inclus de la
**--------** *从包括15 %的分数到包括85 %的分数的限制
* variable de transition correspondante (et dans cet espace la procédure prend nbvalininc-2
**--------** *相应的转换变量(此处的过程采用nbvalini nicc - 2 )
* autres valeurs également réparties).
**--------** *其他同样分布的值)。
*
**--------** *
* exoz = Indicatrice de la présence de variables explicatives du type z1 z2. Si exoz=1, leurs noms sont lus
**--------** * : exz =表示存在Z1 z2类型的说明变量。如果exz = 1,则会读取它们的名称
* sur la troisième carte supplémentaire. Si exoz=0 cette troisième liste est absente de l'appel de la
**--------** *在第三张附加卡上。如果exz = 0,则调用中缺少第三个列表
* procédure. [0]
**--------** *程序。[ 0 ]
*
**--------** *
* mlin = Puissance maximale à considérer sur la variable de transition dans les tests : linéarité vs PSTR
**--------** * * mlin =测试中过渡变量考虑的最大功率:线性与pstn
* (eq.4 p. 3 de GTvD). Le développement de Taylor considéré porte sur la dernière variable de
**--------** * ( gtvd第4页,第3段)。泰勒的发展涉及的最后一个变量是
* transition du modèle ajusté. Au premier tour il s'agit de la première de la liste q1 q2 ...).
**--------** *调整后的模型过渡。第一轮是Q1 Q2清单中的第一轮-我...。页: 1。
* Si mlin=0 (valeur par défaut), ce test n'est pas réalisé. [0]
**--------** *如果mlin = 0 (默认值),则不执行此测试。[ 0 ]
*
**--------** *
* mh = Puissance maximale à considérer dans les tests de constance des coefficients (eqs 13 et 14 p. 7 de GTvD)
**--------** * MH =系数常数测试中要考虑的最大功率( gtvd e13和14p . 7 )
* Si mh=0 (valeur par défaut), ce test n'est pas réalisé. [0]
**--------** *如果MH = 0 (默认值),则不执行此测试。[ 0 ]
*
**--------** *
* piters = Nombre d'itérations réalisées avec la méthode du simplex si difficulté de convergence avec les
**--------** * piters =使用simple方法进行的迭代次数
* valeurs initiales prises dans les grilles. [6]
**--------** *网格中的初始值。[ 6 ]
*
**--------** *
* rc = nombre de fonctions de transitions que doit incorporer le seul modèle estimé.
**--------** * / RC =需要纳入唯一估计模型的转接特征数目。
* Si rc est non défini dans l'appel la procédure met en oeuvre un traitement séquentiel. Par exemple
**--------** *如果未在调用中定义RC,则该过程将执行顺序处理。比如说
* #q1 q2 demande l'estimation d'un modèle avec q1 comme variable de transition puis d'un modèle avec
**--------** * # Q1 Q2要求先估算一个以Q1为转移变数的模型,然后估算一个以Q1为转移变数的模型
* q1 et q2 comme variables de transition. Dans ce cas le nombre de variables de transition doit être
**--------** * Q1和Q2为转移变数。在这种情况下,转移变数的数目必须是
* égal au nombre de valeurs spécifiées dans le vecteur m.
**--------** *等于在向量m中指定的值数目。
* Si rc est défini alors seul le modèle avec rc variables de transition est ajusté et m doit spécifier
**--------** *如果定义RC,则仅调整具有RC变化变量的模型,并且m必须指定
* au moins rc valeurs. Si le nombre de variables de transition est supérieur à rc, les tests de linéarité
**--------** *至少RC值。如果变化变量的数目大于RC,则线性测试
* versus PSTR sont réalisés avec ce seul modèle ajusté et successivement pour chacune des variables de
**--------** * /与pstn相比,只能针对每个变量使用此调整模型并按顺序执行
* transition en excès (ceci uniquement si mlin>0). Si rc est défini alors il doit être >0.
**--------** *过渡(仅当mlin大于0时)。如果设置了RC,则必须大于0。
*
**--------** *
* methodini = simplex / [genetic] / grid.
**--------** * *方法学=单纯形/ [遗传] /网格。
* Spécifie le mode de calcul des valeurs initiales sur les pentes et les parametres de restriction des
**--------** *指定如何计算坡度和限制参数的初始值
* fonctions de transition. Les valeurs initiales des pentes avec les deux premières options sont prises
**--------** *过渡功能。将采用带有前两个选项的初始坡度值
* au hasard où spécifiées lors de l'appel de la procédure, avec une seule valeur par fonction de transition.
**--------** *在调用过程中随机指定,每个转换函数只有一个值。
* Les paramètres de restriction sont déterminés par une grille qui peut normalement avoir moins de valeurs
**--------** *约束参数由栅格确定,栅格通常具有较少的值
* (ce nombre étant donné par nbvalinic) que lorsque l'on emploie une recherche complète dans les grilles, ce
**--------** * (此数字由nbvalnic计算)仅在使用全面网格搜索时
* dernier cas correspondant à l'option GRID. Dans tous les cas, une fois les valeurs initiales obtenues par
**--------** *「网格」选项的最后一个案例。在所有情况下,一旦获得初始值
* l'une de ces trois méthodes la procédure utilise une maximisation bfgs pour la recherche des valeurs
**--------** * :这三种方法中的一种使用bfgs最大化来查找值
* finales des estimateurs des pentes et des paramètres de restriction.
**--------** *坡度估计值和限制参数的终点。
*
**--------** *
* graphd = yes / [no]
**--------** * graph =是/ [否]
* Si graphd=yes la procédure calcule et graphe les dérivées par rapport à chacune des explicatives affectées par
**--------** *如果graph = yes,则此过程将根据受影响的每个解释计算和绘制派生项
* la ou les transitions. Actuellement, les formules utilisées supposent qu'aucune de ces explicatives n'est
**--------** *过渡。目前使用的公式假定这些解释都不是
* présente dans la ou les variables de transition. On affiche d'une part les résultats afférents à chaque individu
**--------** *存在于转移变数中。一方面显示每个人的结果
* en tout point des temps et d'autre part les moyennes sur le temps pour chaque individu. Les graphes concernent
**--------** *任何时候,另一方面,每个人的平均时间。这些图表包括
* l'évolution dans le temps des dérivées estimées, un graphe est réalisé pour chaque individu.
**--------** *随着时间的推移,每个人都会绘制一个图表。
*
**--------** *
* name = Vecteur de string dont chaque composante est le nom des individus et qui est utilisé pour donner un titre
**--------** * name =字串向量,其中每个元件都是个人的名称,用于提供标题
* aux divers graphiques. L'ordre des noms devant correspondre à celui des entrées du fichier de données. La
**--------** *到各种图表。名称的顺序必须与数据文件中条目的顺序相匹配。在那里
* dimension de ce vecteur doit être égale au nombre d'individus étudiés. En son absence, les individus sont
**--------** *此向量的大小应等于研究的人数。如果没有此向量,则个人为
* repérés par leur ordre (1, 2, 3, ...).
**--------** *按顺序排列( 1、2、3、-我...。页: 1。
*
**--------** *
* Remarques :
**--------** *注意:
* - Il est obligatoire de préciser l'option m= .
**--------** * -必须指定m =。
*
**--------** *
* - En cas d'observations manquantes, les estimations sont réalisées (y compris les centrages pour éliminations
**--------** *如果缺少观测数据,则进行估算(包括处置中心)
* des effets fixes individuels) sur les observations non manquantes pour la totalité des variables expliquée,
**--------** *单个的固定效应)对所解释的所有变量没有缺失的观测值,
* explicatives de type x ou z), et de transitions spécifiées dans l'appel de la procédure. En conséquence un
**--------** * x或z类型的说明,以及过程调用中指定的转换。因此一个
* appel avec par exemple #q1 q2, supprimera notamment les observations pour lesquelles q2 n'est pas renseignée
**--------** *,例如# Q1 Q2调用,除其他外,将删除Q2未提供信息的注释
* et ceci même dans la première étape d'estimation, cad dans le modèle ou seule q1 est utilisée comme variable de
**--------** *即使在第一个估算阶段,模型中的CAD或仅Q1被用作变量
* transition.
**--------** *过渡。
*
**--------** *

*********************************************************************************************


************************************************
* définition de la fonction logistique
**--------** *后勤职能的定义
* améliore la précision des calculs pour x>>>>0
**--------** *提高x > > > > 0的计算精度

************************************************
function logistic x
type real logistic x
if x<=0{
compute logistic=1./(1.+exp(x))
}
else {
compute logistic=exp(-x)/(1.+exp(-x))
}
end function


*-------------------------------------------------------------
* calcul des élasticité ...... ATTENTION :
**--------** *弹性计算...我...。请注意:
* - explicatives non inclues dans les variables de threshold
**--------** * -未包含在阈值变量中的说明

*-------------------------------------------------------------
proc derive trans_r nobs r m c gamma derive beta explic nbexoz nomsinds

type integer nobs r nbexoz
type vector[integer] trans_r explic
type vector gamma m beta
type vector[string] nomsinds
type rectangular c
type vector[series] *derive ;* derive = séries des dérivées pour chaque explicatives
**--------** derive =每个说明的派生系列
local integer i j series obs nexplic nlignes
local real git qit
local vector[series] transf ;* transf = valeurs des r fonctions de transition
**--------** transf =过渡特征r值
local vector[series] derive_means
local vector[string] noms_explic
local series rien

compute nexplic=fix(%rows(explic))

dimension transf(r) derive_means(nexplic) noms_explic(nexplic+1)
compute noms_explic(1)='individu'
do i=1,nexplic
compute noms_explic(i+1)=%l(explic(i))
end do i

* construction des r fonctions de transition
**--------** *建设过渡职能
do i=1,r
clear transf(i)
end do i
compute i=0
dofor series=trans_r
compute i=i+1
do obs=1,nobs
compute git=1.0
compute qit=%seriesentry(series,obs)
if %valid(qit) {
do j=1,fix(m(i))
compute git=git*(qit-c(j,i))
**--------** ( qit - c ( j,I ) )
end do j
compute transf(i)(obs)=logistic(-gamma(i)*git)
**--------** ( git )
}
else {
compute transf(i)(obs)=%na
}
end do obs
end dofor

* calcul de la derivée
**--------** *导数计算
do j=1,nexplic
set derive(j) = beta(nbexoz+j)
do i=1,r
set derive(j) = derive(j) + beta(nbexoz+nexplic+r*(j-1)+i)*transf(i)
**--------** 传输( I )
end do i
panel(indiv=1.0,compress) derive(j) / derive_means(j)
end do j
print(windows='derive,r='+%string(r)) / derive

*graphiques
**--------** *图形
compute nlignes=%indiv(nobs)/3
if %indiv(nobs)/3.0 - %indiv(nobs)/3 .ne. 0.;compute nlignes=nlignes+1
do j=1,nexplic
extremum(noprint) derive(j)
spgraph(vfields=nlignes,hfields=3,windows=noms_explic(j+1)+',r='+%string(r))
do i=1,%indiv(nobs)
sample(smpl=(%indiv(t)==i)) derive(j) / rien 1
graph(max=%maximum,min=%minimum,header=nomsinds(i)) 1
#rien 1 %period(nobs)
end do i
spgraphs(done)
end do j

display '--------------------'
display 'élasticités moyennes'
display '--------------------'
report(action=define,hlabels=noms_explic)
do i=1,%indiv(nobs)
report(row=new,atcol=1) nomsinds(i)
do j=1,nexplic
report(row=current,atcol=j+1,align=decimal) derive_means(j)(i)
end do j
end do i
report(action=show)
end derive


*--------------------------------------------------------------------------------------------
* construction des produits croisés variables explicatives x fonctions de transition centrées
**--------** *构建说明性可变交叉产出x以过渡为中心的职能

*--------------------------------------------------------------------------------------------
proc transition trans_r explic nobs r m c gamma explictransf smpl

type integer nobs r
type vector[integer] trans_r explic
type vector gamma m
type rectangular c
type series smpl
type vector[series] *explictransf ;* explictransf = séries contenant les produits croisés explic*transf
**--------** 传输中
local integer i j series obs
local real git qit
local vector[series] transf ;* transf = valeurs des r fonctions de transition
**--------** transf =过渡特征r值

dimension transf(r)
do i=1,r
clear transf(i)
end do i


* construction des valeurs des r fonctions de transition
**--------** *构建过渡函数的r值
compute i=0
dofor series=trans_r
compute i=i+1
do obs=1,nobs
compute git=1.0
compute qit=%seriesentry(series,obs)
if %valid(qit) {
do j=1,fix(m(i))
compute git=git*(qit-c(j,i))
**--------** ( qit - c ( j,I ) )
end do j
compute transf(i)(obs)=logistic(-gamma(i)*git)
**--------** ( git )
}
else {
compute transf(i)(obs)=%na
}
end do obs
end dofor


* construction des produits croisés explic*transf et centrage sur les moyennes individuelles
**--------** *构建交叉产品explice * transf和侧重于个体平均值
compute i=0
dofor series=explic
do j=1,r
compute i=i+1
set explictransf(i) = transf(j)*series{0}
**--------** 系列{ 0 }
panel(entries=1.0,indiv=-1.0,smpl=smpl) explictransf(i)
end do j
end dofor
end transition



*--------------------------------------------------------------------------------------------
* construction de la grille sur c et du vecteur controle
**--------** * c轴网和控制向量的构造

*--------------------------------------------------------------------------------------------
proc grillec trans_r grillec m trimc nbvalinic nbparamc controle smpl

type vector[integer] trans_r
type integer nbvalinic nbparamc
type real trimc
type vector m *controle
**--------** 控制系统
type rectangular *grillec
**--------** 烤好了
type series smpl
local integer i j k nb_param_c series
local real minc maxc
local rectangular rien

compute i=0,nb_param_c=0
dofor series=trans_r
compute i=i+1
make(smpl=smpl) rien
#series{0}
compute minc=%fractiles(rien,trimc)(1), maxc=%fractiles(rien,1.-trimc)(1)
do k=1,fix(m(i))
compute nb_param_c=nb_param_c+1
do j=1,nbvalinic
compute grillec(nb_param_c,j)=minc+(j-1)*(maxc-minc)/(nbvalinic-1)
**--------** ( maxc - minc ) / ( nbvalnic - 1 )
end do j
if k>1 {
compute controle(nb_param_c)=1
}
end do k
end dofor
disp 'valeurs initiales sur c'
write grillec
end grillec


*-----------------------------------------------------------------------------------------------
* verification de l'appartenance des paramètres de restriction à l'espace défini par le trimming
**--------** *验证修剪所定义的空间限制参数的成员资格

*-----------------------------------------------------------------------------------------------
proc verifc trans_r c m trimc smpl

type vector[integer] trans_r
type rectangular c
type real trimc
type vector m
type series smpl
local integer series i
local real minc maxc
local rectangular rien

compute i=0
dofor series=trans_r
compute i=i+1
make(smpl=smpl) rien
#series{0}
compute minc=%fractiles(rien,trimc)(1), maxc=%fractiles(rien,1.-trimc)(1)
do k=1,fix(m(i))
if c(k,i)<minc .or. c(k,i)>maxc {
display 'Attention : le paramètre estimé' +c(k,i) 'dans la fonction de transition numéro' +i
display @15 'est extérieur au domaine défini par le trimming (' +minc +',' +maxc +') pour' +%l(series)
}
end do k
end dofor
end verifc





*--------------------------------------------------------------------------------------------
* programme principal
**--------** *主要方案

*--------------------------------------------------------------------------------------------
proc gtvd depvar


*********************************************
* entrée des informations de base et controle
**--------** *基本信息输入和控制

*********************************************
type series depvar
local integer rmax rmin r i j k ic ok obs nobs series mi g ilin methodini paramini graphd
local integer nb_valini_gamma nb_essai_gamma nbparamc nb_essai_c dl1 dl2 nbexoz nbreg
local real qit git objectif objectif_opt objectif_s stat
local vector grille_gamma
local vector cvec controle ;* cvec : vecteur constitue des nbparamc parametres c pris dans la grille grillec
**--------** cvec : vector是取自grid EC的nbparam c参数
;* controle : verifie que cvec correspond a un cas devant etre considere
**--------** 控制:验证cvec是否为需要考虑的案例
local vector beta ;* beta contient les estimateurs OLS des coefficients obtenus à la fin de la seconde étape (utilisé par proc derive)
**--------** beta包含在第二阶段结束时获得的系数ols估计值( proc derive使用)
local vector gamma gamma_opt gamma_opt_preced ;* gamma = pentes des r fonctions de transition (rx1)
**--------** gamma =过渡特征r斜率( rx 1 )
local rectangular grillec ;* grillec = grille des valeurs pour les restrictions c
**--------** grid EC =约束c的值网格
local rectangular c copt copt_preced ;* c = valeur des restrictions (m_max x r)
**--------** c =约束值( m _ max x r )
local vect[integer] explic ;* explic = liste des variables explicatives sur lesquelles portent la ou les transition(s)
**--------** explicic =转移所涉及的说明变量的列表
local vect[integer] trans ;* trans = liste des variables de transition
**--------** trans =转移变数清单
local vect[integer] iexoz ;* iexoz = liste des explicatives sur lesquelles ne portent pas la ou les transition(s)
**--------** iexoz =不包含过渡的说明列表
local vect[integer] trans_r ;* trans_r = liste des variables de transition dans le modèle courant
**--------** trans _ r =目前模型中转接变数的清单
local series smpl depvarc ;* smpl = repère les observations non manquantes, utilisé dans instruction panel pour que
**--------** smpl =标记非缺少的注释,用于panel语句,以便
;* le centrage ne porte que sur les observations complétement renseignées de chaque
**--------** 重点仅放在对每一项建议进行充分知情的评论上
;* individu en cas d'échantillon non cylindré
**--------** 非圆柱形试样情况下的个体
;* depvarc = depvar centrée sur moyennes individuelles
**--------** depvarc =以单个平均值为中心的depvar
local vector[series] derive ;* derive = valeur des dérivées relativement aux explicatives
**--------** derive =与说明相关的派生值
local vector[series] explictransf ;* explictransf = séries contenant les produits croisés explic*transf
**--------** 传输中
local vector[series] explic_c ;* explic_c = series explic centrées sur leurs moyennes individuelles
**--------** explicic _ c =以个别平均值为中心的explicic系列
local vector[series] explic_l ;* explic_l = series utilisées dans le test linéarité vs PSTR et de constance des coef.
**--------** explicic _ l =用于线性vs pstn测试和Coe一致性测试中的系列。
local vector[integer] iexplic_l ;*iexplic_l = liste correspondant aux séries explic_l utilisée dans l'appel de proc transition
**--------** iexplic _ l = proc transition调用中使用的explicic _ l系列的列表
local vector[series] explic_lc ;* explic_lc = series utilisées dans le test de constance des coefficients
**--------** explicic _ LC =系数常数测试中使用的系列
local vector[series] iexoz_c ;* iexoz_c = séries non soumises à transitions centrées sur leurs moyennes individuelles
**--------** iez _ c =不以个别平均值为中心的非变化序列
local vector[string] nomsinds ;* reprend les éventuels noms passés par name
**--------** 恢复任何通过name传递的名称
option vector m
option vector grilleg
option integer piters 6
option integer nbvalinic 10
option real trimc .15
option integer mlin 0
option integer mh 0
option integer exoz 0
option integer rc
option choice methodini 3 simplex genetic grid
option choice paramini 1 partial all
option choice graphd 2 yes no
option vector[string] name

enter(varying) explic
enter(varying) trans
if exoz {
enter(varying) iexoz
compute nbexoz = fix(%rows(iexoz))
}
else {
compute nbexoz=0
}
* calcul du nombre total d'observations
**--------** *意见总数的计算
set depvarc = 1
stat(noprint) depvarc
compute nobs=%nobs

* liste des modèles à ajuster
**--------** *有待调整的模板清单
if %defined(rc) {
if rc==0 {
display 'vous devez avoir rc>0. Ici vous demandez à ajuster un modèle sans transition'
return
}
compute rmin=rmax=rc
}
else {
compute rmax = fix(%rows(trans)),rmin=1
}

* verification de la definition de m
**--------** *核查m的定义
if %defined(m)==0 {
display 'vous devez definir les nombres de restrictions identificatrices pour chacune des fonctions de transition'
display 'avec une option : m=||m(1)|m(2)|....|m(r)|| ou r est le nombre de fonctions de transition'
return
}
if fix(%rows(m))!=rmax .and. (.not.%defined(rc)) {
display 'vous devez avoir autant de variables de transition que de composantes du vecteur m'
return
}
if fix(%rows(m))<rmax .and. %defined(rc) {
display 'vous devez avoir au moins' rc 'composantes dans le vecteur m'
return
}

* verification de le definition de grilleg lorsque genetic ou simplex est employe
**--------** *在使用遗传或单纯形时验证格列格的定义
if %defined(grilleg) .and. (methodini==1 .or. methodini==2) .and. %rows(grilleg)!=%rows(m) {
display 'avec methodeini = genetic ou methodini = simplex vous devez avoir autant de valeurs initiales pour gamma'
display 'que de fonctions de transition'
return
}
if nbvalinic<2 .and. methodini==3 {
display 'vous devez imposer un nombre de valeurs initiales pour les paramètres de transitions >= 2 lorsque methodini=grid'
return
}
if paramini==1 .and. %defined(rc) .and. rc>1 .and. methodini== 3 {
display 'avec methodini=grid et rc>1 vous ne pouvez pas imposer paramini=partial'
return
}

* verification de noms si graphd=yes et initialisation si absent
**--------** *如果graph = yes,则验证名称;如果不存在,则初始化
if graphd==1 {
if .not.%defined(name) {
dimension nomsinds(%indiv(nobs))
do i=1,%indiv(nobs)
compute nomsinds(i)=%string(i)
end do i
}
else {
if %rows(name) != %indiv(nobs) {
display 'vous devez donner' %indiv(nobs) 'noms aux' %indiv(nobs) 'individus présents dans vos données'
return
}
else {
compute nomsinds=name
}
}
}


*******************************************************************
* mise en place des objets ne dépendant pas d'un modèle particulier
**--------** *建立不依赖特定模型的对象

*******************************************************************
* repérage des observations non manquantes sur {depvar, explic, trans, iexoz} : si besoin smpl=smpl disponible
**--------** *寻找{ depvar,explicic,trans,iexoz }上的未遗漏观测值:如果需要smpl = smpl
compute i=1
set smpl = %valid(depvar)
dofor series = explic
set smpl = smpl+%valid(series{0})
compute i=i+1
end dofor
dofor series = trans
set smpl = smpl+%valid(series{0})
compute i=i+1
end dofor
if exoz {
dofor series = iexoz
set smpl = smpl+%valid(series{0})
compute i=i+1
end dofor
}
set smpl = %if(smpl==i,1,0)

* centrage de depvar et des variables explic sur leurs moyennes individuelles
**--------** * depvar和explica变量的重点是它们各自的平均值
panel(entries=1.0,indiv=-1.0,smpl=smpl) depvar / depvarc
dimension explic_c(fix(%rows(explic)))
do j=1,fix(%rows(explic))
panel(entry=1.0,indiv=-1.0,smpl=smpl) explic(j) / explic_c(j)
end do j
* centrage si besoin des variables iexoz sur leurs moyennes individuelles
**--------** *必要时将iexoz变量集中于其个别平均值
if exoz {
dimension iexoz_c(nbexoz)
do j=1,nbexoz
panel(entry=1.0,indiv=-1.0,smpl=smpl) iexoz(j) / iexoz_c(j)
end do j
}

* gestion de la grille des valeurs initiales pour gamma : soit entree en option, soit prise par defaut
**--------** * gamma初始值网格管理:可选或默认
if %defined(grilleg) {
if %minvalue(grilleg)<=0 {
display 'les valeurs des pentes des fonctions de transition doivent être positives'
return
}
compute nb_valini_gamma = %rows(grilleg)
dimension grille_gamma(nb_valini_gamma)
compute grille_gamma=grilleg
}
else {
if methodini==3 {
compute nb_valini_gamma = 10
dimension grille_gamma(10)
compute grille_gamma=||0.2|0.5|0.9|1.4|1.9|2.5|3.0|3.5|4.0|5.0||
}
else {
compute nb_valini_gamma = %rows(m)
dimension grille_gamma(nb_valini_gamma)
compute grille_gamma=%uniform(.2,3.5)
}
}
* initialisation de l'objectif (à la RSS de la régression sans transition)
**--------** *目标初始化(在没有过渡的回归RSS )
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c
}
compute objectif = %rss, objectif_opt=%rss



***************************************************************
* Test de linéarité vs PSTR pour le premier modèle à considérer
**--------** *要考虑的第一个型号的线性测试与pstn测试
* (pour les modèles d'ordre r >1, le test est réalisé à l'issue
**--------** * (对于r > 1订单模型,测试将在以下结果中进行
* de l'estimation du modèle d'ordre r-1)
**--------** *来自r - 1订单模型估计数)

***************************************************************
if mlin>0 {
dofor series=trans
display 'Linéarité vs PSTR sur variable' +%l(series) +'sans autre variable de transition'
* construction des produits croisés (explicatives x puissances de la variable de
**--------** 交叉乘积构造(解释性x变量的幂
* transition) centrés
**--------** (过渡)中心
do ic=mlin,1,-1
compute i=0
dimension explic_l(fix(%rows(explic)*ic))
**--------** ( c )
do j=ic,1,-1
do k=1,fix(%rows(explic))
compute i=i+1
set explic_l(i) = [series]explic(k)*[series]series**j
**--------** j .你好
panel(entry=1.0,indiv=-1.0,smpl=smpl) explic_l(i)
end do k
end do j
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explic_l
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explic_l
}
* LM correspond à la formule donnée par Gonzales, Terasvirta et van Dick (2004) page 10.
**--------** lm是Gonzales、tera sverta和van dick ( 2004年)第10页给出的公式。
* F correspond à la formule (2.49) de Amemiya (chap. 6, p 349, Handbook of Econometrics, vol. 1, 1983).
**--------** f系amemiya公式(第2.49章)。同上,第6卷,第349页,《计量经济学手册》,第1卷,1983年)。
* (et à celle de LMF donnée par Gonzales, Terasvirta et van Dick (2004) page 10).
**--------** (以及Gonzales、tera sverta和van dick提供的lmf ( 2004年)第10页)。
* LRT correspond à la formule (2.58) de Amemiya (chap. 6, p 351, Handbook of Econometrics, vol. 1, 1983)
**--------** lrt是amemiya (第二章)的公式( 2.58 )。6,第351页,《计量经济学手册》,第1卷,1983年)
display @5 'Tests pour mlin =' ic
compute stat=%nobs*(objectif-%rss)/objectif
**--------** (目标- % RSS ) /目标
display @8 'LM = ' +stat 'sous H0, Chi2(' +i +')' $
'SL=' %chisqr(stat,i)
compute stat=((objectif-%rss)/i)/(%rss/(%nobs-i-%indiv(nobs)))
display @8 'F = ' +stat $
'sous H0, F(' +i +',' +%nobs-i-%indiv(nobs) +')' $
'SL=' %ftest(stat,i,%nobs-i-%indiv(nobs))
compute stat=%nobs*(log(objectif)-log(%rss))
**--------** (日志目标) -日志( % RSS )
display @8 'pseudo LRT = ' +stat 'sous H0, Chi2(' +i +')' $
'SL=' %chisqr(stat,i)
end do ic
end dofor
}


***************************************
* Traitement successif des rmax modèles
**--------** *对rmx型号的后续处理

***************************************
do r=rmin,rmax
display
display 'ESTIMATION DU MODELE A' r 'VARIABLE(s) DE TRANSITION :'
do i=1,r
display @5 %l(trans(i))
end do i
display
* nb de paramètres de restriction dans le modèle courant
**--------** 当前模型中限制参数的数量
compute nbparamc=0
do j=1,r
compute nbparamc=nbparamc+fix(m(j))
end do j

dimension gamma(r) c(fix(%maxvalue(m)),r) gamma_opt(r) explictransf(%rows(explic)*r)
**--------** ( r )
dimension grillec(nbparamc,nbvalinic) trans_r(r)
dimension controle(nbparamc) cvec(nbparamc)

* construction de la liste des variables de transition dans le modèle courant
**--------** 建构目前模型中的变化变数清单
do j=1,r
compute trans_r(j)=trans(j)
end do j

*initialisation de gamma_opt pour le premier modèle
**--------** 初始化第一个模型的gamma _ opt
if r==1;compute gamma_opt=%const(0.0)
* construction de la grille des valeurs initiales pour c et du vecteur controle
**--------** c和控制向量初始值格线的建构
@grillec trans_r grillec m trimc nbvalinic nbparamc controle smpl

* PREMIERE ETAPE
**--------** 第一步
* recherche des valeurs initiales dans une grille sur gamma et c lorsque methodini=grid
**--------** 当method Odin = grid时,在gamma和c网格中查找初始值
* recherche des valeurs initiales dans une grille sur c lorsque methodini=genetic ou simplex
**--------** 当method Odin = genetic或simple时,在c网格中查找初始值
* la boucle externe en g est faite sur les valeurs posibles de gamma
**--------** g的外循环是在gamma的可能值上完成的
display 'PREMIERE ETAPE : RECHERCHE DES VALEURS INITIALES DANS LES GRILLES'
compute nb_essai_c=fix(nbvalinic**nbparamc)
**--------** nbparamc )
if methodini==3 {
if paramini==2 {
compute nb_essai_gamma=fix(nb_valini_gamma**r)
**--------** ( r )
}
else {
compute nb_essai_gamma=fix(nb_valini_gamma)
compute nb_essai_c=fix(nbvalinic**m(r))
**--------** m ( r )
}
}
else {
compute nb_essai_gamma=1
}
compute nbreg=0

do g=1,nb_essai_gamma
* construction de gamma :
**--------** gamma构造:
* - lorsque methodini=grid et paramini=all, ce vecteur contient successivement chacune des combinaisons possibles de r éléments
**--------** -当method Odin = grid和param ini = all时,此向量依次包含r元素的每个可能组合
* pris dans les nb_valini_gamma valeurs possibles (combinaisons au nombre de nb_essai_gamma)
**--------** 取值范围为nb _ valini _ gamma ( nb _ test _ gamma的组合)
* - lorsque methodini=grid et paramini=partial, ce vecteur contient successivement chacune des combinaisons possibles de r éléments
**--------** -当method Odin = grid和param ini = partial时,此向量依次包含r元素的每个可能组合
* dont les r-1 premiers sont égaux aux solutions optimales précédentes ( à l'exception du cas r=1) et la dernière prise
**--------** 其前r - 1与前一个最佳解决方案( r = 1除外)和最后一个插座相同
* dans les nb_valini_gamma valeurs possibles (combinaisons au nombre de nb_essai_gamma)
**--------** 在nb _ valini _ gamma中可能的值( nb _ test _ gamma的组合)
* - lorsque methodini=genetic ou simplex, ce vecteur contient pour chaque fonction de transition la valeur correspondante
**--------** -当method Odin = genetic或simple时,此向量包含每个转接函数的对应值
* prise dans grille_gamma
**--------** 灰度系数_ gamma
do j=1,r
if methodini==3 {
if paramini==2 .or. r==1 {
compute gamma(j)=grille_gamma((%clock(g,(nb_valini_gamma**(r-j+1)))-1)/(nb_valini_gamma**(r-j))+1)
**--------** ( r - j ) ) + 1
}
else if paramini==1 .and. r>1 {
do i=1,r-1
compute gamma(i)=gamma_opt_preced(i)
end do i
compute gamma(r)=grille_gamma(g)
}
}
else {
compute gamma(j)=grille_gamma(j)
}
end do j
* boucle sur les valeurs de c (uniquement celles respectant la relation d'ordre grace a controle)
**--------** c值上的回圈(仅符合grace a控制顺序关系的回圈)
do ic=1,nb_essai_c
* construction d'un vecteur contenant les valeurs initiales pour c
**--------** 建构包含c初始值的向量
if paramini==1 .and. methodini==3 .and. r>1 {
compute k=0
do i=1,r-1
do j=1,fix(m(i))
compute k=k+1
compute cvec(k)=copt_preced(j,i)
compute controle(k)=0
end do j
end do i
do j=k+1,nbparamc
compute cvec(j)=grillec(j,(%clock(ic,(nbvalinic**(nbparamc-j+1)))-1)/(nbvalinic**(nbparamc-j))+1)
**--------** ( nbparam - j ) ) + 1 )
if j==k+1 {
compute controle(j)=0
}
else {
compute controle(j)=1
}
end do j
}
else {
do j=1,nbparamc
compute cvec(j)=grillec(j,(%clock(ic,(nbvalinic**(nbparamc-j+1)))-1)/(nbvalinic**(nbparamc-j))+1)
**--------** ( nbparam - j ) ) + 1 )
end do j
}
* selection des seuls vecteurs a considerer etant donne l'ordonnancement des valeurs de transition
**--------** 仅选取a向量,因为转换值是按顺序排列的
compute ok=1
do j=1,nbparamc
if controle(j)==1 .and. cvec(j)<=cvec(j-1) {
compute ok=0
break
}
end do j
if ok {
compute nbreg=nbreg+1
* construction de c après initialisation à zéro
**--------** c初始化后的构造
compute c=%const(0.0)
compute i=0
do j=1,r
do k=1,fix(m(j))
compute i=i+1,c(k,j)=cvec(i)
end do k
end do j
* construction des valeurs des r fonctions de transition et des produits croises avec explic
**--------** 使用explica构建转换函数和交叉产品的r值
@transition trans_r explic nobs r m c gamma explictransf smpl
* calcul de la rss de la regression lineaire et gestion des valeurs initiales optimales
**--------** 线性回归RSS计算及最佳初始值管理
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explictransf
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explictransf
}
if %rss<objectif_opt .or. (g==1 .and. ic==1) {
compute objectif_opt=%rss, gamma_opt=gamma,copt=c
}
}
end do ic
end do g
display 'selection des valeurs initiales optimales dans les grilles :'
display 'gamma='; write gamma_opt
display 'c='; write copt
display 'objectif initial associé =' objectif_opt
display 'nombre de régressions effectuées :' nbreg

* initialisations
**--------** 初始化中
nonlin gamma c gamma>=0.
compute gamma=gamma_opt
compute c=copt
compute objectif=objectif_opt


* fin de premiere etape si methodini=genetic ou simplex
**--------** 如果method Odin = genetic或simplex,则第一步结束
if methodini==1 .or. methodini==2 {
find(method=methodini,piters=piters) min objectif
{
* construction des valeurs des r fonctions de transition et des produits croises avec explic
**--------** 使用explica构建转换函数和交叉产品的r值
@transition trans_r explic nobs r m c gamma explictransf smpl
* estimation des beta
**--------** beta估计值
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explictransf
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explictransf
}
* calcul de objectif
**--------** 目标计算
compute objectif=%rss
}
end find
if %converged {
compute gamma_opt=gamma
compute copt=c
compute objectif_opt=objectif
}
else {
if methodini==1 {
display 'absence de convergence avec methodini=simplex'
}
if methodini==2 {
display 'absence de convergence avec methodini=genetic'
}
display 'appel de bfgs avec les valeurs issues des grilles'
compute gamma=gamma_opt
compute c=copt
compute objectif=objectif_opt
}
}


* SECONDE ETAPE
**--------** 第二阶段
display
display 'SECONDE ETAPE : OPTIMISATION BFGS A PARTIR DES VALEURS INITIALES PRECEDENTES'

find(notrace,method=bfgs,stderrs) min objectif
{
* construction des valeurs des r fonctions de transition et des produits croises avec explic
**--------** 使用explica构建转换函数和交叉产品的r值
@transition trans_r explic nobs r m c gamma explictransf smpl
* estimation des beta
**--------** beta估计值
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explictransf
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explictransf
}
* calcul de objectif
**--------** 目标计算
compute objectif=%rss
}
end find
display
if %converged {
* aide à la lecture des résultats sur c
**--------** 帮助阅读c上的结果
if r>1 {
display 'Rappel :'
display 'C(i,j) = Iieme parametre de location dans la Jieme fonction de transition'
display 'Dans cette estimation ne presentent un interet que les coefficients suivants :'
do i=1,r
display 'fonction de transition num.' +i +', variable de transition' %l(trans(i)) +', pente de la fonction :' +gamma(i)
display @5 'parametres de transition associes :'
do j=1,fix(m(i))
display c(j,i)
end do j
end do i
}

* estimation des coefficients beta avec c et gamma terminaux
**--------** 最终带和γ的β系数估计
if exoz {
linreg(print,smpl=smpl) depvarc
#iexoz_c explic_c explictransf
}
else {
linreg(print,smpl=smpl) depvarc
#explic_c explictransf
}

* aide à la lecture des résultats sur beta
**--------** beta测试结果阅读帮助
display 'Rappels : signification des intitulés des variables :'
display 'variable expliquée :' %l(depvar)
display 'variables explicatives :'
compute i=0
dofor series=explic
compute i=i+1
display @5 'EXPLIC_C('+i+') =' %l(series)
end dofor
compute i=0
dofor series=explic
do j=1,r
compute i=i+1
display @5 'EXPLICTRANSF('+i+') =' %l(series) 'x' 'fonction de transition num.'+j
end do j
end dofor
if exoz {
display 'variables iexoz_c :'
compute i=0
dofor series=iexoz
compute i=i+1
display @5 'IEXOZ_C('+i+') =' %l(series)
end dofor
}
* critère de sélection
**--------** 选择标准
display
display 'critères de sélection dans ce modèle à' (%nreg+r+nbparamc) 'paramètres'
display ' AIC =' log(%rss/%nobs)+(%nreg+r+nbparamc)*2.0/%nobs
**--------** 2.0 / % nobs
display ' BIC =' log(%rss/%nobs)+(%nreg+r+nbparamc)*log(%nobs)/%nobs
**--------** 日志( % nobs ) / % nobs
display
* verification de la valeur des paramètres de transition
**--------** 验证过渡参数的值
*@verifc trans_r c m trimc smpl
**--------** @检查trans _ r c m trimc smpl

*calcul des dérivées sur chacune des explicatives
**--------** 计算每个解释的派生项
if graphd==1 {
dimension derive(fix(%rows(explic)))
clear derive ;*initialisation
**--------** 初始化中
compute beta = %beta
@derive trans_r nobs r m c gamma derive beta explic nbexoz nomsinds
}

* sauvegarde des résultats optimaux des paramètres des fonctions de transition
**--------** 备份转接特征设定的最佳结果
compute gamma_opt=gamma
compute copt=c
compute objectif_s=%rss

* test linéarité vs PSTR la r+1 ième variable de transition sachant PSTR sur les
**--------** 线性测试vs pstn r + 1了解pstn的第一过渡变量
* r variables de transition déjà prises en compte et pour lesquelles on prend comme
**--------** r已考虑并被视为
* valeurs des paramètres initiaux celles du modèle qui vient d'être ajusté.
**--------** 初始参数值与新调整的模型的参数值。
if mlin>0 .and. r<fix(%rows(trans)) {
do ilin= r+1,fix(%rows(trans))
display
display 'Linéarité vs PSTR sur variable' +%l(trans(ilin)) +'sachant la présence de' $
+r +'fonction(s) de transition'
do ic=mlin,1,-1
* initialisation des paramètres des fonctions de transition à leurs valeurs optimales
**--------** 将转接特征参数初始化为其最佳值
compute gamma=gamma_opt
compute c=copt
* reconstruction des valeurs des r fonctions de transition et des produits croises avec explic
**--------** 使用explica重建转换函数和交叉产品的r值
* necessaire pour faire les tests sans réestimation des paramètres de transition
**--------** 在不重新评估过渡参数的情况下进行测试所必需的
* (explictransf sera modifié lors de la construction des tests avec réestimation)
**--------** ( explain transf将在重新评估后的测试构建过程中更改)
@transition trans_r explic nobs r m c gamma explictransf smpl
* construction des produits croisés (explicatives x puissances de la variable de
**--------** 交叉乘积构造(解释性x变量的幂
* transition testée) centrés
**--------** 经测试的过渡)重点
compute i=0
dimension explic_l(fix(%rows(explic)*ic))
**--------** ( c )通过
do j=ic,1,-1
do k=1,fix(%rows(explic))
compute i=i+1
set explic_l(i) = [series]explic(k)*[series]trans(ilin)**j
**--------** j .你好
panel(entry=1.0,indiv=-1.0,smpl=smpl) [series]explic_l(i)
end do k
end do j

*** Tests sans réestimation des paramètres c et gamma
**--------** 无需重新评估c和gamma参数即可进行测试
display @5 'Tests pour mlin =' ic 'sans ré-estimation des paramètres de la transition'
* estimation des beta
**--------** beta估计值
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explictransf explic_l
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explictransf explic_l
}
compute dl1=%nreg ;*utilisé dans la construction des tests de linéarité vs PSTR y compris avec réestimation des paramètres
**--------** 用于构造vs pstn的线性测试,包括参数重新评估
* LM et LMF correspondent aux formules données par Gonzales, Terasvirta et van Dick (2004) page 10
**--------** lm和lmf是Gonzales、tera sverta和van dick ( 2004年)第10页给出的公式
display @8 'SSR =' %rss
display @8 'LM = ' +%nobs*(objectif_s-%rss)/objectif_s 'sous H0, Chi2(' +i +')' $
'SL=' %chisqr(%nobs*(objectif_s-%rss)/objectif_s,i)
**--------** (目标_ s - % RSS ) /目标_ s,I )
display @8 'LMF = ' +((objectif_s-%rss)/i)/(%rss/(%nobs-dl1-%indiv(nobs))) $
'sous H0, F(' +i +',' +%nobs-dl1-%indiv(nobs) +')' $
'SL=' %ftest(((objectif_s-%rss)/i)/(%rss/(%nobs-dl1-%indiv(nobs))),i,%nobs-dl1-%indiv(nobs))

*** Tests avec réestimation des paramètres c et gamma
**--------** 重新评估c和gamma参数的测试

find(method=bfgs,notrace,stderrs,noprint) min objectif
{
* construction des valeurs des r fonctions de transition et des produits croises avec explic
**--------** 使用explica构建转换函数和交叉产品的r值
* pour les variables de transitions incluses
**--------** 对于包括的转变变量
@transition trans_r explic nobs r m c gamma explictransf smpl
* estimation des beta
**--------** beta估计值
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_c explictransf explic_l
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_c explictransf explic_l
}
compute objectif=%rss
}
end find
display @5 'Tests pour mlin =' ic 'avec ré-estimation des paramètres de la transition'
* F correspond à la formule (2.49) de Amemiya (chap. 6, p 349, Handbook of Econometrics, vol. 1, 1983)
**--------** f系amemiya公式(第2.49章)。第6卷,第349页,《计量经济学手册》,第1卷,1983年)
* LRT correspond à la formule (2.58) de Amemiya (chap. 6, p 351, Handbook of Econometrics, vol. 1, 1983)
**--------** lrt是amemiya (第二章)的公式( 2.58 )。6,第351页,《计量经济学手册》,第1卷,1983年)
if %converged {
compute stat=%nobs*(log(objectif_s)-log(%rss))
**--------** ( log ( target _ s ) -日志( % RSS ) )
display @8 'SSR =' %rss
display @8 'pseudo LRT = ' +stat 'sous H0, Chi2(' +i +')' $
'SL=' %chisqr(stat,i)
compute stat=((objectif_s-%rss)/i)/(%rss/(%nobs-dl1-%indiv(nobs)-nbparamc-r))
display @8 'F = ' +stat $
'sous H0, F(' +i +',' +%nobs-dl1-%indiv(nobs)-nbparamc-r +')' $
'SL=' %ftest(stat,i,%nobs-dl1-%indiv(nobs)-nbparamc-r)
}
else {
display 'absence de convergence, test non effectué'
}
* reinitialisation de objectif à la valeur du modèle optimal
**--------** 将目标重置为最佳模型值
compute objectif=objectif_s
end do ic
end do ilin
}
* test de constance des coefficients du modèle qui vient d'être ajusté.
**--------** 刚调整的模型系数的常数测试。
* actuellement on ré-estime l'équation 14 (correspondant à 11 linéarisée)
**--------** 目前正在重新计算-估计方程式14 (相当于11个线性)
if mh>0 {
display
display 'Constance des paramètres du modèle avec ré-estimation des paramètres de la transition'
do ic=mh,1,-1
* initialisation des paramètres des fonctions de transition à leurs valeurs optimales
**--------** 将转接特征参数初始化为其最佳值
compute gamma=gamma_opt
compute c=copt
compute objectif=objectif_s
* construction des produits croisés (explicatives x puissances de la variable (t/T) centrés et non centrés
**--------** 交叉乘积构造(解释性x变量幂( t / t )居中和非居中
compute i=0
dimension explic_lc(fix(%rows(explic)*(ic+1)))
**--------** ( IC + 1 ) )
dimension explic_l(fix(%rows(explic)*(ic+1)))
**--------** ( IC + 1 ) )
dimension explictransf(fix(%rows(explic)*(ic+1))*r)
**--------** ( r )
do j=ic,0,-1 ;* arret de j à zéro ce qui met les variables explic dans explic_l
**--------** 将explicic _ l中的explicic变量设置为零的j停止
do k=1,fix(%rows(explic))
compute i=i+1
set explic_l(i) = [series]explic(k)*((1.*%period(t))/%period(nobs))**j
**--------** j .你好
panel(entry=1.0,indiv=-1.0,smpl=smpl) explic_l(i) / explic_lc(i)
end do k
end do j
find(method=bfgs,notrace,stderrs,noprint) min objectif
{
* construction de la liste iexplic_l
**--------** 构建iexplic _ l列表
enter(varying) iexplic_l
#explic_l
* construction des valeurs des r fonctions de transition et de leurs produits croises avec explic_l
**--------** 使用explicic _ l构建过渡特征及其交叉产品的r值
@transition trans_r iexplic_l nobs r m c gamma explictransf smpl
* estimation des beta
**--------** beta估计值
if exoz {
linreg(noprint,smpl=smpl) depvarc
#iexoz_c explic_lc explictransf
}
else {
linreg(noprint,smpl=smpl) depvarc
#explic_lc explictransf
}
compute objectif=%rss
}
end find
display @5 'Tests pour mh =' ic
if %converged {
* F correspond à la formule (2.49) de Amemiya (chap. 6, p 349, Handbook of Econometrics, vol. 1, 1983)
**--------** f系amemiya公式(第2.49章)。第6卷,第349页,《计量经济学手册》,第1卷,1983年)
* LRT correspond à la formule (2.58) de Amemiya (chap. 6, p 351, Handbook of Econometrics, vol. 1, 1983)
**--------** lrt是amemiya (第二章)的公式( 2.58 )。6 .第351页,《计量经济学手册》,第1卷,1983年)
compute stat=%nobs*(objectif_s-%rss)/objectif_s,dl1=ic*fix(%rows(explic)*(r+1))
**--------** ( r + 1 )
display @8 'pseudo LRT = ' +stat 'sous H0, Chi2(' +dl1 +')' $
'SL=' %chisqr(stat,dl1)
compute stat=((objectif_s-%rss)/(ic*fix(%rows(explic)*(r+1))))/(%rss/(%nobs-ic*fix(%rows(explic)*(r+1)-%indiv(nobs))))
**--------** ( r + 1 ) - (印地安人百分比( nobs ) ) )
compute dl1=ic*fix(%rows(explic)*(r+1)),dl2=%nobs-ic*fix(%rows(explic)*(r+1)-%indiv(nobs))
**--------** ( r + 1 ) - (印地安人百分比)
display @8 'F = ' +stat 'sous H0, F(' +dl1 +',' +dl2 +')' $
'SL=' %ftest(stat,dl1,dl2)
}
else {
display 'absence de convergence, test non effectué'
}
end do ic
}

*réinitialisation de objectif
**--------** 重设目标
compute objectif=objectif_s
* redimensionnement de explictransf modifié par le test de constante des coefficients
**--------** 系数常数测试修改的explict的大小
dimension explictransf(%rows(explic)*r)
**--------** ( r )
}
else {
display 'ABSENCE DE CONVERGENCE....SORTIE DE LA PROCEDURE'
break
}

compute gamma_opt_preced=gamma_opt,copt_preced=copt
end do r

end gtvd

Link:
Hide post links
Show post links


回复