27.3.平仓指令函数后用from指定平掉哪个信号的仓位。
有图有真相：
右键菜单【查看测评报告】的交易明细：
可见，Sell1与Buy1、Sell2与Buy2分别一一配对，这样我们就可分别控制不同的仓位。
再看一个早盘区间突破分批平仓日内交易策略，公式如下：
1. //-------金魔方智能交易公式--------------
2. //例4_2 早盘区间突破分批平仓策略
3. //用于5分钟周期
5. 1.根据上午10点前的价格波动范围画出最高价水平线
6. 2.下午14点前，价格突破区间高点买入2口
7. 3.跌破买入价以下20点清仓止损
8. 4.涨至买入价以上30点止盈其中1口
9. 5.当天若有亏损交易，不再开新仓
10.6.日内交易，收市前清仓
早盘终点时间(1000), //10:00
开仓结束时间(1400); //14:00
15.variable:
//趋势线标识号，赋初值-1
17.if Date && Date[1] then begin
//新交易日开始
ID := TL_new(Date,Time,RngH,Date,Time,RngH);
//新建画线
22.if Time & 早盘终点时间*100 then begin //上午10:00前的最高价作为区间高点
RngH := Max(High, RngH);
26.//随时间调整区间高点水平线
27.TL_SetBegin(ID, TL_GetBeginDate(ID), TL_GetBeginTime(ID), RngH);
28.TL_SetEnd(ID, Date, Time, RngH);
30.bTradeTime := Time &=
And Time & 开仓结束时间*100; //交易时间
31.if bTradeTime And DailyLosers(Date,0)&1 then //
Buy('', 2, RngH, -1, OT_STOP, OB_NEXTBAR, '买入');
33.if MarketPosition = 1 then
//若持多头仓
Sell('', DEFAULT, EntryPrice - 20, -1, OT_STOP, OB_NEXTBAR, '止损');
if CurrentContracts = 2 then
Sell('', 1, EntryPrice + 30, 0, OT_LIMIT, OB_NEXTBAR, '止盈');
38.SetExitOnC //收市前清仓
41.1.画线函数TL_New、TL_SetBegin、TL_SetEnd用于画出区间通道 42.2.5分钟周期，9:55 的下一个周期开始交易
金魔方以K线开始时间作为K线的时间
44.3.DailyLosers(Date,0)取得当日亏损交易次数
45.4.EntryPrice为开仓价，对多头开仓而言就是买入价
46.5.CurrentContracts取得当前持仓数量
有图有真相：
右键菜单【查看测评报告】的交易明细：
可见，开仓2口的单被拆成2笔，1笔止盈，1笔日内交易平仓。
从这个公式，我们可以看出它逐根计算的机制：在每天开盘的那根K线创建1条新的趋势线，然后随着下1根K线的不断增加，调整趋势线的起点和终点。 以上介绍了仓位控制的方法，金魔方还有哪些风险控制的技巧呢？
且听下回分解！
金魔方智能交易攻略（5）-指标背离交易及风险控制策略
作者：仁心慧能
缠论等交易理论重视指标背离时的交易信号，请看金魔方公式如何实现：
1. //-------金魔方智能交易公式--------------
2. //例5_1 指标背离买入风险控制策略
4. 1、RSI指标上穿25且与价格形成底背离时买入，不采用指标平仓，而是
5. 2、综合运用止盈、止损、保本平仓、跟踪止损、盘整平仓等风险控制技术
波谷强度(3),//用于找波谷并判断背离
止损价差(35),
止赢价差(100),
保本启动价差(20),
跟踪启动价差(30),
跟踪回撤价差(20),
跟踪回撤幅度(20),
盘整最大价差(5),
盘整周期数(5),
使用价差(1), //开关控制使用价差或金额参数
止损金额(10000),
止赢金额(30000),
保本启动金额(6000),
跟踪启动金额(9000),
跟踪回撤金额(6000);
//计算RSI指标
24.RSI1 : SMA(Max(C-C[1],0),8,1)/SMA(Abs(C-C[1]),8,1)*100, OwnerS
25.底背离: Divergence(C,RSI1,波谷强度,30,-1), LineThick0; 26.
27.//若指标与价格走势发生牛背离，则在指标上穿25时买入
28.if 底背离 and CrossOver(RSI1,25) then B
30.if 使用价差 = 1 then begin
//以下风控金额基于单口计算
if 止损价差 & 0 then
SetStopLoss(止损价差*BigPointValue);
if 止赢价差 & 0 then
SetProfitTarget(止赢价差*BigPointValue);
if 保本启动价差 & 0 then
SetBreakEven(保本启动价差*BigPointValue);
if 跟踪启动价差 & 0 And 跟踪回撤价差 & 0 then
SetDollarTrailing(跟踪回撤价差*BigPointValue,跟踪启动价差*BigPointValue);
if 跟踪启动价差 & 0 And 跟踪回撤幅度 & 0 then
SetPercentTrailing(跟踪启动价差*BigPointValue,跟踪回撤幅度);
if 盘整最大价差 & 0 And 盘整周期数 & 0 then
SetInactive(盘整最大价差*BigPointValue,盘整周期数);
45.else begin
//整个仓位的止损止盈金额
if 止损金额 & 0 then
SetStopLoss(止损金额);
if 止赢金额 & 0 then
SetProfitTarget(止赢金额);
if 保本启动金额 & 0 then
SetBreakEven(保本启动金额);
if 跟踪启动金额 & 0 And 跟踪回撤金额 & 0 then
SetDollarTrailing(跟踪回撤金额,跟踪启动金额);
if 跟踪启动金额 & 0 And 跟踪回撤幅度 & 0 then
SetPercentTrailing(跟踪启动金额,跟踪回撤幅度);
60.1.OwnerScale修饰符可以使RSI指标叠加在主图上
61.2.LineThick0修饰符用于查看底背离状态而不画出指标线 62.3.Divergence函数可用于判断指标与价格走势的背离，
波谷点是前后各N个周期的相对低点，这个N即为波谷强度&&/&&&&/&&&&/&&
Swift基础教程
Swift语言参考
与Cocoa和Objective-C混合编程
Swift闭包详解
闭包是功能性自包含模块，可以在代码中被传递和使用。&Swift&中的闭包与&C&和&Objective-C中的&blocks&以及其他一些编程语言中的&lambdas&比较相似。
闭包可以&捕获&和存储其所在上下文中任意常量和变量的引用。 这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift会为您管理在&捕获&过程中涉及到的内存操作。
注意：如果您不熟悉&捕获&(capturing) 这个概念也不用担心，后面会详细对其进行介绍。
在章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
全局函数是一个有名字但不会捕获任何值的闭包
嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的没有名字的闭包
Swift的闭包表达式拥有简洁的风格，并鼓励在常见场景中以实现语法优化，主要优化如下：
利用上下文推断参数和返回值类型
单表达式（single-expression）闭包可以省略&return&关键字
参数名称简写
Trailing 闭包语法
闭包表达式
嵌套函数是一种在较复杂函数中方便进行命名和定义自包含代码模块的方式。 当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在处理一些函数并需要将另外一些函数作为该函数的参数时。
闭包表达式是一种利用简洁语法构建内联闭包的方式。 闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。 下面闭包表达式的例子通过使用几次迭代展示了&sort&函数定义和语法优化的方式。 每一次迭代都用更简洁的方式描述了相同的功能。
Swift 标准库提供了&sort&函数，会根据您提供的排序闭包将已知类型数组中的值进行排序。 一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。
下面的闭包表达式示例使用&sort&函数对一个&String&类型的数组进行字母逆序排序，以下是初始数组值：
let names = [&Chris&, &Alex&, &Ewa&, &Barry&, &Daniella&]
排序函数有两个参数：
已知类型值的数组。
一个闭包，采用相同类型的数组的内容的两个参数，并返回一个布尔值来表示是否将第一个值在排序时放到第二个值的前面或是后面。如果第一个值应该出现第二个值之前，闭包需要返回true，否则返回false。
该例子对一个&String&类型的数组进行排序，因此排序闭包需为&(String, String) -& Bool&类型的函数。
提供排序闭包的一种方式是撰写一个符合其类型要求的普通函数，并将其作为&sort&函数的第二个参数传入：
func backwards(s1: String, s2: String) -& Bool {
return s1 & s2
var reversed = sort(names, backwards)
// reversed is equal to [&Ewa&, &Daniella&, &Chris&, &Barry&, &Alex&]
如果第一个字符串 (s1) 大于第二个字符串 (s2)，backwards&函数则返回&true，表示在新的数组中&s1&应该出现在&s2&前。 字符中的 &大于& 表示 &按照字母顺序后出现&。 这意味着字母 &B& 大于字母 &A&, 字符串 &Tom& 大于字符串 &Tim&。 其将进行字母逆序排序，&Barry& 将会排在 &Alex& 之后,一次类推。
然而，这是一个相当冗长的方式，本质上只是写了一个单表达式函数 (a & b)。 在下面的例子中，利用闭合表达式语法可以更好的构造一个内联排序闭包。
闭包表达式语法
闭包表达式语法有如下一般形式：
{ (parameters) -& returnType in
statements
闭包表达式语法可以使用常量、变量和&inout&类型作为参数，但不提供默认值。 也可以在参数列表的最后使用可变参数。元组也可以作为参数和返回值。
下面的例子展示了之前&backwards&函数对应的闭包表达式版本的代码：
reversed = sort(names, { (s1: String, s2: String) -& Bool in
return s1 & s2
需要注意的是内联闭包参数和返回值类型声明与&backwards&函数类型声明相同。 在这两种方式中，都写成了 (s1: String, s2: String) -& Bool类型。 然而在内联闭包表达式中，函数和返回值类型都写在大括号内，而不是大括号外。
闭包的函数体部分由关键字&in&引入。 该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。
因为这个闭包的函数体部分如此短以至于可以将其改写成一行代码：
reversed = sort(names, { (s1: String, s2: String) -& Bool in return s1 & s2 } )
这说明&sort&函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包 (相比于&backwards&版本的代码)。
根据上下文推断类型
因为排序闭包是作为函数的参数进行传入的，Swift可以推断其参数和返回值的类型。&sort&期望第二个参数是类型为&(String, String) -& Bool&的函数，因此实际上&String,&String&和&Bool&类型并不需要作为闭包表达式定义中的一部分。 因为所有的类型都可以被正确推断，返回箭头 (-&) 和 围绕在参数周围的括号也可以被省略：
reversed = sort(names, { s1, s2 in return s1 & s2 } )
实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。
然而，你也可以使用明确的类型，如果你想它避免读者阅读可能存在的歧义，这样还是值得鼓励的。这个排序函数例子，闭包的目的是很明确的，即排序被替换，而且对读者来说可以安全的假设闭包可能会使用字符串值,因为它正协助一个字符串数组进行排序。
单行表达式闭包可以省略&return
单行表达式闭包可以通过隐藏&return&关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：
reversed = sort(names, { s1, s2 in s1 & s2 } )
在这个例子中，sort&函数的第二个参数函数类型明确了闭包必须返回一个&Bool&类型值。 因为闭包函数体只包含了一个单一表达式 (s1 & s2)，该表达式返回&Bool&类型值，因此这里没有歧义，return关键字可以省略。
参数名简写
Swift&自动为内联函数提供了参数名称简写功能，您可以直接通过&$0,$1,$2等名字来引用的闭包的参数的值。
如果您在闭包表达式中使用参数名称简写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称简写的类型会通过函数类型进行推断。&in&关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成：
reversed = sort(names, { $0 & $1 } )
在这个例子中，$0&和&$1&表示闭包中第一个和第二个&String&类型的参数。
运算符函数
实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。&Swift的&String&类型定义了关于大于号 (&) 的字符串实现，让其作为一个函数接受两个&String&类型的参数并返回&Bool&类型的值。 而这正好与&sort&函数的第二个参数需要的函数类型相符合。 因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现：
reversed = sort(names, &)
更多关于运算符表达式的内容请查看&&。
Trailing 闭包
如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用 trailing 闭包来增强函数的可读性。
Trailing 闭包是一个书写在函数括号之外(之后)的闭包表达式，函数支持将其作为最后一个参数调用。
func someFunctionThatTakesAClosure(closure: () -& ()) {
// 函数体部分
// 以下是不使用 trailing 闭包进行函数调用
someFunctionThatTakesAClosure({
// 闭包主体部分
// 以下是使用 trailing 闭包进行函数调用
someFunctionThatTakesAClosure() {
// 闭包主体部分
注意：如果函数只需要闭包表达式一个参数，当您使用 trailing 闭包时，您甚至可以把 () 省略掉。 NOTE
在上例中作为&sort&函数参数的字符串排序闭包可以改写为：
reversed = sort(names) { $0 & $1 }
当闭包非常长以至于不能在一行中进行书写时，Trailing 闭包就变得非常有用。 举例来说，Swift&的&Array&类型有一个&map&方法，其获取一个闭包表达式作为其唯一参数。 数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值(也可以是不同类型的值)。 具体的映射方式和返回值类型由闭包来指定。
当提供给数组闭包函数后，map&方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。
下例介绍了如何在&map&方法中使用 trailing 闭包将&Int&类型数组&[16,58,510]&转换为包含对应&String&类型的数组&[&OneSix&, &FiveEight&, &FiveOneZero&]:
let digitNames = [
0: &Zero&, 1: &One&, 2: &Two&, 3: &Three&, 4: &Four&,
5: &Five&, 6: &Six&, 7: &Seven&, 8: &Eight&, 9: &Nine&
let numbers = [16, 58, 510]
上面的代码创建了整数数字到他们的英文名字之间映射字典。 同时定义了一个准备转换为字符串的整型数组。
您现在可以通过传递一个 trailing 闭包给&numbers&的&map&方法来创建对应的字符串版本数组。 需要注意的时调用&numbers.map不需要在&map&后面包含任何括号，因为只需要传递闭包表达式这一个参数，并且该闭包表达式参数通过 trailing 方式进行撰写：
let strings = numbers.map {
(var number) -& String in
var output = &&
while number & 0 {
output = digitNames[number % 10]! + output
number /= 10
return output
// strings 常量被推断为字符串类型数组，即 String[]
// 其值为 [&OneSix&, &FiveEight&, &FiveOneZero&]
map&在数组中为每一个元素调用了闭包表达式。 您不需要指定闭包的输入参数&number&的类型，因为可以通过要映射的数组类型进行推断。
闭包&number&参数被声明为一个变量参数 (变量的具体描述请参看)，因此可以在闭包函数体内对其进行修改。 闭包表达式制定了返回值类型为&String，以表明存储映射值的新数组类型为&String。
闭包表达式在每次被调用的时候创建了一个字符串并返回。 其使用求余运算符&(number % 10)&计算最后一位数字并利用digitNames&字典获取所映射的字符串。
注意：字典&digitNames&下标后跟着一个叹号 (!)，因为字典下标返回一个可选值 (optional value)，表明即使该&key不存在也不会查找失败。 在上例中，它保证了&number % 10&可以总是作为一个&digitNames&字典的有效下标&key。 因此叹号可以用于强展开&(force-unwrap)&存储在可选下标项中的&String&类型值。
从&digitNames&字典中获取的字符串被添加到输出的前部，逆序建立了一个字符串版本的数字。 (在表达式&number % 10中，如果number为16，则返回6，58返回8，510返回0)。
number&变量之后除以10。 因为其是整数，在计算过程中未除尽部分被忽略。 因此 16变成了1，58变成了5，510变成了51。
整个过程重复进行，直到&number /= 10&为0，这时闭包会将字符串输出，而map函数则会将字符串添加到所映射的数组中。
上例中 trailing 闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在&map&函数的括号内。
捕获 (Caputure)
闭包可以在其定义的上下文中捕获常量或变量。 即使定义这些常量和变量的原作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数体内的函数。 嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
下例为一个叫做&makeIncrementor&的函数，其包含了一个叫做&incrementor&嵌套函数。 嵌套函数&incrementor&从上下文中捕获了两个值，runningTotal&和&amount。 之后&makeIncrementor&将&incrementor&作为闭包返回。 每次调用&incrementor&时，其会以&amount&作为增量增加&runningTotal&的值。
func makeIncrementor(forIncrement amount: Int) -& () -& Int {
var runningTotal = 0
func incrementor() -& Int {
runningTotal += amount
return runningTotal
return incrementor
makeIncrementor&返回类型为&() -& Int。 这意味着其返回的是一个函数，而不是一个简单类型值。 该函数在每次调用时不接受参数只返回一个&Int&类型的值。 关于函数返回其他函数的内容，请查看。
makeIncrementor&函数定义了一个整型变量&runningTotal&(初始为0) 用来存储当前增加总数。 该值通过&incrementor&返回。
makeIncrementor&有一个&Int&类型的参数，其外部命名为&forIncrement， 内部命名为&amount，表示每次&incrementor&被调用时runningTotal&将要增加的量。
incrementor&函数用来执行实际的增加操作。 该函数简单地使&runningTotal&增加&amount，并将其返回。
如果我们单独看这个函数，会发现看上去不同寻常：
func incrementor() -& Int {
runningTotal += amount
return runningTotal
incrementor&函数并没有获取任何参数，但是在函数体内访问了&runningTotal&和&amount&变量。这是因为其通过捕获在包含它的函数体内已经存在的&runningTotal&和&amount&变量而实现。
由于没有修改&amount&变量，incrementor&实际上捕获并存储了该变量的一个副本，而该副本随着&incrementor&一同被存储。
然而，因为每次调用该函数的时候都会修改&runningTotal&的值，incrementor&捕获了当前&runningTotal&变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当&makeIncrementor&结束时候并不会消失，也保证了当下一次执行&incrementor&函数时，runningTotal&可以继续增加。
注意：Swift&会决定捕获引用还是拷贝值。 您不需要标注&amount&或者&runningTotal&来声明在嵌入的&incrementor&函数中的使用方式。&Swift&同时也处理&runingTotal&变量的内存管理操作，如果不再被&incrementor&函数使用，则会被清除。
下面为一个使用&makeIncrementor&的例子：
let incrementByTen = makeIncrementor(forIncrement: 10)
该例子定义了一个叫做&incrementByTen&的常量，该常量指向一个每次调用会加10的&incrementor&函数。 调用这个函数多次可以得到以下结果：
incrementByTen()
// 返回的值为10
incrementByTen()
// 返回的值为20
incrementByTen()
// 返回的值为30
如果您创建了另一个&incrementor，其会有一个属于自己的独立的&runningTotal&变量的引用。 下面的例子中，incrementBySevne&捕获了一个新的&runningTotal&变量，该变量和&incrementByTen&中捕获的变量没有任何联系：
let incrementBySeven = makeIncrementor(forIncrement: 7)
incrementBySeven()
// 返回的值为7
incrementByTen()
// 返回的值为40
注意：如果您闭包分配给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。&Swift&使用捕获列表来打破这种强引用环。更多信息，请参考&。
闭包是引用类型
上面的例子中，incrementBySeven&和&incrementByTen&是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。 这是因为函数和闭包都是引用类型。
无论您将函数/闭包赋值给一个常量还是变量，您实际上都是将常量/变量的值设置为对应函数/闭包的引用。 上面的例子中，incrementByTen&指向闭包的引用是一个常量，而并非闭包内容本身。
这也意味着如果您将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包：
let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()
// 返回的值为50交易开拓者代码学习各种买卖指令及实例&（TB）
各种买卖指令
说明 产生一个多头建仓操作。&
语法 Buy(Numeric Share=0,Numeric Price=0,Bool
Delay=False)&
参数 Share 买入数量，为整型值，默认为使用系统设置参数；
Price 买入价格，为浮点数，默认=0时为使用现价(非最后Bar为Close)；
买入动作是否延迟，默认为当前Bar发送委托，当Delay=True，在下一个Bar执行。&
备注 产生一个多头建仓操作，无返回值，该函数仅支持交易指令。
该函数仅用于多头建仓，其处理规则如下：
如果当前持仓状态为持平，即MarketPosition = 0 时，该函数按照参数进行多头建仓。
如果当前持仓状态为空仓，即MarketPosition = -1
时，该函数首先平掉所有空仓，达到持平的状态，然后再按照参数进行多头建仓。
如果当前持仓状态为多仓，即MarketPosition = 1
时，该函数将继续建仓，但具体是否能够成功建仓要取决于系统中关于连续建仓的设置，以及资金，最大持仓量等限制。
示例 在MarketPosition=0的情况下：
Buy(50,10.2,1) 表示用10.2的价格买入50张合约，延迟到下一个Bar发送委托。
Buy(10,Close) 表示用当前Bar收盘价买入10张合约，马上发送委托。
Buy(5,0) 表示用现价买入5张合约，马上发送委托。 &
BuyToCover
说明 产生一个空头平仓操作。&
语法 BuyToCover(Numeric Share=0,Numeric Price=0,Bool
Delay=False)&
参数 Share 买入数量，为整型值，默认为平掉当前所有持仓；
Price 买入价格，为浮点数，默认=0时为使用现价(非最后Bar为Close)；
买入动作是否延迟，默认为当前Bar发送委托，当Delay=True,在下一个Bar执行。&
备注 产生一个空头平仓操作，无返回值，该函数仅支持交易指令。
该函数仅用于空头平仓，其处理规则如下：
如果当前持仓状态为持平，即MarketPosition = 0 时，该函数不执行任何操作。
如果当前持仓状态为多仓，即MarketPosition = 1 时，该函数不执行任何操作。
如果当前持仓状态为空仓，即MarketPosition = -1
时，如果此时Share使用默认值，该函数将平掉所有空仓，达到持平的状态，否则只平掉参数Share的空仓。&
示例 在MarketPosition = -1的情况下：
BuyToCover(50,10.2,1) 表示用10.2的价格空头买入50张合约，延迟到下一个Bar发送委托。
BuyToCover(10,Close) 表示用当前Bar收盘价空头买入10张合约，马上发送委托。
BuyToCover(5,0) 表示用现价空头买入5张合约)，马上发送委托。
说明 产生一个多头平仓操作。 (BK)
语法 Sell(Numeric Share=0,Numeric Price=0,Bool
Delay=False)&
参数 Share 卖出数量，为整型值，默认为平掉当前所有持仓；
Price 卖出价格，为浮点数，默认=0时为使用现价(非最后Bar为Close)；
卖出动作是否延迟，默认为当前Bar发送委托，当Delay=True，在下一个Bar执行。&
备注 产生一个多头平仓操作，无返回值，该函数仅支持交易指令。
该函数仅用于多头平仓，其处理规则如下：
如果当前持仓状态为持平，即MarketPosition = 0 时，该函数不执行任何操作。
如果当前持仓状态为空仓，即MarketPosition = -1 时，该函数不执行任何操作。
如果当前持仓状态为多仓，即MarketPosition = 1
时，如果此时Share使用默认值，该函数将平掉所有多仓，达到持平的状态，否则只平掉参数Share的多仓。
示例 在MarketPosition=0的情况下：
Sell(50,10.2,1) 表示用10.2的价格卖出50张合约，延迟到下一个Bar发送委托。
Sell(10,Close) 表示用当前Bar收盘价卖出10张合约，马上发送委托。
Sell(5,0) 表示用现价卖出5张合约，马上发送委托。 &
说明 产生一个空头建仓操作。&
语法 SellShort(Numeric Share=0,Numeric Price=0,Bool
Delay=False)&
参数 Share 卖出数量，为整型值，默认为使用系统设置参数；
Price 卖出价格，为浮点数，默认=0时为使用现价(非最后Bar为Close)；
卖出动作是否延迟，默认为当前Bar发送委托，当Delay=True，在下一个Bar执行。&
备注 产生一个空头建仓操作，无返回值，该函数仅支持交易指令。
该函数仅用于空头建仓，其处理规则如下：
如果当前持仓状态为持平，即MarketPosition = 0 时，该函数按照参数进行空头建仓。
如果当前持仓状态为多仓，即MarketPosition = 1
时，该函数首先平掉所有多仓，达到持平的状态，然后再按照参数进行空头建仓。
如果当前持仓状态为空仓，即MarketPosition = -1
时，该函数将继续建仓，但具体是否能够成功建仓要取决于系统中关于连续建仓的设置，以及资金，最大持仓量等限制。
示例 在MarketPosition=0的情况下：
SellShort(50,10.2,1) 表示用10.2的价格空头卖出50张合约，延迟到下一个Bar发送委托。
SellShort(10,Close) 表示用当前Bar收盘价空头卖出10张合约，马上发送委托。
SellShort(5,0) 表示用现价空头卖出5张合约，马上发送委托。
对应的BPK,SPK,你清楚了吗
函数名 描述 &
Buy 平掉所有空头持仓，开多头仓位。(*BPK*)&
Sell 平掉指定的多头持仓。&
SellShort 平掉所有多头持仓，开空头仓位。 (*SPK*)
BuyToCover 平掉指定的空头持仓。
获得当前持仓状态,太妙了
MarketPosition
说明 获得当前持仓状态。&
语法 Integer MarketPosition()&
备注 获得当前持仓状态，返回值为整型，该函数仅支持交易指令。
返回值定义如下：
-1 当前位置为持空仓
0 当前位置为持平
1 当前位置为持多仓&
内建平仓指令--精华之特色
内建平仓指令
除了上节的Sell和BuyToCover可以进行平仓之外，TradeBlazer公式提供了额外的八种平仓函数，通过合理的应用内建平仓函数，可以帮助您有效的锁定风险并及时获利。
您可以组合使用内建平仓函数，也可以在自己的交易指令中调用内建平仓函数进行平仓，八个内建平仓函数如下:
函数名 描述 &
SetExitOnClose
该平仓函数用来在当日收盘后产生一个平仓动作，将当前所有的持仓按当日收盘价全部平掉。&
SetBreakEven
该平仓函数在获利条件满足的情况下启动，当盈利回落达到保本时产生平仓动作，平掉指定的仓位。&
SetStopLoss
该平仓函数在亏损达到设定条件时产生平仓动作，平掉指定的仓位。&
SetProfitTarget
该平仓函数在盈利达到设定条件时产生平仓动作，平掉指定的仓位。&
SetPeriodTrailing
该平仓函数在盈利回落到设定条件时产生平仓动作，平掉指定的仓位。&
SetPercentTrailing
&该平仓函数在盈利回落到设定条件时产生平仓动作，平掉指定的仓位。&
SetDollarTrailing
该平仓函数在盈利回落到设定条件时产生平仓动作，平掉指定的仓位。&
SetInactivate
该平仓函数在设定时间内行情一直在某个幅度内波动时产生平仓动作，平掉指定的仓位。&
关于ExitPosition
上述多个平仓函数都用到了参数ExitPosition，作为平仓函数仓位控制的重要参数，有必要对该参数进行单独说明。
ExitPosition是布尔型参数，当ExitPosition=True时，表示将当前所有的持仓作为一个整体，根据其平均建仓成本，计算各平仓函数的盈亏，当条件满足时，会将所有仓位一起平掉；当ExitPosition=False时，表示单独对每个建仓位置进行平仓，单独计算各平仓函数盈亏时，当单个建仓位置条件满足后，平掉该建仓位置即可。
触发单是交易开拓者特有的交易方式，触发单是指用户设置条件，将触发单提交到交易开拓者的交易服务器，当设定条件满足情况，交易服务器会自动发送委托到交易所。触发单可以帮助解决用户盯盘的辛苦，及手动发单的速度问题。
触发单分为以下四种类型：吊买、吊卖、追买、追卖。
每个触发单在发送时需要输入以下参数：
触发价格：触发单设定的条件价格，通过比较现价和触发价格确定是否下单。下单之后，该触发单会从交易服务器中删除；
执行价格：条件满足之后，发送委托的价格，设定为0可自动获取当时的叫买/卖价；
过期时间：设定触发单的过期时间，到这个时间还没有触发的订单会被设为过期，不再进行监控。
吊买是指当现价向下跌破触发价格，即按执行价格产生一个即时买入委托单，如下图所示：吊卖
吊卖是指当现价向上突破触发价格，即按执行价格产生一个即时卖出委托单，如下图所示：追买
追买是指当现价向上突破触发价格，即按执行价格产生一个即时买入委托单，如下图所示：追卖
追卖是指当现价向下跌破触发价格，即按执行价格产生一个即时卖出委托单，如下图所示：
修改或删除触发单
当存在某个商品的触发单，可通过双击帐户管理的触发单页面的项目，打开交易师，进行修改或删除操作。您可以修改数量、触发单类型、触发价格、执行价格、过期时间及止损获利等，完成修改之后，点击[修改]按钮即可完成修改；您可以直接点击[删除]按钮将该触发单删除。
注意: 触发单在发送之后将会生效，该委托单在服务器上运行，此时您关闭程序或电脑不会影响触发单的执行。
SetPercentTrailing(,True); 又是一个宝
SetPercentTrailing(,True);
当前所有持仓盈利在大于2000之后回落，当回落百分比达到20%之后，执行所有持仓位置的百分比回落平仓。（此时是计算所有持仓的盈利数）
SetPercentTrailing(,False);
当前持仓的某一个建仓位置的盈利大于1000之后回落，当回落百分比达到10%之后，执行该持仓位置的百分比回落平仓。（此时只计算该持仓位置的盈利）
SetStopLoss(0,2000,True);
当前所有持仓亏损达到2000之后，执行所有持仓位置的止损平仓。（此时是计算所有持仓的亏损数）
SetStopLoss(1,50, False);
当前持仓的某一个建仓位置每张合约的亏损达到50之后，执行该持仓位置的止损平仓。（此时只计算该持仓位置的每张合约亏损）
SetBreakEven(0,2000,True);
当前所有持仓的盈利达到2000之后，启动所有持仓位置的保本平仓。（此时是计算所有持仓的盈利数）
SetBreakEven(1,50, False);
当前持仓的某一个建仓位置每张合约的盈利达到50之后，启动该持仓位置的保本平仓。（此时只计算该持仓位置的每张约的盈利）
精华中精华文华所没有实现复杂策略工具一
循环语句包括两种表达方式：For和While。
For语句是一个循环语句，重复执行某项操作，直到循环结束。
语法如下：
For 循环变量 = 初始值 To 结束值
TradeBlazer公式语句;
循环变量为在之前已经定义的一个数值型变量，For循环的执行是从循环变量从初始值到结束值，按照步长为1递增，依次执行TradeBlazer公式语句。结束值必须大于或等于初始值才有意义，初始值和结束值可以使用浮点数，但是在执行过程中会被直接取整。只计算其整数部分。
TradeBlazer公式语句是一些语句的组合，如果TradeBlazer公式语句是单条，您可以省略{}，二条或者二条以上的语句必须使用{}。
第一次执行时，首先将循环变量赋值为初始值，然后判断循环变量是否小于等于结束值，如果满足条件，则执行TradeBlazer公式语句，同时循环变量加1。接着重新判断循环变量是否小于等于结束值，一直到条件为False，退出循环。
例如，以下的用户计算Price最近Length周期的和。
NumericSeries Price(1);
& & Numeric
Length(10);
& & Numeric
SumValue(0);
& & Numeric
& & for i = 0
to Length - 1
& & SumValue =
SumValue + Price[ i ];
& & Return
如果希望For语句从大到小进行循环，可以使用以下的语法：
For 循环变量 = 初始值 DownTo 结束值
TradeBlazer公式语句;
For-DownTo让循环变量从结束值每次递减1直到等于结束值，依次调用TradeBlazer公式语句执行，初始值必须大于或等于结束值才有意义。
For语句是比较常用的一种循环控制语句，它应用于知道循环次数的地方，很多内建用户函数中都使用For语句来完成相应的功能，比如Summation，Highest，Lowest，LinearReg等。
While语句在条件为真的时候重复执行某一项操作。即，只要条件表达式的值为真(True)时，就重复执行某个动作。直到行情信息改变以致条件为假(False)时，循环才结束。
语法如下：
While (Condition)
TradeBlazer公式语句;
Condition是一个逻辑表达式，当Condition为True的时候，TradeBlazer公式语句将会被循环执行，Condition可以是多个条件表达式的逻辑组合，Condition必须用()括起来。
TradeBlazer公式语句是一些语句的组合，如果TradeBlazer公式语句是单条，您可以省略{}，二条或者二条以上的语句必须使用{}。
例如，以下的公式用来计算要产生大于100000成交量需要最近Bar的个数：
& & Numeric
&SumVolume(0);
& & Numeric
& &Counter
(SumVolume & 100000)
& & SumVolume =
SumVolume + Vol[Counter]
& & Counter =
Counter + 1;
首先，我们定义两个变量SumVolume和Counter，并将其默认值设为0。当SumVolume
&100000这个表达式为True时，While内的TradeBlazer公式语句一直被调用，将前Counter个Bar的Vol加到SumVolume中，当SumVolume大于等于100000时，退出循环。
在使用While循环的时候，有可能会遇到循环一直执行，永远不能退出的情况，这种情况我们称之为死循环，比如下面的语句；
While (True)
TradeBlazer公式语句;
在这种情况下，循环将一直执行，导致程序不能继续工作，在这种情况，我们可以使用Break来跳出循环，详细情况参加下节。
针对上节的例子，要想从死循环中跳出，我们可以在循环之中添加Break语句，如下：
While (True)
TradeBlazer公式语句;
(Condition)
循环在每次执行后，都将判断Condition的值，当Condition为True时，则执行Break语句，跳出整个循环。
有的时候在循环中，我们可能希望跳过后面的代码，进入下一次循环，在这种情况下，可以使用Continue语句来达到目的，如下：
While (Condition1)
TradeBlazer公式语句1;
(Condition2)
TradeBlazer公式语句2;
当Condition1满足时，循环被执行，在执行完TradeBlazer公式语句1后，将判断Condition2的值，当Condition2为True，将跳过TradeBlazer公式语句2，重新判断Condition1的值，进入下一次循环。否则将继续执行TradeBlazer公式语句2。
精华中精华文华所没有实现复杂策略工具二
TradeBlazer公式支持两大类的控制语句：条件语句和循环语句。
条件语句包括以下四类表达方式：
If语句是一个条件语句，当特定的条件满足后执行一部分操作。
语法如下：
If (Condition)
TradeBlazer公式语句;
Condition是一个逻辑表达式，当Condition为True的时候，TradeBlazer公式语句将会被执行，Condition可以是多个条件表达式的逻辑组合，Condition必须用()括起来。
TradeBlazer公式语句是一些语句的组合，如果TradeBlazer公式语句是单条，您可以省略{}，二条或者二条以上的语句必须使用{}。
例如，您可以计算图表中上升缺口（当前Bar的开盘价高于上一个Bar的最高价）出现了多少次，只要在图表中使用If语句，当找到一个满足条件的Bar时，即条件为真时，变量加1，脚本如下：
NumericSeries Counter(0);
& & If ( Open
& High[1])
& & Counter =
Counter[1] + 1;
在TradeBlazer公式中，If语句被广泛使用，如K线型态和特征走势，都需要大量的使用If语句，当条件满足的时候，在满足条件的Bar上面进行标记。例如，下面的语句就是特征走势的例子：
If(High & High[1] AND Low & Low[1])
PlotNumeric(High,"Outside Bar");
If语句在不是用括号的情况，只执行下面的第一条语句，如下的语句，Alert不会只在条件为True时执行，而是每次都执行。
If(High & High[1] AND Low & Low[1])
PlotNumeric(High,"Outside Bar");
Alert("Outside Bar");
要想Alert只在条件为True时执行，您需要按照下面的格式编写：
If(High & High[1] AND Low & Low[1])
PlotNumeric(High,"Outside Bar");
Alert("Outside Bar");
If-Else语句是对指定条件进行判断，如果条件满足执行If后的语句。否则执行Else后面的语句。
语法如下：
If (Condition)
TradeBlazer公式语句1;
TradeBlazer公式语句2;
Condition是一个逻辑表达式，当Condition为True的时候，TradeBlazer公式语句1将会被执行；Condition为False时，TradeBlazer公式语句2将会被执行。Condition可以是多个条件表达式的逻辑组合，Condition必须用()括起来。
TradeBlazer公式语句是一些语句的组合，如果TradeBlazer公式语句是单条，您可以省略{}，二条或者二条以上的语句必须使用{}。
例如，比较当前Bar和上一个Bar的收盘价，如果Close & Close[1]，Value1 = Value1 +
Vol；否则Value1 = Value1 - Vol，脚本如下：
If (Colse & Close[1])
& & Value1 =
Value1 + V
& & Value1 =
Value1 - V
If-Else-If
If-Else-If是在If-Else的基础上进行扩展，支持条件的多重分支。
语法如下：
If (Condition1)
TradeBlazer公式语句1;
}Else If(Condition2)
TradeBlazer公式语句2;
TradeBlazer公式语句3;
Condition1是一个逻辑表达式，当Condition1为True的时候，TradeBlazer公式语句1将会被执行，Condition1为False时，将会继续判断Condition2的值，当Condition2为True时，TradeBlazer公式语句2将会被执行。Condition2为False时，TradeBlazer公式语句3将会被执行。Condition1，Condition2可以是多个条件表达式的逻辑组合，条件表达式必须用()括起来。
TradeBlazer公式语句是一些语句的组合，如果TradeBlazer公式语句是单条，您可以省略{}，二条或者二条以上的语句必须使用{}。
If-Else-If的语句可以根据需要一直扩展，在最后的Else之后再加If(Condition)和新的执行代码即可。当然您也可以省略最后的Else分支，语法如下：
If (Condition1)
TradeBlazer公式语句1;
}Else If(Condition2)
TradeBlazer公式语句2;
If-Else的嵌套
If-Else的嵌套是在If-Else的执行语句中包含新的条件语句，即一个条件被包含在另一个条件中。
语法如下：
If (Condition1)
(Condition2)
TradeBlazer公式语句1;
TradeBlazer公式语句2;
(Condition3)
TradeBlazer公式语句3;
TradeBlazer公式语句4;
Condition1是一个逻辑表达式，当Condition1为True的时候，将会继续判断Condition2的值，当Condition2为True时，TradeBlazer公式语句1将会被执行。Condition2为False时，TradeBlazer公式语句2将会被执行。当Condition1为False的时候，将会继续判断Condition3的值，当Condition3为True时，TradeBlazer公式语句3将会被执行。Condition3为False时，TradeBlazer公式语句4将会被执行。Condition1，Condition2，Condition3可以是多个条件表达式的逻辑组合，条件表达式必须用()括起来。
TradeBlazer公式语句是一些语句的组合，如果TradeBlazer公式语句是单条，您可以省略{}，二条或者二条以上的语句必须使用{}。
例如，在一个交易指令中，条件设置如下：当前行情上涨的时候，如果收盘价高于开盘价时，则产生一个以收盘价买入1张合约；否则产生一个以开盘价买入1张合约。当前行情没有上涨的时候，如果收盘价高于开盘价，则产生一个以收盘价卖出1张合约；否则产生一个以开盘价卖出1张合约。脚本如下：
If (Open & High[1])
(Close&Open)
Buy(1,Open);
Buy(1,Close);
& & If (Close
Sell(1,Open);
(1,Close);
接平仓东东
SetDollarTrailing (2000,True);
当前所有持仓盈利在回落达到2000之后，执行所有持仓位置的价值回落平仓。（此时是计算所有持仓的盈利数）
SetDollarTrailing (1000,False);
当前持仓的某一个建仓位置的盈利在回落达到1000之后，执行该持仓位置的价值回落平仓。（此时只计算该持仓位置的盈利）
说明 当日收盘全部平仓。&
语法 SetExitOnClose()&
备注 当日收盘全部平仓，无返回值，该函数仅支持交易指令。
在当日收盘之后以收盘价全部平仓，将持仓状态变为持平，该函数仅用于历史数据测试，在小于1日线的周期情况下，该操作在建仓日期的最后一个Bar上执行，在1日线及以上的周期中，该操作以建仓Bar的收盘价在同一Bar内执行。在自动交易中因为收盘之后不一定能够保证成功发送委托，所以该函数延迟到第二天的开盘发送。
PositionProfit
说明 获得当前持仓位置的浮动盈亏。&
语法 Numeric PositionProfit()&
备注 获得当前持仓位置的浮动盈亏，已考虑交易费用，返回值为浮点数，该函数仅支持交易指令。
只有当MarketPosition != 0时，即有持仓的状况下，该函数才有意义，否则返回0。
当前持仓的平均建仓价格
说明 获得当前持仓的平均建仓价格。&
语法 Numeric AvgEntryPrice()&
获得当前持仓的平均建仓价格，返回值为浮点数，该函数仅支持交易指令。&
当前持仓位置的每手浮动盈亏
ContractProfit
说明 获得当前持仓位置的每手浮动盈亏。&
语法 Numeric ContractProfit()&
备注 获得当前持仓位置的每手浮动盈亏，已考虑交易费用，返回值为浮点数，该函数仅支持交易指令。
只有当MarketPosition != 0时，即有持仓的状况下，该函数才有意义，否则返回0。
获得当前的可用资金
CurrentCapital
说明 获得当前的可用资金。&
语法 Numeric CurrentCapital()&
备注 获得当前的可用资金，已考虑交易费用，返回值为浮点数，该函数仅支持交易指令。
根据参数进行获利平仓操作
SetProfitTarget (0,2000,True);
当前所有持仓盈利达到2000之后，执行所有持仓位置的获利平仓。（此时是计算所有持仓的盈利数）
SetProfitTarget (1,50, False);
当前持仓的某一个建仓位置每张合约的盈利达到50之后，执行该持仓位置的获利平仓。（此时只计算该持仓位置的每张合约盈利）
第一课：实例之战
一个文华交易系统的移植例子
多空趋势-交易系统之文华的公式脚本：
[Copy to clipboard] [ - ]CODE:
MA1:=EMA(CLOSE,16);
MA2:=EMA(CLOSE,35),COLORYELLOW;
MA3:=EMA(CLOSE,60);
MA4:=REF(HIGH,1);
LOWV:=LLV(LOW,9);
HIGHV:=HHV(HIGH,9);
RSV:=EMA((CLOSE-LOWV)/(HIGHV-LOWV)*100,3);
K:=EMA(RSV,3);
D:=MA(K,3);
MV5:=MA(VOL,5);
KK:=REF(K,1);
PP:=REF(LOW,1);
VAR3:=(2*CLOSE+HIGH+LOW)/4;
VAR4:=LLV(LOW,33);
VAR5:=HHV(HIGH,33);
ZL:=EMA((VAR3-VAR4)/(VAR5-VAR4)*100,17);
SH:=EMA(0.667*REF(ZL,1)+0.333*ZL,2);
LC:=REF(CLOSE,1);
RSI:=SMA(MAX(CLOSE-LC, 0), 6, 1)/SMA(ABS(CLOSE-LC), 6,
CROSS(CLOSE,MA1)&&(K&D)&&(ZL&SH)||CROSS(MA1,MA2)&&(ZL&SH)&&(VOL&1.25*MV5)&&(K&D)||CROSS(K,D)&&(CLOSE&MA1)&&(ZL&SH)||CROSS(RSI,70),BK;
CROSS(PP,CLOSE)&&(D&K)&&(SH&ZL)||CROSS(D,K)&&(CLOSEZL),SK;
CROSS(D,K)||(CLOSE
CROSS(K,D)||(CLOSE&MA1*1.001),BP;
TradeBlazer公式代码：
[Copy to clipboard] [ - ]CODE:
//------------------------------------------------------------------------
// 简称: Test
// 名称: 多空趋势交易系统
// 类别: 交易指令
// 类型: 其他
//------------------------------------------------------------------------
& & Numeric
Length1(16);
& & Numeric
Length2(35);
& & Numeric
Length3(9);
& & Numeric
& & NumericSeries
& & NumericSeries
& & Numeric
& & NumericSeries
& & NumericSeries
& & NumericSeries
& & NumericSeries
& & Numeric
& & NumericSeries
CloseTmp1;
& & NumericSeries
CloseTmp2;
& & NumericSeries
& & NumericSeries
& & NumericSeries
& & Numeric
& & NumericSeries
& & NumericSeries
& & NumericSeries
& & Numeric
& & Value1 =
XAverage(Close,Length1);
& & Value2 =
XAverage(Close,Length2);
& & //取两条均线的值
& & LowestValue =
Lowest(Low,Length3);
& & //取最低值
& & Value5 =
(CLOSE-LowestValue)/(Highest(High,Length3)-LowestValue)*100;
XAverage(Value5,3);
& & KValue =
XAverage(RSV,3);
& & DValue =
Average(KValue,3);
& & PreKValue =
KValue[1];
& & PreLow =
& & AvgVol5 =
Average(Vol,5);
& & Lowest33Value =
Lowest(Low,33);
& & VarTmp1
=((2*CLOSE+HIGH+LOW)/4 - Lowest33Value )/(Highest(High,33) -
Lowest33Value) * 100;
XAverage(VarTmp1,17);
& & VarTmp2 =
0.667*ZL[1] + 0.333*ZL;
XAverage(VarTmp2,2);
& & CloseTmp1 =
Max(Close - Close[1], 0);
& & CloseTmp2 =
Abs(Close - Close[1]);
& & RSIValue =
WAverage(CloseTmp1,6)/WAverage(CloseTmp2,6) *100;
//以上为KD部分只要如何换书写方式就可了，，higest ==hhv lowest==llv
& xAverager=ma &
Buy什么时做买入动作，条件
(CrossOver(Close,Value1 ) && (KValue & DValue)
&& (ZL&SH)) Or&
&(CrossOver(Value1,Value2) &&
(ZL&SH) && (Vol & 1.25 * AvgVol5) && (KValue
& DValue)) Or
&(CrossOver(KValue,DValue) &&
(Close & Value1) && (ZL&SH)) Or
&(CrossOver(RSIValue,70)))//条件
Buy(Lots,Close);
& & // SellShort
什么作卖出动作
(CrossOver(PreLow,Close) && (KValue & DValue )
&& (SH&ZL) ) Or
&(CrossOver(DValue,KValue) &&
(Close & Value1) && (Value1 & Value2)) Or
&(CrossOver(PreKValue,KValue)&&
(SH&ZL)))//条件
SellShort(Lots,Close);
& & // Sell
什么做多平动作
If(CrossOver(DValue,KValue) || Close &
1.001)//条件
BuyToCover什么进个做空平动作
If(CrossOver(KValue,DValue) || Close & Value1 * 1.001)//条件
//------------------------------------------------------------------------
// 编译版本 & &
// 用户版本 & &
// 版权所有 & &
&TradeBlazer
// 更改声明 & &
& &TradeBlazer
Software保留对TradeBlazer平台
&每一版本的TrabeBlazer公式修改和重写的权利
//------------------------------------------------------------------------
第二课：交易思想是灵魂
要是打算根据3日的高低价平仓呢?想法如下
想实现这样一个一个想法：价格突破5天最高价，开多仓，把当天和前一天的K线做比较，取两日的最低价格做为止损，当价格突破3日最低价时，平多仓。
价格突破5日最低价，开空仓，把今天和 ...&
你看看哦，代码大致如此：&
NumericSeries EntryHi; &
NumericSeries EntryLo; &
NumericSeries ShortS &
NumericSeries LongS
NumericSeries SellHi;
NumericSeries SellLo; &
Numeric myEntryP &
Numeric myExitP &
//入场点，开多和开空点，突破5天最高或最低
EntryHi = Highest(high[1],5);
EntryLo &= Lowest(low[1],5);
//离场点，止盈点，三天较高或较低
SellHi=Highest(high[1],3);
SellLo= Lowest(low[1],3);
//止损点，两天较高或较低
ShortStop= Highest(high[1],2);
LongStop=Lowest(low[1],2);
if(MarketPosition ==0)
If(CrossOver(high,EntryHi))
& & myEntryPrice =
min(high,EntryHi );
& & myEntryPrice =
IIF(myEntryPrice & Open, Open,myEntryPrice);
Buy(0,myEntryPrice);
If(CrossUnder(Low,EntryLo ))
& & myEntryPrice =
max(low,EntryLo &);
& & myEntryPrice =
IIF(myEntryPrice & Open, Open,myEntryPrice);
SellShort(0,myEntryPrice);
If(MarketPosition ==1)
(CrossUnder(Low,LongStop))
& & myExitPrice =
max(low,LongStop );
& & myExitPrice =
IIF(myExitPrice & Open, Open,myExitPrice);
Sell(0,myExitPrice);
(CrossUnder(Low,SellLo))
& & myExitPrice =
max(low,SellLo );
& & myExitPrice =
IIF(myExitPrice & Open, Open,myExitPrice);
Sell(0,myExitPrice);
If(MarketPosition ==-1)
(CrossOver(high,ShortStop))
& myExitPrice = min(high,ShortStop );
& myExitPrice = IIF(myExitPrice & Open,
Open,myExitPrice);
BuyToCover(0,myExitPrice);
(CrossOver(high,SellHi))
& myExitPrice = min(high,SellHi );
& myExitPrice = IIF(myExitPrice & Open,
Open,myExitPrice);
BuyToCover(0,myExitPrice);
第三课:双均线策略
// 以下为均线交易系统，5日均线上穿20均线为买入，5日均线下穿20均线为买出
Params & &
& &// 宣告参数定义
& & Numeric
Length1(5); & &
5日均线的参数值
& & Numeric
Length2(20); & &
20日均线的参数值
& & Numeric
Lots(1); & &
默认的交易数量，您可以通过公式计算来产生
& &// 宣告变量定义
& & NumericSeries
中间变量，用来保存5日均线的值，因为CrossOver的输入参数需要序列变量，因此定义为序列变量
& & NumericSeries
中间变量，用来保存20日均线的值，因为CrossOver的输入参数需要序列变量，因此定义为序列变量
宣告公式正文开始
AverageFC(Close,Length1); &
&// 求出5日均线值，并将值赋给MA1
AverageFC(Close,Length2); &
&// 求出20日均线值，并将值赋给MA2
If(CrossOver(MA1,MA2)) &
&// 当出现5日均线上穿20均线时买入
Buy(Lots,Close); &
&// 用当前Bar的收盘价买入，详细的Buy函数调用请参见帮助文件
If(CrossUnder(MA1,MA2))// 当出现5日均线下穿20均线时卖出
Sell不用参数时会自动平掉所有仓位，详细的Sell函数调用请参见帮助文件
宣告公式正文结束
问题集中一下,双策略
收盘价格突破5天均线,开仓,跌破5天线平仓;
收盘价格突破25天均线,开仓,跌破25天线平仓;
各平各的仓,不可乱平.
是这样解决
如果您希望两个交易指令不相互平仓，那直接开两个图表分别执行交易指令就可以啦！
你举例的交易指令除了参数还都是一样的。所以只需要更改两个图表中交易指令的参数就可以解决了。
操作步骤如下：
1、新建一个交易指令，假定命名为Demo:
[Copy to clipboard] [ - ]CODE:
Params & &
& &// 宣告参数定义
& & Numeric
Length(5); & &
& &// 均线的参数值
& & Numeric
Lots(1); & &
默认的交易数量，您可以通过公式计算来产生
& &// 宣告变量定义
& & NumericSeries
中间变量，用来保存均线的值，因为CrossOver的输入参数需要序列变量，因此定义为序列变量
宣告公式正文开始
AverageFC(Close,Length); &
&// 求出均线值，并将值赋给MA1
If(CrossOver(Close,MA1)) &
&// 当出现收盘价上穿均线时买入
Buy(Lots,Close); &
&// 用当前Bar的收盘价买入，详细的Buy函数调用请参见帮助文件
If(CrossUnder(Close,MA1))// 当出现收盘价下穿均线时卖出
Sell不用参数时会自动平掉所有仓位，详细的Sell函数调用请参见帮助文件
宣告公式正文结束
2、编译保存该公式后，开两个图表，都加入该交易指令。一个图表的交易指令参数设置为5，一个设置为20。
这就相当两个毫无关联的交易系统组合在一起的效果，就好像有两个人[A和B]可以同时操作一个账户，A,B都可以在任何时候进行开平仓。
必然会出现A开的仓被B平掉，或者B想开仓，发现资金不够。所以，您在组合交易系统的时候，一定要知道每个交易系统会干什么，会产生什么关联。就相当于A和B两个人需要约定一下，A来管开仓，B来管平仓。或者其他分工，这样就不会乱啦。
我提供的是一个无任何实际意义的例子，所以，您不与拘泥于公式的条件写法。
比如开仓条件，先从单个条件写起。如果错误的讯号太多，则需要增加条件，过滤一些无效的讯号。
如果讯号太少，则说明您的条件太苛刻，也需要对条件进行修改。
平仓的讯号也是类似，唯一不同的是还需要加上一些止损的条件
第四课:开仓和资金关联
如何进行增减开仓控制
能否在开仓前检测资产总额，比如盈亏20%时增减1手仓位？[
假定我们在当前持多仓盈利的盈利达到10%的时候在增仓一倍。其他的用法类似。
[Copy to clipboard] [ - ]CODE:
& & Numeric
前面的代码为建仓，平仓操作。。
If(MarketPosition == 1) // 当前为多仓
& & ProfitRatio =
ContractProfit/(AvgEntryPrice()*ContractUnit()*MarginRatio()); //
当前盈利比例=每手盈利/(每手的总价格*保证金)
& & If(ProfitRatio
Buy(CurrentContracts,Close); &
&// 再按照当前的仓位买入
CurrentCapital，AvgEntryPrice，CurrentContracts，ContractProfit等函数可获得测试时的资金，盈亏等数据。
然后进行后续仓位控制。
第5课:资金管理与TB的结合范例应
通过对资金管理来实现及时止损和止赢(最为关键一课)
第6课:海龟--著名交易系统
只有吃透海龟你才算是合格的系统交易者
第七课:实战例
//------------------------------------------------------------------------
// 简称: sd
// 名称: sd
// 类别: 交易指令
// 类型: 多头建仓
//------------------------------------------------------------------------
& & Numeric
lots(8);//精华在这里
if (BarStatus == 2 ) &
&{Lots=A_FreeMargin
/(Q_AskPrice*ContractUnit*MarginRatio);
IntPart(Lots); }// 取整
Else If(BarStatus&&2 &)
&{Lots=CurrentCapital/(Close*ContractUnit*MarginRatio);
Lots=IntPart(Lots); // 取整
//这是本例华部分,也是作者思想可取,一个好的交易者先首要件就是控制作风险.......
SZWY=(close&=open[1])&&(close[2]&=open[2]);
SSLY=(CLOSE&OPEN)&&(CLOSE[1]&=OPEN[1])&&(CLOSE[2]&=OPEN[2])&&(CLOSE[3]&=OPEN[3]);
SLY=(CLOSE&OPEN
)&&(CLOSE[1]&=OPEN[1])&&(CLOSE[2]&=OPEN[2]);
SSZWY=(CLOSE&=OPEN[1])&&(CLOSE[2]&=OPEN[2])&&(CLOSE[3]&=Open[3]);
// 开多条件
& &IF(ssly and
Time&0.144500 ) &
在四连阳形态的时候！在下根K线开盘价做多(注:每个人入场方式可以不同)
& Buy(lots,Close,True);
// 开空条件
& &if(sszwy
and Time&0.144500 &)
//在四连阴形态的时候！在下根K线开盘价卖空((注:每个人入场方式可以不同)
& SellShort(lots,Close,True);
&Sell(lots,Close,True);
BuyToCover(lots,Close,True);//这都关键性,别的系统所不能这样做
//------------------------------------------------------------------------
/content/11/897_.shtml}