Lion Blog 个人博客

鲁棒控制

2020-01-13T12:34:24+08:00

鲁棒控制

鲁棒控制（Robust Control）方面的研究始于20世纪50年代。在过去的20年中，鲁棒控制一直是国际自控界的研究热点。所谓“鲁棒性”，是指控制系统在一定（结构，大小）的参数摄动下，维持某些性能的特性。根据对性能的不同定义，可分为稳定鲁棒性和性能鲁棒性。以闭环系统的鲁棒性作为目标设计得到的固定控制器称为鲁棒控制器。

名词解释

由于工作状况变动、外部干扰以及建模误差的缘故，实际工业过程的精确模型很难得到，而系统的各种故障也将导致模型的不确定性，因此可以说模型的不确定性在控制系统中广泛存在。如何设计一个固定的控制器，使具有不确定性的对象满足控制品质，也就是鲁棒控制，成为国内外科研人员的研究课题。
主要的鲁棒控制理论有：（1）Kharitonov区间理论；（2）H∞控制理论；（3）结构奇异值理论（μ理论）等等。

控制理论

H∞控制理论是20世纪80年代开始兴起的一门新的现代控制理论。H∞控制理论是为了改变近代控制理论过于数学化的倾向以适应工程实际的需要而诞生的,其设计思想的真髓是对系统的频域特性进行整形(Loopshaping),而这种通过调整系统频率域特性来获得预期特性的方法,正是工程技术人员所熟悉的技术手段,也是经典控制理论的根本。
1981年Zames首次用明确的数学语言描述了H∞优化控制理论,他提出用传递函数阵的H∞范数来记述优化指标。1984年加拿大学者Fracis和Zames用古典的函数插值理论提出了H∞设计问题的最初解法,同时基于算子理论等现代数学工具,这种解法很快被推广到一般的多变量系统,而英国学者Glover则将H∞设计问题归纳为函数逼近问题,并用Hankel算子理论给出这个问题的解析解。Glover的解法被Doyle在状态空间上进行了整理并归纳为H∞控制问题,至此H∞控制理论体系已初步形成。
在这一阶段提出了H∞设计问题的解法,所用的数学工具非常繁琐,并不像问题本身那样具有明确的工程意义。直到1988年Doyle等人在全美控制年会上发表了著名的DGKF论文,证明了H∞设计问题的解可以通过适当的代数Riccati方程得到。DGKF的论文标志着H∞控制理论的成熟。迄今为止,H∞设计方法主要是DGKF等人的解法。不仅如此,这些设计理论的开发者还同美国的The Math Works公司合作,开发了MATLAB中鲁棒控制软件工具箱(Robust Control Toolbox),使H∞控制理论真正成为实用的工程设计理论。

研究

鲁棒控制的早期研究，主要针对单变量系统（SISO）的在微小摄动下的不确定性，具有代表性的是Zames提出的微分灵敏度分析。然而，实际工业过程中故障导致系统中参数的变化，这种变化是有界摄动而不是无穷小摄动。因此产生了以讨论参数在有界摄动下系统性能保持和控制为内容的现代鲁棒控制。
现代鲁棒控制是一个着重控制算法可 [1] 靠性研究的控制器设计方法。其设计目标是找到在实际环境中为保证安全要求控制系统最小必须满足的要求。一旦设计好这个控制器，它的参数不能改变而且控制性能能够保证。
鲁棒控制方法，是对时间域或频率域来说，一般要假设过程动态特性的信息和它的变化范围。一些算法不需要精确的过程模型，但需要一些离线辨识。
一般鲁棒控制系统的设计是以一些最差的情况为基础，因此一般系统并不工作在最优状态。常用的设计方法有：INA方法，同时镇定，完整性控制器设计，鲁棒控制，鲁棒PID控制以及鲁棒极点配置，鲁棒观测器等。
鲁棒控制方法适用于稳定性和可靠性作为首要目标的应用，同时过程的动态特性已知且不确定因素的变化范围可以预估。飞机和空间飞行器的控制是这类系统的例子。
过程控制应用中，某些控制系统也可以用鲁棒控制方法设计，特别是对那些比较关键且（1）不确定因素变化范围大；（2）稳定裕度小的对象。
但是，鲁棒控制系统的设计要由高级专家完成。一旦设计成功，就不需太多的人工干预。另一方面，如果要升级或作重大调整，系统就要重新设计。

理论特点

1) 将经典频域设计理论具有一定的鲁棒性和现代控制理论状态空间方法适于M IM O 系统的两个优点融合在一起，系统地给出了在频域中进行回路成形的技术和手段。
2) 给出了鲁棒控制系统的设计方法，并充分考虑了系统不确定性的影响，不仅能保证控制系统的鲁棒稳定性，而且能优化某些性能指标。
3) 采用状态空间方法，具有时域方法精确计算和最优化的优点。
4) 多种控制问题均可变换为H∞鲁棒控制理论的标准问题，具有一般性，并适于实际工程应用。

如何入门自动控制理论

2020-01-12T12:34:24+08:00

转自 https://zhuanlan.zhihu.com/p/42615269

如何入门自动控制理论

一个典型的系统响应有什么特点
幅频响应和相频响应
传递函数的零、极点是怎么个回事
什么是闭环控制系统

一、一个典型的系统响应有什么特点

人，对于外界信息的响应，有两个明显特征，一个是“选择性记忆”，另一个是“永久性拖延”。什么是“选择性记忆”——人们只选择记忆自己感兴趣的、认为有价值的信息，而自动筛选掉那些无关紧要的信息，这实际是给大脑减负，减少能量消耗。什么是“永久性拖延呢”？——这个就很好解释了，就一个字：“懒”。那对于一个更简单普遍一些的系统（线性时不变系统，简称LTI），它的响应是什么呢？——和人类似，它也有“选择性记忆”和“永久性拖延”，只不过改了个名字：“选择性记忆”叫做“幅值有衰减”；“永久性拖延”叫做“相位有延迟”。

二、幅频响应和相频响应

举个简单的例子——弹簧振子来说明一下。这是一个单输入（质量块激励力）单输出（质量块位移）系统，质量块可以看成一个刚体（质点），两端分别通过一个弹簧和一个阻尼器连接到壁面上。弹簧提供与位移成正比的力，阻尼器提供与速度成正比的力，质量块在有加速下还会产生惯性力，这是一个典型的二阶系统。惯性力+阻尼力+弹性力=外界激励

现在假设用一个交变的正弦力 [公式] 去激励这个弹簧振子，会出现什么响应呢呢？——俗话说：“龙生龙，凤生凤，老鼠的儿子会打洞”，试验和理论分析结果都表明：当给LTI系统一个正弦激励时，其响应也是一个正弦，而且频率不变。

……

Array & Linked List

2020-01-12T12:34:24+08:00

Array & Linked List [TOC]

知识点

Array Access: O(1) Insert: 平均 O(n) Delete: 平均 O(n)
Linked List Access: O(n) Insert: O(1) Delete: O(1)
Doubly Linked List space O(n) prepend O(1) append O(1) lookup O(n) insert O(1) delete O(1)

例题

206. Reverse Linked List

Reverse a singly linked list. Example:

Input: 1->2->3->4->5->NULL Output: 5->4->3->2->1->NULL

Follow up:A linked list can be reversed either iteratively or recursively. Could you implement both?

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        pre, cur = None, head
        while cur:
            cur.next, pre, cur = pre, cur, cur.next
        return pre

24. Swap Nodes in Pairs

Given a linked list, swap every two adjacent nodes and return its head.You may not modify the values in the list’s nodes, only nodes itself may be changed. Example:

Given 1->2->3->4, you should return the list as 2->1->4->3.

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def swapPairs(self, head: ListNode) -> ListNode:
        pre, pre.next = self, head
        while pre.next and pre.next.next:
            a = pre.next
            b = a.next
            pre.next, b.next, a.next, pre = b, a, b.next, a
        return self.next

141. Linked List Cycle

Given a linked list, determine if it has a cycle in it.To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list. Example 1:

Input: head = [3,2,0,-4], pos = 1 Output: true Explanation: There is a cycle in the linked list, where tail connects to the second node.

Example 2:

Input: head = [1,2], pos = 0 Output: true Explanation: There is a cycle in the linked list, where tail connects to the first node.

Example 3:

Input: head = [1], pos = -1 Output: false Explanation: There is no cycle in the linked list.

Follow up:Can you solve it using O(1) (i.e. constant) memory?

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        fast = slow = head
        while fast and slow and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                return True
        return False

142. Linked List Cycle II

Given a linked list, return the node where the cycle begins. If there is no cycle, return null.To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.Note: Do not modify the linked list. Example 1:

Input: head = [3,2,0,-4], pos = 1 Output: tail connects to node index 1 Explanation: There is a cycle in the linked list, where tail connects to the second node.

Example 2:

Input: head = [1,2], pos = 0 Output: tail connects to node index 0 Explanation: There is a cycle in the linked list, where tail connects to the first node.

Example 3:

Input: head = [1], pos = -1 Output: no cycle Explanation: There is no cycle in the linked list.

Follow up: Can you solve it without using extra space?

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        cur = head
        nodes = set()
        while cur:
            if cur in nodes:
                return cur
            nodes.add(cur)
            cur = cur.next
        return None

25. Reverse Nodes in k-Group

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is. Example:

Given this linked list: 1->2->3->4->5 For k = 2, you should return: 2->1->4->3->5 For k = 3, you should return: 3->2->1->4->5

Note: Only constant extra memory is allowed. You may not alter the values in the list’s nodes, only nodes itself may be changed.

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reverseKGroup(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode
        """
        pre, pre.next = self, head
        while True:
            node = pre
            tmps = dict()
            for i in range(k):
                if node.next is None:
                    break
                node = node.next
                tmps[i] = node
            else:          
                pre.next = tmps[k-1]
                tmps[0].next = tmps[k-1].next
                pre = tmps[0]
                for i in range(k-1, 0, -1):
                    tmps[i].next = tmps[i-1]
                continue
            break
        return self.next