精华内容
下载资源
问答
  • 上一个版本,本工具支持的第一个逆向策略,(对汇编的函数体内的分支控制结构逆向生成cpp代码,)一直都可以正常工作,直到遇上了一个函数。这个使我的逆向策略算法失效的函数,主要的特点是它含有众多无条件跳转...

    上一个版本,本工具支持的第一个逆向策略,(对反汇编的函数体内的分支控制结构逆向生成cpp代码,)一直都可以正常工作,直到遇上了一个函数。这个使我的逆向策略算法失效的函数,主要的特点是它含有众多无条件跳转指令(,都是在函数体内的跳转)。

    为什么无条件跳转指令会使得我的第一个逆向算法失效,因为这些无条件跳转指令让函数的执行流变得不易于线性理解。

    在一个没有反汇编出来的函数汇编代码中,如果无条件跳转指令很少,特殊地连一条无条件跳转指令也没有时,将汇编代码的执行流当作行文阅读,总可以找到一个特例让所有条件跳转满足一种情况,使得行文可以从头到尾。中间的条件跳转就像,你愿意不愿意对跳转的区域行文阅读,但总的来说,情节还是单线顺序发展的。

    但是反汇编出来的函数汇编代码中,包含了很多无条件跳转指令,代码的行文就会变得支离破碎。或者说有很多插叙或倒叙,你的行文阅读(某条主线或支线,执行流)并不要知道某些插叙或倒叙,这时就会有无条件跳转。你不得不去不停地翻书的页(,在函数汇编代码中跳来跳去)。插叙和倒叙,叙述了并行发展的情节(,不是并行执行的那个并行),而且不同的情节之间还会有关联(相交点),每个情节抽离出来都是一个故事支线。要完整呈现这个支线故事就不得不从其他支线故事中引用相关(双线交叉)的情节,就像内联一样。所有的顺叙,插叙或倒叙中的某段情节都将可能会内联到某一个支线故事当中去。

    所以对于这种包含了很多无条件跳转指令的函数,我想到的是函数体使用了内联,还可能是宏的方式。比如定义了三个代码片段的宏ABCBC都使用了A。一个函数内多次是使用了这三个宏的话,编译器可能会将A抽出来,将A内联到的地方都无条件跳转到A的代码片段,A代码片段结束处又无条件跳转到另一处。因此我也使用同样的策略来处理这种逆向情况,将汇编代码进行内联。

     

    下面这个包含多个jmp指令的函数CA::Layer::collect_animations__的反汇编代码:

     

    QuartzCore`CA::Layer::collect_animations__:
         <+0>:    pushq  %rbp
         <+1>:    movq   %rsp, %rbp
         <+4>:    pushq  %r15
         <+6>:    pushq  %r14
         <+8>:    pushq  %r13
         <+10>:   pushq  %r12
         <+12>:   pushq  %rbx
         <+13>:   subq   $0x48, %rsp
         <+17>:   movq   %rsi, %rbx
         <+20>:   movapd %xmm0, %xmm1
         <+24>:   movss  0x8(%rdx), %xmm0
         <+29>:   andps  0x3d8de(%rip), %xmm0      ; .memset_pattern + 560
         <+36>:   orps   0x3d8e7(%rip), %xmm0      ; .memset_pattern + 576
         <+43>:   cvtss2sd %xmm0, %xmm0
         <+47>:   movsd  %xmm0, -0x48(%rbp)
         <+52>:   movq   0x98(%rdi), %rax
         <+59>:   movq   %rax, -0x30(%rbp)
         <+63>:   testq  %rax, %rax
         <+66>:   je     0x1041b20bf               ; <+145>
         <+68>:   leaq   0x4(%rdi), %rsi
         <+72>:   leaq   -0x30(%rbp), %rcx
         <+76>:   movq   %rcx, -0x40(%rbp)
         <+80>:   xorl   %r12d, %r12d
         <+83>:   testl  $0x1800000, 0x4(%rdi)
         <+90>:   je     0x1041b20c6               ; <+152>
         <+92>:   movq   %rbx, -0x60(%rbp)
         <+96>:   lock   
         <+97>:   andl   $0xfe7fffff, (%rsi)
         <+103>:  movq   -0x30(%rbp), %rax
         <+107>:  xorl   %ecx, %ecx
         <+109>:  testq  %rax, %rax
         <+112>:  je     0x1041b235a               ; <+812>
         <+118>:  movq   %rsi, -0x68(%rbp)
         <+122>:  movq   %rdx, %r14
         <+125>:  xorl   %ecx, %ecx
         <+127>:  movq   %rcx, -0x50(%rbp)
         <+131>:  movsd  %xmm1, -0x38(%rbp)
         <+136>:  movq   %rdi, -0x70(%rbp)
         <+140>:  xorl   %r12d, %r12d
         <+143>:  jmp    0x1041b20e0               ; <+178>
         <+145>:  xorl   %eax, %eax
         <+147>:  jmp    0x1041b24b8               ; <+1162>
         <+152>:  movq   %rsi, -0x68(%rbp)
         <+156>:  movq   %rdx, %r14
         <+159>:  xorl   %ecx, %ecx
         <+161>:  movq   %rcx, -0x50(%rbp)
         <+165>:  movsd  %xmm1, -0x38(%rbp)
         <+170>:  movq   %rdi, -0x70(%rbp)
         <+174>:  movq   %rbx, -0x60(%rbp)
         <+178>:  xorl   %ecx, %ecx
         <+180>:  movq   %rcx, -0x58(%rbp)
         <+184>:  movq   %rax, %rbx
         <+187>:  testb  $0x2, 0x38(%rbx)
         <+191>:  je     0x1041b22ee               ; <+704>
         <+197>:  movq   0x20(%rbx), %rdi
         <+201>:  testq  %rdi, %rdi
         <+204>:  je     0x1041b22ee               ; <+704>
         <+210>:  movq   0x20(%rdi), %r15
         <+214>:  callq  0x104101b12               ; CA::Render::Timing::end_time() const
         <+219>:  movq   0x20(%rbx), %rax
         <+223>:  movl   0x8(%rax), %r13d
         <+227>:  shrl   $0x12, %r13d
         <+231>:  andb   $0x1, %r13b
         <+235>:  movl   0x8(%rax), %ecx
         <+238>:  shrl   $0x11, %ecx
         <+241>:  andb   $0x1, %cl
         <+244>:  movss  0x8(%r14), %xmm1
         <+250>:  xorpd  %xmm2, %xmm2
         <+254>:  ucomiss %xmm1, %xmm2
         <+257>:  je     0x1041b21ef               ; <+449>
         <+263>:  movd   %xmm0, %rax
         <+268>:  ucomiss %xmm2, %xmm1
         <+271>:  jae    0x1041b2146               ; <+280>
         <+273>:  movq   %rax, %rdx
         <+276>:  movb   %cl, %al
         <+278>:  jmp    0x1041b2152               ; <+292>
         <+280>:  movq   %r15, %rdx
         <+283>:  movq   %rax, %r15
         <+286>:  movb   %r13b, %al
         <+289>:  movb   %cl, %r13b
         <+292>:  movd   %rdx, %xmm0
         <+297>:  ucomiss %xmm2, %xmm1
         <+300>:  jbe    0x1041b217b               ; <+333>
         <+302>:  movsd  -0x38(%rbp), %xmm1
         <+307>:  ucomisd %xmm1, %xmm0
         <+311>:  ja     0x1041b220b               ; <+477>
         <+317>:  movd   %r15, %xmm0
         <+322>:  ucomisd %xmm1, %xmm0
         <+326>:  jbe    0x1041b2199               ; <+363>
         <+328>:  jmp    0x1041b221d               ; <+495>
         <+333>:  movsd  -0x38(%rbp), %xmm1
         <+338>:  ucomisd %xmm1, %xmm0
         <+342>:  jb     0x1041b220b               ; <+477>
         <+348>:  movd   %r15, %xmm0
         <+353>:  ucomisd %xmm1, %xmm0
         <+357>:  jb     0x1041b221d               ; <+495>
         <+363>:  movsd  %xmm1, -0x38(%rbp)
         <+368>:  movq   0x8(%rbx), %rdi
         <+372>:  movl   $0x2, %esi
         <+377>:  movl   $0xffffffff, %edx
         <+382>:  callq  0x1041914ba               ; CAAnimationSetFlags
         <+387>:  movq   %rbx, %rdi
         <+390>:  callq  0x1041b159c               ; schedule_stop_callback(CA::Layer::Animation*)
         <+395>:  testb  $0x1, 0x38(%rbx)
         <+399>:  je     0x1041b224c               ; <+542>
         <+405>:  movq   (%rbx), %rax
         <+408>:  movq   -0x40(%rbp), %rcx
         <+412>:  movq   %rax, (%rcx)
         <+415>:  movq   0x6d574(%rip), %rax       ; animation_state (.2)
         <+422>:  movq   %rax, (%rbx)
         <+425>:  movq   %rbx, 0x6d56a(%rip)       ; animation_state (.2)
         <+432>:  movq   (%rcx), %rbx
         <+435>:  testq  %rbx, %rbx
         <+438>:  jne    0x1041b20e9               ; <+187>
         <+444>:  jmp    0x1041b2310               ; <+738>
         <+449>:  movd   %r15, %xmm1
         <+454>:  movsd  -0x38(%rbp), %xmm2
         <+459>:  ucomisd %xmm2, %xmm1
         <+463>:  movapd %xmm2, %xmm1
         <+467>:  jbe    0x1041b2256               ; <+552>
         <+469>:  movb   %r13b, %al
         <+472>:  jmp    0x1041b22b4               ; <+646>
         <+477>:  movzwl 0x38(%rbx), %ecx
         <+481>:  testw  $0x220, %cx
         <+486>:  je     0x1041b2262               ; <+564>
         <+488>:  movsd  %xmm1, -0x38(%rbp)
         <+493>:  jmp    0x1041b2284               ; <+598>
         <+495>:  movsd  %xmm0, -0x40(%rbp)
         <+500>:  movsd  %xmm1, -0x38(%rbp)
         <+505>:  movq   %rbx, %rdi
         <+508>:  callq  0x1041b24d0               ; schedule_start_callback(CA::Layer::Animation*)
         <+513>:  testb  $0x4, 0x39(%rbx)
         <+517>:  jne    0x1041b2243               ; <+533>
         <+519>:  movb   $0x1, %al
         <+521>:  cmpq   $0x0, 0x30(%rbx)
         <+526>:  movsd  -0x48(%rbp), %xmm0
         <+531>:  je     0x1041b2284               ; <+598>
         <+533>:  movb   $0x1, %al
         <+535>:  movsd  -0x40(%rbp), %xmm0
         <+540>:  jmp    0x1041b2284               ; <+598>
         <+542>:  movb   %r13b, %al
         <+545>:  movsd  -0x48(%rbp), %xmm0
         <+550>:  jmp    0x1041b2284               ; <+598>
         <+552>:  movb   $0x1, %al
         <+554>:  ucomisd %xmm1, %xmm0
         <+558>:  ja     0x1041b22b4               ; <+646>
         <+560>:  movb   %cl, %al
         <+562>:  jmp    0x1041b22b4               ; <+646>
         <+564>:  testb  $0x4, %ch
         <+567>:  jne    0x1041b226e               ; <+576>
         <+569>:  cmpq   $0x0, 0x30(%rbx)
         <+574>:  je     0x1041b227a               ; <+588>
         <+576>:  movsd  %xmm1, -0x38(%rbp)
         <+581>:  movd   %r15, %xmm0
         <+586>:  jmp    0x1041b2284               ; <+598>
         <+588>:  movsd  %xmm1, -0x38(%rbp)
         <+593>:  movsd  -0x48(%rbp), %xmm0
         <+598>:  xorpd  %xmm1, %xmm1
         <+602>:  ucomiss 0x8(%r14), %xmm1
         <+607>:  jae    0x1041b2299               ; <+619>
         <+609>:  ucomisd -0x48(%rbp), %xmm0
         <+614>:  setb   %cl
         <+617>:  jmp    0x1041b22a1               ; <+627>
         <+619>:  ucomisd -0x48(%rbp), %xmm0
         <+624>:  seta   %cl
         <+627>:  movsd  -0x38(%rbp), %xmm1
         <+632>:  testb  %cl, %cl
         <+634>:  jne    0x1041b22af               ; <+641>
         <+636>:  movsd  -0x48(%rbp), %xmm0
         <+641>:  movsd  %xmm0, -0x48(%rbp)
         <+646>:  testb  %al, %al
         <+648>:  je     0x1041b22e9               ; <+699>
         <+650>:  movzwl 0x38(%rbx), %eax
         <+654>:  movl   %eax, %ecx
         <+656>:  andl   $0x20, %ecx
         <+659>:  testw  %cx, %cx
         <+662>:  je     0x1041b22e9               ; <+699>
         <+664>:  movl   %eax, %ecx
         <+666>:  andl   $0x80, %ecx
         <+672>:  testw  %cx, %cx
         <+675>:  je     0x1041b22d9               ; <+683>
         <+677>:  movb   $0x1, %cl
         <+679>:  movq   %rcx, -0x50(%rbp)
         <+683>:  andl   $0x100, %eax
         <+688>:  testw  %ax, %ax
         <+691>:  je     0x1041b22e9               ; <+699>
         <+693>:  movb   $0x1, %al
         <+695>:  movq   %rax, -0x58(%rbp)
         <+699>:  movsd  %xmm1, -0x38(%rbp)
         <+704>:  leaq   0x10(%rbx), %rdi
         <+708>:  xorl   %esi, %esi
         <+710>:  callq  0x1040e0598               ; CA::Render::key_path_atom(void* const*, unsigned long)
         <+715>:  cmpl   $0x63, %eax
         <+718>:  cmoveq %rbx, %r12
         <+722>:  movq   (%rbx), %rax
         <+725>:  testq  %rax, %rax
         <+728>:  movq   %rbx, -0x40(%rbp)
         <+732>:  jne    0x1041b20e6               ; <+184>
         <+738>:  movq   -0x68(%rbp), %rsi
         <+742>:  movl   (%rsi), %ebx
         <+744>:  movq   -0x50(%rbp), %rax
         <+748>:  testb  $0x1, %al
         <+750>:  movl   $0x0, %ecx
         <+755>:  je     0x1041b232f               ; <+769>
         <+757>:  lock   
         <+758>:  orl    $0x1000000, (%rsi)
         <+764>:  movl   $0x1000, %ecx
         <+769>:  movl   %ebx, %eax
         <+771>:  andl   $0x3000, %eax
         <+776>:  movq   -0x58(%rbp), %rdx
         <+780>:  testb  $0x1, %dl
         <+783>:  je     0x1041b234c               ; <+798>
         <+785>:  orl    $0x2000, %ecx
         <+791>:  lock   
         <+792>:  orl    $0x800000, (%rsi)
         <+798>:  movq   -0x70(%rbp), %rdi
         <+802>:  movsd  -0x38(%rbp), %xmm1
         <+807>:  movq   %r14, %rdx
         <+810>:  jmp    0x1041b2366               ; <+824>
         <+812>:  movl   (%rsi), %ebx
         <+814>:  movl   %ebx, %eax
         <+816>:  andl   $0x3000, %eax
         <+821>:  xorl   %r12d, %r12d
         <+824>:  cmpl   %eax, %ecx
         <+826>:  jne    0x1041b238f               ; <+865>
         <+828>:  testl  %eax, %eax
         <+830>:  je     0x1041b24a9               ; <+1147>
         <+836>:  xorpd  %xmm0, %xmm0
         <+840>:  ucomiss 0x8(%rdx), %xmm0
         <+844>:  jne    0x1041b2386               ; <+856>
         <+846>:  cmpl   $0x0, 0xc(%rdx)
         <+850>:  je     0x1041b24a9               ; <+1147>
         <+856>:  movq   %r12, %r13
         <+859>:  movq   0x10(%rdi), %r14
         <+863>:  jmp    0x1041b23b2               ; <+900>
         <+865>:  movq   %r12, %r13
         <+868>:  movq   0x10(%rdi), %r14
         <+872>:  movl   %ebx, %eax
         <+874>:  orl    $0xffffcfff, %eax
         <+879>:  xorl   $0x3000, %eax
         <+884>:  movq   %rcx, %rdx
         <+887>:  andl   %eax, %ecx
         <+889>:  lock   
         <+890>:  orl    %ecx, (%rsi)
         <+892>:  movq   %rdx, %rcx
         <+895>:  orl    %ecx, %eax
         <+897>:  lock   
         <+898>:  andl   %eax, (%rsi)
         <+900>:  movq   %rdi, %r15
         <+903>:  testl  %ecx, %ecx
         <+905>:  je     0x1041b245c               ; <+1070>
         <+911>:  movq   %rcx, %r12
         <+914>:  movsd  %xmm1, -0x38(%rbp)
         <+919>:  movq   0x68964(%rip), %rsi       ; "_scheduleAnimationTimer"
         <+926>:  movq   %r14, %rdi
         <+929>:  callq  *0x6de63(%rip)            ; (void *)0x000000010357d800: objc_msgSend
         <+935>:  testb  %al, %al
         <+937>:  movq   -0x60(%rbp), %rbx
         <+941>:  movq   %r15, %rdi
         <+944>:  je     0x1041b24ad               ; <+1151>
         <+950>:  movq   %r12, %rax
         <+953>:  testb  $0x10, %ah
         <+956>:  je     0x1041b2408               ; <+986>
         <+958>:  movq   0x68855(%rip), %rsi       ; "setNeedsLayout"
         <+965>:  movq   %rdi, %r15
         <+968>:  movq   %r14, %rdi
         <+971>:  movq   %rax, %r12
         <+974>:  callq  *0x6de36(%rip)            ; (void *)0x000000010357d800: objc_msgSend
         <+980>:  movq   %r12, %rax
         <+983>:  movq   %r15, %rdi
         <+986>:  testb  $0x20, %ah
         <+989>:  je     0x1041b2450               ; <+1058>
         <+991>:  movq   %rdi, %r15
         <+994>:  testq  %r13, %r13
         <+997>:  je     0x1041b2436               ; <+1032>
         <+999>:  movq   0x6809c(%rip), %rdx       ; "removeAnimationForKey:"
         <+1006>: movq   0x68915(%rip), %rsi       ; "performSelectorOnMainThread:withObject:waitUntilDone:"
         <+1013>: leaq   0x7a106(%rip), %rcx       ; @"contents"
         <+1020>: xorl   %r8d, %r8d
         <+1023>: movq   %r14, %rdi
         <+1026>: callq  *0x6de02(%rip)            ; (void *)0x000000010357d800: objc_msgSend
         <+1032>: movq   0x68823(%rip), %rsi       ; "setNeedsDisplay"
         <+1039>: movq   %r14, %rdi
         <+1042>: callq  *0x6ddf2(%rip)            ; (void *)0x000000010357d800: objc_msgSend
         <+1048>: movq   %r15, %rdi
         <+1051>: orb    $0x20, 0x85(%rdi)
         <+1058>: movsd  -0x38(%rbp), %xmm0
         <+1063>: movsd  %xmm0, -0x48(%rbp)
         <+1068>: jmp    0x1041b24ad               ; <+1151>
         <+1070>: movq   0x688dd(%rip), %rsi       ; "_cancelAnimationTimer"
         <+1077>: movq   %r14, %rdi
         <+1080>: callq  *0x6ddcc(%rip)            ; (void *)0x000000010357d800: objc_msgSend
         <+1086>: testb  $0x10, %bh
         <+1089>: je     0x1041b2481               ; <+1107>
         <+1091>: movq   0x687d0(%rip), %rsi       ; "setNeedsLayout"
         <+1098>: movq   %r14, %rdi
         <+1101>: callq  *0x6ddb7(%rip)            ; (void *)0x000000010357d800: objc_msgSend
         <+1107>: testb  $0x20, %bh
         <+1110>: jne    0x1041b248f               ; <+1121>
         <+1112>: movq   -0x60(%rbp), %rbx
         <+1116>: movq   %r15, %rdi
         <+1119>: jmp    0x1041b24ad               ; <+1151>
         <+1121>: movq   0x687ca(%rip), %rsi       ; "setNeedsDisplay"
         <+1128>: movq   %r14, %rdi
         <+1131>: callq  *0x6dd99(%rip)            ; (void *)0x000000010357d800: objc_msgSend
         <+1137>: movq   %r15, %rdi
         <+1140>: orb    $0x20, 0x85(%rdi)
         <+1147>: movq   -0x60(%rbp), %rbx
         <+1151>: movq   -0x30(%rbp), %rsi
         <+1155>: callq  0x1041b0e50               ; CA::Layer::set_animations(CA::Layer::Animation*)
         <+1160>: movb   $0x1, %al
         <+1162>: movsd  -0x48(%rbp), %xmm0
         <+1167>: movsd  %xmm0, (%rbx)
         <+1171>: addq   $0x48, %rsp
         <+1175>: popq   %rbx
         <+1176>: popq   %r12
         <+1178>: popq   %r13
         <+1180>: popq   %r14
         <+1182>: popq   %r15
         <+1184>: popq   %rbp
         <+1185>: retq   
    View Code

     

    下面是跳转的形态图:

    这个函数一共有17jmp指令,我将其划分成17jmp block孤岛,分支跳转指令在这17座孤岛中穿插。下面我借用UML对象图的符号来描述,符号的作用被重定义为:

    ~package),入口地址。

    +public),外出跳转。

    #protected),往回走(backwards)的外出跳转。

    -private),jmp block内跳转,没有离开jmp block的跳转。

    =(初始值),表示跳转的目的偏移位置。

    ->direct-link),有向线表示jmp blocks之间的跳转,蓝色代表跳转到另一个jmp block的入口,黑色代表跳转到另一个jmp block的体内。

    对象符号表示一个jmp block孤岛,绿色代表按某种策略选定为主线成员,不宜作为inline候选。

    下面是反映这个函数分支连接的图:

     

    可以看出(黑色)非主线成员的孤岛可以被内联到(绿色)主线成员孤岛的分支中,然后回到主线上。但是并没有一条线路可以满足将17个孤岛连成线的。

     

    下面是对第#4JmpBlock进行内联后逆向分支输出:

      

    #6JmpBlock被内联到#4号在offset 342处的分支内,#11内联到了#6号内联块的结尾offset 493,并且#11号内联片段是从体内截取出来,而不是#11号内联从头开始的整个代码块。

    477493598617的片段被内联到了offset 342的分支内,分支外继续#4JmpBlock的执行流。这样就减少了,逆向代码中凌乱的跳转,而且将跳转的单位上升到JmpBlock的粒度,并且是non-inlineJmpBlock。虽然没有减少goto的数量,但是大大减少了goto目的选择的可能性,而且内联减少了很多中间的跳转,使跳转更加直接,容易归纳分析。

    另外在每个JmpBlock的开头输出的注释,提供了有力的跟踪分析的信息。例如内联块的指令数目,可以看出#6#11都是只有几条指令的小内联块。还有内联块的入边和出边分别关联到哪些其它块的可能,也还是从何处来往何处走,#11内联的注释表示这个块将内联到多处,但结果都将走向#12JmpBlock

     

    世上没有通杀的银子弹,和包治百病的药,具体问题还要具体分析,所以针对像这样包含了很无条件跳转指令的函数的逆向分析,我使用了另一个逆向策略-内联。其实,这只策略在本文中分析的目标函数,也并不完全适用,因为在后面4JmpBlock中它们的关联并非内联,而更多是二路分支if-else

     

    总算是多了一个帮助分析的选择。

    最后贴上部分输出结果:

    /***
    * Summary:
    * total JmpBlock(s): 17
    * noninline block(s): #0, #2, #4, #7, #10, #12, #13, #14, #15, #16
    * inline block(s): #1, #3, #5, #6, #8, #9, #11
    */
    
    
    /***
    * #0<<JmpBlock>>
    * 0 to 143
    * instrs: 40
    * inners: 0
    *
    */
    _f0:
    // 66
    if () {
        /***
        * #1<<Inline JmpBlock>>
        * 145(145) to 147
        * instrs: 2
        * incomings: 1    ; #0
        * outgoings: 1    ; #16
        * depth: 1
        *
        */
        // 145
        // 147
        goto _f1162;    // to #16
                        // end of inline #1
    }
    // 90
    if () {
        goto _f152;    // to #2, BoJ
    }
    // 112
    if () {
        goto _f812;    // to #13, BoJ
    }
    // 143
    goto _f178;    // to #2
                // end of non-inline #0
    
                /***
                * #2<<JmpBlock>>
                * 152 to 278
                * instrs: 34
                * inners: 0
                *
                */
    _f152:
    _f152:    // from #0(90)
    _f178:    // from #0(143, EoJ)
    _b184:    // from #12(732)
    _b187:    // from #4(438)
            // 191
    if () {
        goto _f704;    // to #12
    }
    // 204
    if () {
        goto _f704;    // to #12
    }
    // 257
    if () {
        /***
        * #5<<Inline JmpBlock>>
        * 449(449) to 472
        * instrs: 7
        * incomings: 1    ; #2
        * outgoings: 2    ; #9, #12
        * depth: 1
        *
        */
        // 449
        // 467
        if () {
            /***
            * #9<<Inline JmpBlock>>
            * 552(552) to 562
            * instrs: 5
            * incomings: 1    ; #5
            * outgoings: 2    ; #12
            * depth: 2
            *
            */
            // 552
            // 558
            if () {
                goto _f646;    // to #12
            }
            // 562
            goto _f646;    // to #12
                        // end of inline #9
        }
        // 472
        goto _f646;    // to #12
                    // end of inline #5
    }
    // 271
    if () {
        /***
        * #3<<Inline JmpBlock>>
        * 280(280) to 328
        * instrs: 14
        * incomings: 2    ; #2
        * outgoings: 4    ; #4, #6, #7
        * depth: 1
        *
        */
        // 280
        // 300
        if () {
            goto _f333;    // to #4, BoJ
        }
        // 311
        if () {
            /***
            * #6<<Inline JmpBlock>>
            * 477(477) to 493
            * instrs: 5
            * incomings: 2    ; #3, #4
            * outgoings: 2    ; #10, #11
            * depth: 2
            *
            */
            // 477
            // 486
            if () {
                goto _f564;    // to #10, BoJ
            }
            // 493
            /***
            * #11<<Inline JmpBlock>>
            * 588(598) to 617
            * instrs: 8
            * incomings: 6    ; #6, #7, #8, #10
            * outgoings: 2    ; #12
            * depth: 3
            * concast #6 to #11
            *
            */
            // 598
            // 607
            if () {
                goto _f619;    // to #12, BoJ
            }
            // 617
            goto _f627;    // to #12
                        // end of inline #11
                        // end of inline #6
        }
        // 326
        if () {
            goto _f363;    // to #4
        }
        // 328
        goto _f495;    // to #7, BoJ
                    // end of inline #3
    }
    // 278
    /***
    * #3<<Inline JmpBlock>>
    * 280(292) to 328
    * instrs: 14
    * incomings: 2    ; #2
    * outgoings: 4    ; #4, #6, #7
    * depth: 1
    * concast #2 to #3
    *
    */
    // 292
    // 300
    if () {
        goto _f333;    // to #4, BoJ
    }
    // 311
    if () {
        /***
        * #6<<Inline JmpBlock>>
        * 477(477) to 493
        * instrs: 5
        * incomings: 2    ; #3, #4
        * outgoings: 2    ; #10, #11
        * depth: 2
        *
        */
        // 477
        // 486
        if () {
            goto _f564;    // to #10, BoJ
        }
        // 493
        /***
        * #11<<Inline JmpBlock>>
        * 588(598) to 617
        * instrs: 8
        * incomings: 6    ; #6, #7, #8, #10
        * outgoings: 2    ; #12
        * depth: 3
        * concast #6 to #11
        *
        */
        // 598
        // 607
        if () {
            goto _f619;    // to #12, BoJ
        }
        // 617
        goto _f627;    // to #12
                    // end of inline #11
                    // end of inline #6
    }
    // 326
    if () {
        goto _f363;    // to #4
    }
    // 328
    goto _f495;    // to #7, BoJ
                // end of inline #3
                // end of non-inline #2
    
                /***
                * #4<<JmpBlock>>
                * 333 to 444
                * instrs: 25
                * inners: 0
                *
                */
    _f333:
    _f333:    // from #3(300, inline)
            // 342
    if () {
        /***
        * #6<<Inline JmpBlock>>
        * 477(477) to 493
        * instrs: 5
        * incomings: 2    ; #3, #4
        * outgoings: 2    ; #10, #11
        * depth: 1
        *
        */
        // 477
        // 486
        if () {et 
            goto _f564;    // to #10, BoJ
        }
        // 493
        /***
        * #11<<Inline JmpBlock>>
        * 588(598) to 617
        * instrs: 8
        * incomings: 6    ; #6, #7, #8, #10
        * outgoings: 2    ; #12
        * depth: 2
        * concast #6 to #11
        *
        */
        // 598
        // 607
        if () {
            goto _f619;    // to #12, BoJ
        }
        // 617
        goto _f627;    // to #12
                    // end of inline #11
                    // end of inline #6
    }
    // 357
    if () {
        goto _f495;    // to #7, BoJ
    }
    _f363:    // from #3(326, inline)
            // 399
    if () {
        /***
        * #8<<Inline JmpBlock>>
        * 542(542) to 550
        * instrs: 3
        * incomings: 1    ; #4
        * outgoings: 1    ; #11
        * depth: 1
        *
        */
        // 542
        // 550
        /***
        * #11<<Inline JmpBlock>>
        * 588(598) to 617
        * instrs: 8
        * incomings: 6    ; #6, #7, #8, #10
        * outgoings: 2    ; #12
        * depth: 2
        * concast #8 to #11
        *
        */
        // 598
        // 607
        if () {
            goto _f619;    // to #12, BoJ
        }
        // 617
        goto _f627;    // to #12
                    // end of inline #11
                    // end of inline #8
    }
    // 438
    if () {
        goto _b187;    // to #2
    }
    // 444
    goto _f738;    // to #12
                // end of non-inline #4
    
                /***
                * #7<<JmpBlock>>
                * 495 to 540
                * instrs: 13
                * inners: 1
                *
                */
    _f495:
    _f495:    // from #3(328, inline, EoJ)
    _f495:    // from #4(357)
            // 531
    if () {
        /***
        * #11<<Inline JmpBlock>>
        * 588(598) to 617
        * instrs: 8
        * incomings: 6    ; #6, #7, #8, #10
        * outgoings: 2    ; #12
        * depth: 1
        *
        */
        // 598
        // 607
        if () {
            goto _f619;    // to #12, BoJ
        }
        // 617
        goto _f627;    // to #12
                    // end of inline #11
    }
    // 540
    /***
    * #11<<Inline JmpBlock>>
    * 588(598) to 617
    * instrs: 8
    * incomings: 6    ; #6, #7, #8, #10
    * outgoings: 2    ; #12
    * depth: 1
    * concast #7 to #11
    *
    */
    // 598
    // 607
    if () {
        goto _f619;    // to #12, BoJ
    }
    // 617
    goto _f627;    // to #12
                // end of inline #11
                // end of non-inline #7
    
                /***
                * #10<<JmpBlock>>
                * 564 to 586
                * instrs: 7
                * inners: 1
                *
                */
    _f564:
    _f564:    // from #6(486, inline)
            // 574
    if () {
        /***
        * #11<<Inline JmpBlock>>
        * 588(588) to 617
        * instrs: 8
        * incomings: 6    ; #6, #7, #8, #10
        * outgoings: 2    ; #12
        * depth: 1
        *
        */
        // 588
        // 607
        if () {
            goto _f619;    // to #12, BoJ
        }
        // 617
        goto _f627;    // to #12
                    // end of inline #11
    }
    // 586
    /***
    * #11<<Inline JmpBlock>>
    * 588(598) to 617
    * instrs: 8
    * incomings: 6    ; #6, #7, #8, #10
    * outgoings: 2    ; #12
    * depth: 1
    * concast #10 to #11
    *
    */
    // 598
    // 607
    if () {
        goto _f619;    // to #12, BoJ
    }
    // 617
    goto _f627;    // to #12
                // end of inline #11
                // end of non-inline #10
    
                /***
                * #12<<JmpBlock>>
                * 619 to 810
                * instrs: 56
                * inners: 7
                *
                */
    _f619:
    _f619:    // from #11(607, inline)
    _f627:    // from #11(617, inline, EoJ)
    _f646:    // from #5(472, inline, EoJ)
    _f646:    // from #9(558, inline)
    _f646:    // from #9(562, inline, EoJ)
    _f704:    // from #2(191)
    _f704:    // from #2(204)
            // 732
    if () {
        goto _b184;    // to #2
    }
    _f738:    // from #4(444, EoJ)
            // 810
    goto _f824;    // to #13
                // end of non-inline #12
    
                /***
                * #13<<JmpBlock>>
                * 812 to 863
                * instrs: 16
                * inners: 1
                *
                */
    _f812:
    _f812:    // from #0(112)
    _f824:    // from #12(810, EoJ)
            // 826
    if () {
        goto _f865;    // to #14, BoJ
    }
    // 830
    if () {
        goto _f1147;    // to #16
    }
    // 850
    if () {
        goto _f1147;    // to #16
    }
    // 863
    goto _f900;    // to #14
                // end of non-inline #13
    
                /***
                * #14<<JmpBlock>>
                * 865 to 1068
                * instrs: 54
                * inners: 3
                *
                */
    _f865:
    _f865:    // from #13(826)
    _f900:    // from #13(863, EoJ)
            // 905
    if () {
        goto _f1070;    // to #15, BoJ
    }
    // 944
    if () {
        goto _f1151;    // to #16
    }
    // 1068
    goto _f1151;    // to #16
                    // end of non-inline #14
    
                    /***
                    * #15<<JmpBlock>>
                    * 1070 to 1119
                    * instrs: 13
                    * inners: 1
                    *
                    */
    _f1070:
    _f1070:    // from #14(905)
            // 1110
    if () {
        goto _f1121;    // to #16, BoJ
    }
    // 1119
    goto _f1151;    // to #16
                    // end of non-inline #15
    
                    /***
                    * #16<<JmpBlock>>
                    * 1121 to 1185
                    * instrs: 19
                    * inners: 0
                    *
                    */
    _f1121:
    // 1185
    return;
    // end of non-inline #16
    View Code

     

     

    转载于:https://www.cnblogs.com/bbqzsl/p/5356054.html

    展开全文
  • 在ECT图像重建中,由于敏感场S常常不为方阵且病态,因此无法直接求解问题 。为了求解问题,数学家和工程师提出了各式各样的算法,从最原始的LBP到...令 等于方阵 的最大本征值,则可控制迭代中的增益因子 为 [1]...

    bcae53c3a0ca765d43e699261a5db97f.png

    在ECT图像重建中,由于敏感场S常常不为方阵且病态,因此无法直接求解反问题

    。为了求解反问题,数学家和工程师提出了各式各样的算法,从最原始的LBP到现在的深度学习。Landweber迭代就是一种最常见和基础的线性迭代算法。

    af407aa837526ebe5945990f64db99d1.png
    Landweber迭代法简介

    由迭代公式得,稳定的收敛判据为

    ,其中
    为增益因子。令
    等于方阵
    的最大本征值,则可控制迭代中的增益因子
    [1]

    简易版MATLAB代码为:

    function g = landweber(delta_C, S, iteration)
    %-----input-----
    %delta_C: vectors of change in capacitance
    %S: sensitivity matrix
    %iteration: The number of iterations
    
    %-----output-----
    %g: reconstructed permittivity vector
    
      l = svd(S'*S);
      l_max = lambda(1,1);
      alpha = 2/l_max;
    
      g = zeros(size(S,2),1);
      iteration = 20;
      for i = 1:iteration
          g = g + alpha * (S' * (-S * g + delta_C));
      end
    end

    参考

    1. ^[1]王化祥, 王超, 陈磊. 基于Landweber迭代的图像重建算法[J]. 信号处理, 2000, 16(4):354-356.
    展开全文
  • 给出了并联机构运动学解及牛顿迭代正解方法的计算方法,分析了变搜索原点迭代正解方法的原理及实际使用中的可行性,给出了计算流程。最后通过对比的仿真计算验证算法的计算精度及计算效率。结果显示,在保证相同精度...
  • 而这个输入则是下一个一阶系统的状态变量,下一个一阶系统有了其状态变量的参考值,再利用Lyapunov函数又可以找到一个参考输入,而这个输入则又是下一个一阶系统的状态变量…如此迭代下去,直至推到输入u(最后一个...

    Backstepping基础

    这一部分强烈建议自己拿出一张草稿纸推一推这篇博客的内容:backstepping

    backstepping的思想正如其名字,反推,将一个高阶系统分解成无数个一阶系统,对每一个一阶系统利用Lyapunov函数找到一个参考输入,而这个输入则是下一个一阶系统的状态变量,下一个一阶系统有了其状态变量的参考值,再利用Lyapunov函数又可以找到一个参考输入,而这个输入则又是下一个一阶系统的状态变量…如此迭代下去,直至推到输入u(最后一个一阶系统)。结合下面这个SISO系统理解我上面说的话:
    在这里插入图片描述
    刚开始接触的时候可能会问:上面这个系统微分方程组太特殊了,假如x1的一阶导数有输入u呢,或者x2的导数有x4呢?回答是:以LTI系统为例,如果这个系统是可控的,则可以变化为能控标准型,那么就有上面描述的式子了,并且很多非线性系统也能转化为上面这种形式。

    上面这个式子我们还可以这样分析:输入u作用在xn上让xn变化,而xn又是xn-1的输入,则改变了xn-1,迭代下去最后推到x1,这么一个思路分析是正向的,与backstepping的思路恰好相反。这也印证了一个道理“求解问题是正向思维,设计问题(这里是设计控制器)是逆向思维

    一个二阶系统实例入门Backstepping(手工推导)

    这一部分我用ipad书写,跟着这个tutorial推一遍你应该学会了基本思路。

    在这里插入图片描述

    Simulink仿真

    搭建模型

    使用S函数搭建这个非线性系统,代码在后面,想要模型的:
    backstepping非线性控制demo(模型有注释)
    在这里插入图片描述

    结果

    常数给定x1dx_{1d}

    在这里插入图片描述
    上面的是x1x_1和给定(蓝色线),下面的是x2x_2曲线。

    跟踪正弦信号

    在这里插入图片描述
    上面的是x1x_1和给定(蓝色线),下面的是x2x_2曲线。

    斜坡输入

    在这里插入图片描述

    综上可以看到,跟踪效果相当好!

    Backstepping存在的问题

    一旦阶数过高,将引起“复杂度爆炸”问题,这是backstepping的重大缺陷,无论是Lyapunov函数计算还是其它,每一步back必将带来更大的计算量!

    附录

    S函数源码

    function [sys,x0,str,ts,simStateCompliance] = mysystem(t,x,u,flag)
    %   FLAG   RESULT             DESCRIPTION
    %   -----  ------             --------------------------------------------
    %   0      [SIZES,X0,STR,TS]  Initialization, return system sizes in SYS,
    %                             initial state in X0, state ordering strings
    %                             in STR, and sample times in TS.
    %   1      DX                 Return continuous state derivatives in SYS.
    %   2      DS                 Update discrete states SYS = X(n+1)
    %   3      Y                  Return outputs in SYS.
    %   4      TNEXT              Return next time hit for variable step sample
    %                             time in SYS.
    %   5                         Reserved for future (root finding).
    %   9      []                 Termination, perform any cleanup SYS=[].
    switch flag
    
      %%%%%%%%%%%%%%%%%%
      % Initialization %
      %%%%%%%%%%%%%%%%%%
      case 0
        [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes;
     
      %%%%%%%%%%%%%%%
      % Derivatives %
      %%%%%%%%%%%%%%%
      case 1
        sys=mdlDerivatives(t,x,u);
    
      %%%%%%%%%%
      % Update %
      %%%%%%%%%%
      case 2
        sys=mdlUpdate(t,x,u);
    
      %%%%%%%%%%%
      % Outputs %
      %%%%%%%%%%%
      case 3
        sys=mdlOutputs(t,x,u);
    
      %%%%%%%%%%%%%%%%%%%%%%%
      % GetTimeOfNextVarHit %
      %%%%%%%%%%%%%%%%%%%%%%%
      case 4
        sys=mdlGetTimeOfNextVarHit(t,x,u);
    
      %%%%%%%%%%%%%
      % Terminate %
      %%%%%%%%%%%%%
      case 9
        sys=mdlTerminate(t,x,u);
    
      %%%%%%%%%%%%%%%%%%%%
      % Unexpected flags %
      %%%%%%%%%%%%%%%%%%%%
      otherwise
        DAStudio.error('Simulink:blocks:unhandledFlag', num2str(flag));
    
    end
    
    
    function [sys,x0,str,ts,simStateCompliance]=mdlInitializeSizes
    sizes = simsizes;
    sizes.NumContStates  = 2;
    sizes.NumDiscStates  = 0;
    sizes.NumOutputs     = 2;
    sizes.NumInputs      = 1;
    sizes.DirFeedthrough = 1;         %输出如果用到了u这里一定写1!虽然我这里输出没用到输入但是建议还是写1.
    sizes.NumSampleTimes = 1;   % at least one sample time is needed
    sys = simsizes(sizes);
    %
    % initialize the initial conditions
    %
    x0  = zeros(2,1);
    %
    % str is always an empty matrix
    %
    str = [];
    %
    % initialize the array of sample times
    %
    ts  = [0 0];
    % Specify the block simStateCompliance. The allowed values are:
    %    'UnknownSimState', < The default setting; warn and assume DefaultSimState
    %    'DefaultSimState', < Same sim state as a built-in block
    %    'HasNoSimState',   < No sim state
    %    'DisallowSimState' < Error out when saving or restoring the model sim state
    simStateCompliance = 'UnknownSimState';
    % end mdlInitializeSizes
    
    %
    %=============================================================================
    % mdlDerivatives
    % Return the derivatives for the continuous states.
    %=============================================================================
    %
    function sys=mdlDerivatives(t,x,u)
    
    sys = [x(1)^2-x(1)^3+x(2);u];
    
    % end mdlDerivatives
    
    %
    %=============================================================================
    % mdlUpdate
    % Handle discrete state updates, sample time hits, and major time step
    % requirements.
    %=============================================================================
    %
    function sys=mdlUpdate(t,x,u)
    sys = [];
    
    % end mdlUpdate
    
    %
    %=============================================================================
    % mdlOutputs
    % Return the block outputs.
    %=============================================================================
    %
    function sys=mdlOutputs(t,x,u)         %这个flag编写输出
    
    sys = x;
    
    
    % end mdlOutputs
    
    %
    %=============================================================================
    % mdlGetTimeOfNextVarHit
    % Return the time of the next hit for this block.  Note that the result is
    % absolute time.  Note that this function is only used when you specify a
    % variable discrete-time sample time [-2 0] in the sample time array in
    % mdlInitializeSizes.
    %=============================================================================
    %
    function sys=mdlGetTimeOfNextVarHit(t,x,u)
    
    sys = [];
    
    % end mdlGetTimeOfNextVarHit
    
    %
    %=============================================================================
    % mdlTerminate
    % Perform any end of simulation tasks.
    %=============================================================================
    %
    function sys=mdlTerminate(t,x,u)
    
    sys = [];
    
    % end mdlTerminate
    
    展开全文
  • 描述符:将某种特殊类型的类的... __set__(self, instance, value):将在属性分配操作中调用,不回任何内容  __get__(self, instance, owner) 用于访问属性,返回属性值  __delete__(self, instance):控制删除...

    描述符:将某种特殊类型的类的实例指派给另一个类的属性

    特殊类型:

      至少实现以下三个魔法方法中的一个(描述符属性的方法):

      __set__(self, instance, value):将在属性分配操作中调用,不反回任何内容

      __get__(self, instance, owner) 用于访问属性,返回属性值

      __delete__(self, instance):控制删除操作,不反悔任何内容

    注意这三个参数的含义:self是指描述符类的实例对象,instance是指派给的类的实例对象,owner为指派给的类

    从描述符的使用分析,首先要在一个类Test_test中实例化该描述符类Test,这个实例化对象 t 为为类Test_test的一个属性,此时对该属性 t 进行赋值操作时,由于t 为Test的一个对象,因此会调用 方法 __set__(),此时,self即为绑定的对象 t而 instance为t所属的类实例化的对象(test).

     1 class Test():
     2     def __set__(self, instance, value):
     3         print('setting', self, instance, value)
     4         
     5     def __get__(self, instance, owner):
     6         print('getting', self, instance, owner)
     7         
     8     def __delete__(self, instance):
     9         print('delete', self, instance)
    10         
    11 class Test_test():
    12     t = Test()
    13     
    14 test = Test_test()
    15 test.t = 10
    16 test.t
    17 del test.t
    18 ##########################################
    19 
    20 setting <__main__.Test object at 0x01ADB050> <__main__.Test_test object at 0x01ADB030> 10
    21 getting <__main__.Test object at 0x01ADB050> <__main__.Test_test object at 0x01ADB030> <class '__main__.Test_test'>
    22 delete <__main__.Test object at 0x01ADB050> <__main__.Test_test object at 0x01ADB030>
    class Celsius():
        def __init__(self, fset = None, fget = None, fdel = None):
            self.fset = fset
            self.fget = fget
            self.fdel = fdel
            
        def __get__(self, instance, owner):
            return self.fget(instance)*1.8 + 30
        
        def __set__(self, instance, value):
            self.fset(instance, value)
        
        def __delete__(self, instance):
            self.fdel(instance)
            
    class Tempeature():
        def __init__(self):
            self.__x = None
            
        def __fset(self, value):
            self.__x = value
            
        def __fget(self):
            return self.__x
            
        def __fdel(self):
            del self.__x
            
        c = Celsius(__fset, __fget, __fdel)
        
    t = Tempeature()
    t.c = 10
    print(t.__dict__)
    print(t.c)
    del t.c
    print(t.__dict__)
    
    #######################################
    
    {'_Tempeature__x': 10}
    48.0
    {}

    描述符的意义在于,可以默认的调用一些函数,而通过初始化这个类可以将外部的函数作为参数传递进来,并在描述符类中魔法方法被自动调用时使传入的函数参数被自动的执行。如上例所示,通过将Tempeature类中的函数作为参数传入 描述符,使得在描述符中的魔法方法被自动调用时实现 实例对象 t 内部函数的自动调用。

     

    注意,描述符的意义不在于给 描述符赋值,而是通过描述符隐式的为类中的参数赋值。因此在 魔法方法__set__(self, instance, value)中并不会出现属性名。属性值的设置需要包含的被自动调用的魔法方法中,可以很好的隐藏类中的属性。(个人理解)

    定制容器:

    容器类型的协议:

      希望定制的容器时不可变的:只需要 __len__() 与 __getitem__()

      希望定制的容器是可变的: __len__() __getitem__() __setitem__() __delitem__()

    __len__(self):定义当被 len()调用时的行为

    __getitem__(self, key): 定义获取容器中指定元素的行为

    __setitem__(self, key, value): 定义设置容器中元素的行为 self[key] = value

    __delitem__(self, key):定义删除容器中指定元素的行为

    _iter__(self):定义迭代容器中元素的行为

    __reversed__(self):定义 reversed()的行为

    __contains__(self, item):定义使用成员运算符 in 或 not in的行为

     

    自定义一个不可变的列表, 并记录每个值被访问的次数。

     1 class Mylist():
     2     def __init__(self, *args):
     3         self.list = [x for x in args]
     4         self.length = len(self.list)
     5         self.times = [0]*self.length
     6     
     7     def __len__(self):
     8         return self.length
     9     
    10     def __getitem__(self, key):
    11         if key < self.length:
    12             self.times[key] += 1
    13             return self.list[key]
    14         else:
    15             print('KeyError')
    16         
    17 l = Mylist(1,2,3,5)
    18 print(len(l))
    19 l[2]
    20 print(l.times)
    21 
    22 #############################
    23 4
    24 [0, 0, 1, 0]

     迭代器:

      iter()

        __iter__(self):return self返回实例对象本身

      next()

        __next__(self):定义迭代规则

     1 >>> class F():
     2     def __init__(self):
     3         self.a = 0
     4         self.b = 1
     5     def __iter__(self):
     6         return self
     7     def __next__(self):
     8         self.a, self.b = self.b, self.a + self.b
     9         return self.a
    10 
    11 >>> f = F()
    12 >>> for i in f:
    13     print(i)

    加入迭代大小控制:

     1 >>> class F():
     2     def __init__(self, n = 10):
     3         self.a = 0
     4         self.b = 1
     5         self.n = n
     6     def __iter__(self):
     7         return self
     8     def __next__(self):
     9         self.a, self.b = self.b, self.a + self.b
    10         if self.a < self.n:
    11             return self.a
    12         else:
    13             raise StopIteration
    14 
    15         
    16 >>> f = F(100)
    17 >>> for i in f:
    18     print(i)
    19 
    20     
    21 1
    22 1
    23 2
    24 3
    25 5
    26 8
    27 13
    28 21
    29 34
    30 55
    31 89

    生成器:yield

      协同程序:可以运行的独立函数调用,函数可以暂停或者挂起,并在需要的时候在程序离开的地方继续或重新开始。

      yield 类似于return,执行到yield则停止执行,下次继续执行

     1 >>> def MyGen():
     2     a = 0
     3     b = 1
     4     while True:
     5         a,b = b, a + b
     6         yield a
     7 
     8         
     9 >>> g = MyGen()
    10 >>> next(g)
    11 1
    12 >>> next(g)
    13 1
    14 >>> next(g)
    15 2
    16 >>> 

     

    转载于:https://www.cnblogs.com/JYNNO1/p/10484644.html

    展开全文
  • minecraft_bigreactor_control, Minecraft BigReactor Computercraft控制程序 基于的核 Minecraft BigReactor Computercraft控制程序更稳定控制算法的迭代描述这个程序使用Minecraft的计算机控制端口,在中控制大型...
  • 通过形态学中的顶帽变换增强图像的对比度,利用迭代中值滤波与原图像的差值获取图像的细节信息,采用自适应调节参数控制细节锐化。由于图像中某些局部细节信息和人类视觉系统具有模糊性,采用模糊数学算子代替普通的加...
  • 梯度的方向是函数在给定点上升最快的方向,那么梯度的方向就是函数在给定点下降最快的方向, α:学习率或者步长,意味着我们可以通过α来控制每一步走的距离,以保证不要步子跨的太大,哈哈,其实就是不要走太快...
  • 我们将讨论当您需要在业务流程模型中描述分支和迭代行为时出现的模式。对于归纳为模式的典型错误,我们将引入示例来加以演示。接下来,我们将提供一个或多个模式来说明符合建模场景的正确解决方案,并在此基础上...
  • 者,道之动 程序控制结构条件表达式选择结构循环结构 条件表达式 条件表达式: 条件表达式的值只要不是False、0、空值None、空列表、空元组、空集合、空字典、空字符串、空range对象或其他空迭代对象,Python...
  • 针对一种四自由度工业串联机器人,为实现其在工作时的精确运动控制,对其进行运动学...根据正解方程使用Jacobian-迭代法,推导出机构的解方程,用于运动控制的输入。通过ADAMS-MATLAB的联合仿真验证运动学方程的有效性。
  • console.log跟python的print有点不一样,不能每次控制都换行,先试试打方阵,插值需要用引号 看一下对角线,修改判断 每一行都需要清空 对象可以用索引的方式来取,这里是插值 插值的要求是${表达式} for of是...
  • 第2集 责任链设计模式案例实战-老王设计的作弊系统的风控级别 第3集 Command Pattern命令设计模式介绍和应用场景 第4集 命令设计模式之智能家居控制案例实战 第5集 IteratorPattern迭代器设计模式介绍和应用...
  • UML和模式应用(原书第3版)

    热门讨论 2013-06-20 00:33:37
    17.13 控制器 17.14 高内聚 17.15 参考资料 第18章 使用grasp的对象设计示例 18.1 什么是用例实现 18.2 制品注释 18.3 下一步工作 18.4 nextgen迭代的用例实现 18.5 monopoly迭代的用例实现 18.6 过程:...
  • 对6-DOF并联机器人的位置正解进行了研究和分析,通过位置解的求解思路来解位置正解的问题。将上下平台统一在一个坐标系下。按照空间两点间距离计算公式,以6个杆的伸长值为已知量,位姿参数为未知量,建立关于6个...
  • 32.17 自关联 32.18 使用包来组织领域模型 32.19 示例:Monopoly领域模型的精化 第33章 架构分析 33.1 过程:何时开始架构分析 33.2 定义:变化点和进化点 33.3 架构分析 33.4 架构分析的常用步骤 33.5 ...
  • 32.17 自关联 32.18 使用包来组织领域模型 32.19 示例:Monopoly领域模型的精化 第33章 架构分析 33.1 过程:何时开始架构分析 33.2 定义:变化点和进化点 33.3 架构分析 33.4 架构分析的常用步骤 33.5 ...
  • 32.17 自关联 32.18 使用包来组织领域模型 32.19 示例:Monopoly领域模型的精化 第33章 架构分析 33.1 过程:何时开始架构分析 33.2 定义:变化点和进化点 33.3 架构分析 33.4 架构分析的常用步骤 33.5 ...
  • 32.17 自关联 32.18 使用包来组织领域模型 32.19 示例:Monopoly领域模型的精化 第33章 架构分析 33.1 过程:何时开始架构分析 33.2 定义:变化点和进化点 33.3 架构分析 33.4 架构分析的常用步骤 33.5 ...
  • 32.17 自关联 32.18 使用包来组织领域模型 32.19 示例:Monopoly领域模型的精化 第33章 架构分析 33.1 过程:何时开始架构分析 33.2 定义:变化点和进化点 33.3 架构分析 33.4 架构分析的常用步骤 33.5 ...
  • 32.17 自关联 32.18 使用包来组织领域模型 32.19 示例:Monopoly领域模型的精化 第33章 架构分析 33.1 过程:何时开始架构分析 33.2 定义:变化点和进化点 33.3 架构分析 33.4 架构分析的常用步骤 33.5 ...
  • 32.17 自关联 32.18 使用包来组织领域模型 32.19 示例:Monopoly领域模型的精化 第33章 架构分析 33.1 过程:何时开始架构分析 33.2 定义:变化点和进化点 33.3 架构分析 33.4 架构分析的常用步骤 33.5 ...
  • 32.17 自关联 32.18 使用包来组织领域模型 32.19 示例:Monopoly领域模型的精化 第33章 架构分析 33.1 过程:何时开始架构分析 33.2 定义:变化点和进化点 33.3 架构分析 33.4 架构分析的常用步骤 33.5 ...
  • 由于梯度的方向是函数下降最快的方向,为了控制参数调整的速度,算法使用梯度乘以一个步长来当作参数的修正量,这个步长又叫做学习率,即梯度 * 学习率作为参数的修正量 学习率作为控制网络学习速度的超参数,...
  • 3.6 迭代与深度迭代 4.1 长度与距离 4.2 角度 4.3 多边形的面积与周长 4.4 与圆有关的度量 5 用图表菜单作图----甘志高(laoshi_G)编写 5.1 图象画法概述 5.2 抛物线的图象 5.3 分段函数的图象 5.4 用参数控制系数 ...
  • 遗传算法MATLAB代码

    热门讨论 2012-11-08 20:19:48
    %sprintf可以控制输出格式 % 待优化问题 xmin=0;xmax=9; %变量X范围 f='x+10*sin(x.*5)+7*cos(x.*4)'; % 计算适应度,并画出初始种群图形 x=decode(v(:,1:22),xmin,xmax);"位二进制换成十进制,%冒号表示对所有行...
  • 循环结构

    2018-06-26 21:28:16
    1 while循环问题的共同点,写循环代码的套路:1. 都有初始化值 2. 都有一个判断条件 3....(题目中给出的条件往往是的)(3) 反复做什么(4) 怎么过渡到下一次5. 2 do…whileDo while循环和while循环相比 do...
  • 机器学习技术和方法已经被成功应用到多个领域,比如个性推荐系统,金融欺诈,语音识别,自然语言处理和机器翻译,模式识别,智能控制等。 在大数据上进行机器学习,需要处理全量数据并进行大量的迭代计算,这要求
  • 采用Cordic算法求解atan反正切角度

    千次阅读 2020-05-18 20:30:11
    在无感FOC控制中,求解转子位置,可能会用到atan,如果直接运用三角函数求解,运算量大,效率低。这里介绍一种Cordic数字迭代算法来快速求解反正切。 1、Cordic算法介绍 1.1、坐标平面的旋转 在下面的x y平面坐标...

空空如也

空空如也

1 2 3 4 5
收藏数 93
精华内容 37
关键字:

反控制迭代