SARIMAX_01

2021-08-08 机器学习

1. 简介

季节差分、乘性季节模型（SARIMA）

增加了三个新的超参数来指定系列季节性成分的自回归（AR），差分（I）和移动平均（MA），以及季节性周期的附加参数

趋势元素
有三个趋势元素需要配置。

它们与 ARIMA 模型相同;特别：

p ：趋势自动回归顺序。
d ：趋势差异顺序。
q ：趋势均线。
季节性元素
有四个不属于 ARIMA 的季节性元素必须配置;他们是：

P ：季节性自回归顺序。
D ：季节性差异顺序。
Q ：季节性移动平均线。
m ：单个季节性时段的时间步数。
同时，SARIMA 模型的表示法指定为：

SARIMA(p,d,q)(P,D,Q)m

迭代器模式Golang

2020-12-07 设计模式

迭代器模式

迭代器模式(Iterator Pattern): 提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示.

优点和缺点

优点:

它支持以不同的方式遍历一个聚合对象
迭代器简化了聚合类

缺点:

增加了类的个数,这在一定程度上增加了系统的复杂性

type Iterator interface {
    Next() interface{}
    HasNext() bool
}

type ConcreteIterator struct {
    index int
    size int
    con Aggregate
}

func (c *ConcreteIterator) HasNext() bool {
    return c.index < c.size
}

func (c *ConcreteIterator) Next() interface{} {
    if c.HasNext() {
        res := c.con.GetElement(c.index)
        c.index++
        return res
    }
    return nil
}

type Aggregate interface {
    Add(obj interface{})
    CreateIterator() Iterator
    GetElement(index int) interface{}
    Size() int
}

type ConcreteAggregate struct {
    docker []interface{}
}

func (c *ConcreteAggregate) Size() int {
    return len(c.docker)
}

func (c *ConcreteAggregate) Add(obj interface{}) {
    c.docker = append(c.docker,obj)
}

func (c *ConcreteAggregate) CreateIterator() Iterator {
    return &ConcreteIterator{
    index: 0,
    size:  c.Size(),
    con:   c,
    }
}

func (c *ConcreteAggregate) GetElement(index int) interface{} {
    return c.docker[index]
}

解释器模式Golang

2020-12-05 设计模式

解释器模式

解释器（Interpreter）模式的定义: 给分析对象定义一个语言,并定义该语言的文法表示,
再设计一个解析器来解释语言中的句子.也就是说,用编译语言的方式来分析应用中的实例.
这种模式实现了文法表达式处理的接口,该接口解释一个特定的上下文.

优点和缺点

优点:

可扩展性比较好
增加了新的解释表达式的方式

缺点:

利用场景比较少

type Node interface {
	Interpret() int
}

type ValNode struct {
	val int
}

func (n *ValNode) Interpret() int {
	return n.val
}

type AddNode struct {
	left, right Node
}

func (n *AddNode) Interpret() int {
	return n.left.Interpret() + n.right.Interpret()
}

type MinNode struct {
	left, right Node
}

func (n *MinNode) Interpret() int {
	return n.left.Interpret() - n.right.Interpret()
}

type Parser struct {
	exp   []string
	index int
	prev  Node
}

func (p *Parser) Parse(exp string) {
	p.exp = strings.Split(exp, " ")

	for {
		if p.index >= len(p.exp) {
			return
		}
		switch p.exp[p.index] {
		case "+":
			p.prev = p.newAddNode()
		case "-":
			p.prev = p.newMinNode()
		default:
			p.prev = p.newValNode()
		}
	}
}

func (p *Parser) newAddNode() Node {
	p.index++
	return &AddNode{
		left:  p.prev,
		right: p.newValNode(),
	}
}

func (p *Parser) newMinNode() Node {
	p.index++
	return &MinNode{
		left:  p.prev,
		right: p.newValNode(),
	}
}

func (p *Parser) newValNode() Node {
	v, _ := strconv.Atoi(p.exp[p.index])
	p.index++
	return &ValNode{
		val: v,
	}
}

func (p *Parser) Result() Node {
	return p.prev
}

观察模式Golang

2020-12-03 设计模式

观察模式

观察模式(Observer Pattern): 实现观察者模式时要注意具体目标对象和具体观察者对象之间不能直接调用,
否则将使两者之间紧密耦合起来,这违反了面向对象的设计原则.

优点和缺点

优点:

观察者和被观察者是抽象耦合的
建立一种触发机制

缺点:

如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间

type Customer interface {
    update()
}

type CustomerA struct {
}

func (*CustomerA) update() {
    fmt.Println("A")
}

type CustomerB struct {
}

func (*CustomerB) update() {
    fmt.Println("B")
}

type NewsOffice struct {
    customers []Customer
}

func (n *NewsOffice) addCustomer(customer Customer) {
    n.customers = append(n.customers, customer)
}

func (n *NewsOffice) newspaperCome() {
    n.notifyAllCustomer()
}

func (n *NewsOffice) notifyAllCustomer() {
    for _, customer := range n.customers {
        customer.update()
    }
}

状态模式Golang

2020-12-03 设计模式

状态模式

在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式

优点和缺点

优点:

封装转换规则
枚举可能的状态,在枚举状态之前需要确定状态种类

缺点:

状态模式的使用必然会增加系统类和对象的个数

type State interface {
	Handle(context *Context)
}
type ConcreteStateA struct {
}

func (state *ConcreteStateA) Handle(context *Context) {
	fmt.Println("A current state")
	context.SetState(new(ConcreteStateA))
}

type ConcreteStateB struct {
}

func (state *ConcreteStateB) Handle(context *Context) {
	fmt.Println("B current state")
	context.SetState(new(ConcreteStateB))

}

type Context struct {
	state State
}

func (context *Context) Init() {
	context.state = new(ConcreteStateA)
}
func (context *Context) SetState(state State) {
	context.state = state
}
func (context *Context) GetState() State {
	return context.state
}
func (context *Context) Handle() {
	context.state.Handle(context)
}

命令模式Golang

2020-12-02 设计模式

命令模式

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式.
请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令.

优点和缺点

优点:

降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦.

缺点:

使用命令模式可能会导致某些系统有过多的具体命令类

type Stock struct {
	name     string
	quantity int
}

func (stock *Stock) Set(name string, quantity int) {
	stock.name = name
	stock.quantity = quantity
}

func (stock *Stock) Buy(s Stock) {
	stock.name = s.name
	stock.quantity = s.quantity
	fmt.Printf("Buy stock %s, quantity:%d \n", s.name, s.quantity)
}
func (stock Stock) Sell(s Stock) {
	stock.name = s.name
	stock.quantity = s.quantity
	fmt.Printf("Sell stock %s, quantity:%d \n", s.name, s.quantity)
}
type Order interface {
    Execute()
}
type BuyStock struct {
    stock Stock
}

func (buy BuyStock) Execute() {
    fmt.Println("execute in buy command")
    buy.stock.Buy(buy.stock)
}

type SellStock struct {
    stock Stock
}

func (sell SellStock) Execute() {
    fmt.Println("execute in sell command")
    sell.stock.Sell(sell.stock)
}

type Broker struct {
    order Order
}

func (broker *Broker) SetOrder(order Order) {
    fmt.Printf("set order:%v\n", order)
    broker.order = order
}
func (broker Broker) Call() {
    fmt.Println("call in broker")
    broker.order.Execute()
}

访问模式Golang

2020-12-01 设计模式

访问模式

访问模式(Visitor Pattern): 将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，
使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式.

优点和缺点

优点:

延展性好, 能够在不修改对象结构的元素的情况下, 为对象结构中的元素添加新的功能
灵活性好。访问者模式将数据结构与作用于结构上的操作解耦，使得操作集合可相对自由地演化而不影响系统的数据结构.

缺点:

违反了依赖倒置原则。访问者模式依赖了具体类，而没有依赖抽象类。

type Visitor interface {
	VisitA(a *ConcreteElementA)
	VisitB(b *ConcreteElementB)
}
type VisitorA struct {
}
type VisitorB struct {
}
type Element interface {
	Accept(visitor Visitor)
}

func (visotor VisitorA) VisitA(a *ConcreteElementA) {
	fmt.Println("Visitor A visit element a")
	a.OperationA()
}
func (visotor VisitorA) VisitB(b *ConcreteElementB) {
	fmt.Println("Visitor A visit element b")
	b.OperationB()
}

func (visotor VisitorB) VisitA(a *ConcreteElementA) {
	fmt.Println("Visitor B visit element a")
	a.OperationA()
}
func (visotor VisitorB) VisitB(b *ConcreteElementB) {
	fmt.Println("Visitor B visit element b")
	b.OperationB()
}

type ConcreteElementA struct {
}

func (e *ConcreteElementA) Accept(visitor Visitor) {
	visitor.VisitA(e)
}
func (e *ConcreteElementA) OperationA() {
	fmt.Println(" operation A")
}

type ConcreteElementB struct {
}

func (e *ConcreteElementB) Accept(visitor Visitor) {
	visitor.VisitB(e)
}
func (e *ConcreteElementB) OperationB() {
	fmt.Println(" operation B")
}

type ObjectStructure struct {
	elements []Element
}

func (o *ObjectStructure) Accept(visitor Visitor) {
	for _, v := range o.elements {
		v.Accept(visitor)
	}
}
func (o *ObjectStructure) Add(e Element) {
	if o.elements == nil {
		o.elements = []Element{}
	}
	o.elements = append(o.elements, e)
}
func (o *ObjectStructure) Remove(e Element) {
	if o.elements == nil {
		return
	}
	for i, v := range o.elements {
		if v == e {
			o.elements = append(o.elements[0:i], o.elements[i+1:]...)
		}
	}
}

模板方法Golang

2020-11-28 设计模式

模板方法

在模板模式（Template Pattern）中, 定义一个操作中的算法骨架，将算法的一些步骤延迟到子类中,
使得子类在可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
主要解决: 在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异

优点和缺点

优点:

封装不变部分, 扩展可变部分.
父类控制, 子类实现

缺点:

每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

type FPerson interface {
	SetName(name string)
	BeforeOut()
	Out()
}

type Person struct {
	Specific FPerson
	name     String
}

func (f *Person) SetName(name string) {
	p.name = name
}

func (p *Person) BeforeOut() {
    if p.Specific == nil {
        return
    }

    p.Specific.BeforeOut()
}

func (p *Person) Out() {
    p.BeforeOut()
    fmt.Println(p.name + " go out")
}

type Boy struct {
    Person
}

func (b *Boy) BeforeOut() {
    fmt.Println("boy")
}

type Girl struct {
    Person
}

func (g *Girl) BeforeOut() {
	fmt.Println("girl")
}

责任链模式 Golang

2020-11-21 设计模式

责任链模式

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。
这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。
应用实例: 消息过滤器, 权限拦截器

优点和缺点

优点

降低耦合度。它将请求的发送者和接收者解耦
增加新的请求处理类很方便
简化对象, 使的对象不需要知道的结构

缺点

不能保证请求一定被接受

type Handle interface {
    SetNext(next Handle)
    GetNext() Handle
    HandleRequest(request string)
}
type ConcreteHandle1 struct {
    next Handle
}

func (handle *ConcreteHandle1) SetNext(next Handle) {
    handle.next = next
}
func (handle *ConcreteHandle1) GetNext() Handle {
    return handle.next
}
func (handle *ConcreteHandle1) HandleRequest(request string) {
    if request == "one" {
        fmt.Println("1 response")
    } else {
    if handle.GetNext() != nil {
        handle.GetNext().HandleRequest(request)
    } else {
        fmt.Println("No one handle")
        }
    }
}

type ConcreteHandle2 struct {
    next Handle
}

func (handle *ConcreteHandle2) SetNext(next Handle) {
    handle.next = next
}

func (handle *ConcreteHandle2) GetNext() Handle {
    return handle.next
}
func (handle *ConcreteHandle2) HandleRequest(request string) {
    if request == "two" {
        fmt.Println("2 response")
    } else {
    if handle.GetNext() != nil {
        handle.GetNext().HandleRequest(request)
    } else {
        fmt.Println("No one handle")
        }
    }
}

组合模式Golang

2020-11-18 设计模式

组合模式

组合模式(Composite Pattern): 组合多个对象形成树形结构表示具有”整体一部分”关系的层次结构.
适用场景: 希望客户端可以忽略组合对象与单个对象的差异

优点和缺点

优点

清楚地定义分层次的复杂对象, 表示对象的全部或部分层次
简化客户端代码
节点自由增加

缺点

限制类型比较复杂

type IOrganization interface {
    Count() int
}

type Employee struct {
    Name string
}

func (Employee) Count() int {
    return 1
}

type Department struct {
    Name string

    SubOrganizations []IOrganization
}

func (d Department) Count() int {
    c := 0
    for _, org := range d.SubOrganizations {
        c += org.Count()
    }
    return c
}

func (d *Department) AddSub(org IOrganization) {
    d.SubOrganizations = append(d.SubOrganizations, org)
}

Noonde

Yunling Zhang

SARIMAX_01

1. 简介

迭代器模式Golang

迭代器模式

优点和缺点

解释器模式Golang

解释器模式

优点和缺点

观察模式Golang

观察模式

优点和缺点

状态模式Golang

状态模式

优点和缺点

命令模式Golang

命令模式

优点和缺点

访问模式Golang

访问模式

优点和缺点

模板方法Golang

模板方法

优点和缺点

责任链模式 Golang

责任链模式

优点和缺点

组合模式Golang

组合模式

优点和缺点

1. 简介

迭代器模式

优点 和 缺点

解释器模式

优点 和 缺点

观察模式

优点 和 缺点

状态模式

优点 和 缺点

命令模式

优点 和 缺点

访问模式

优点 和 缺点

模板方法

优点 和 缺点

责任链模式

优点 和 缺点

组合模式

优点 和 缺点

优点和缺点

优点和缺点

优点和缺点

优点和缺点

优点和缺点

优点和缺点

优点和缺点

优点和缺点

优点和缺点