MQL5 中的范畴论

回顾一下，我们所介绍的范畴论是作为数学的一个分支，它对组织和分类信息特别有用。在此背景下，我们讨论了范畴论的一些基本概念，以及如何将其应用于金融时间序列数据的分析。具体来说，我们研究了元素、域和态射。元素是范畴论体系中信息的基本单位，它们通常被认为是一个集合的成员，且在这些系列中被视作一个域。一个域可以通过称为态射的过程与其它域建立关系。在这篇文章中，我们将首先通过查看恒等公理、关联公理、交换图，来详述类别的构成。在进行的过程中，贯穿全文，我们将实验示例，并高亮显示非类别的示例。最后，我们将介绍本体日志。

在我们深入研究范畴的公理定义之前，先看看一些“在行动中”类别的日常示例可能会有所帮助。我们已经定义了域及其包含的元素。故此，如果一开始我们把一个类别作为相关域的集合，那么以下内容可以作为说明性示例。

交通方式的类别，其域代表不同的交通方式（例如汽车、飞机和火车、等）。每个域的元素将代表各自种类的运输工具。例如，在汽车类别中，我们可以有共享车、汽车租赁、私家车、出租车；而在飞机类别中，我们可以拥有私人飞机、商业飞机、租赁飞机；对于列车类别，我们能包含有轨电车、子弹头列车、蒸汽机车、等。然后，它们之间的态射可用于定义完整的旅行行程。例如，如果您乘坐 lyft （译者按：共享车连锁品牌）前往机场，乘坐商务航班，然后从该机场乘坐子弹头列车前往目的地，那么这些选择中的每一个都可以轻松映射到此类别中。

一顿饭的类别，其域代表每道菜的菜单。若我们说要准备 5 道菜，即：开胃菜、汤、主菜、甜点和奶酪。在这种情况下，每个域的元素将是菜单上相应那道菜的食物项目。例如，开胃菜可以在其域（菜单）中包含选择：蜜饯胡萝卜配蜂蜜、小茴香和辣椒粉；或塞满罗马佩克立诺、大蒜和面包屑的蘑菇；或烧西兰花配西司椒和腌洋葱；同样明智的汤可以有：托斯卡纳白豆和烤大蒜汤；或南瓜鼠尾草浓汤；或冷瓜和罗勒汤。这些菜单项中的每一个都代表其域中的一个元素。与其类似，它们之间的态射将用于定义餐厅顾客选择的完整餐点。例如，如果客户有蜜饯胡萝卜，然后是南瓜，以及所有其它菜品，那么上述每个选项都可以轻松地映射到该类别中。

另一个类别示例可以是每周娱乐的类型。此处，我们的域可以是体育直播、电视流媒体和公园参观。每个域的元素可以是：体育直播域的 NFL，或 MLB，或 NBA；电视流媒体域的 Netflix，或 HBO，或 AMC；参观公园域的迪斯尼，或动物园，或天然公园。如此观众可随意从每个域中选择参加的体育比赛，观看的电视节目，和参观的公园。选择的说明（态射）跨越了这些域，很容易就能映射此信息。

如此，所有这些，显然还有更多的东西可以被范畴论记录下来。但其终点是什么？有句话说“低能的工人总责怪他的工具”，我觉得这就是问题的关键。因为用不用实际上是由用户决定的。在我看来，范畴论批判性地运用了量化等价性。这是我们在介绍基本概念之后将在后续文章中讨论的主题。从表面来说，这就是为什么看起来可能毫不相关的分属两个不同主题的独立类别显现的原因，但在更深入的调查中发现它们是雷同或镜像对立的。这些见解在决策中至关重要，因为在做出决策时您缺乏足够的信息。但若是您有相关的类别，则可以弥合信息鸿沟。

识别

同构是范畴论中同态的关键性质，因为它确保目标范畴域的结构在映射下得以保留。它还保证保留源类别中域的代数运算。例如，我们考虑一个服装类别，其中的域是衬衫和裤子，态射是将衬衫大小映射到裤子大小的函数。此类别中的同态将保留衬衫尺寸与裤子相应尺寸的配对的功能。而此类别中的同构将是一个函数，它不仅保留了尺寸的代数配对，而且还在衬衫和裤子的尺寸之间建立了一对一的对应关系。这意味着对于任何尺寸的衬衫，只有一个对应的裤子尺寸，反之亦然。举例来说，考虑将衬衫尺寸（例如“小”、“中”、“大”）映射到裤子尺寸（例如 “26”、“28”、“30”、“32”）的函数。该函数是一个同态，因为它保留并定义了大小的配对（例如，“小”可以与 “26” 配对）。但这不是同构，因为它没有在衬衫和裤子的尺寸之间建立一对一的对应关系，因为“小”也可以与 “28” 或 “26” 一起穿。这里没有可逆性。

另一方面，考虑将衬衫的尺寸（例如“小”、“中”、“大”）映射到裤子尺寸（例如 “28”、“30”、“32”）的函数。这个函数不仅是同态，而且是同构，因为它也允许可逆性。

在服装类别的示例中，域是衬衫和裤子，态射是将衬衫尺寸映射到裤子尺寸的函数，单个态射不能同构，因为所有单个态射本质上都是可逆的，并且存在“同构”。同构的性质应对的是从一个域到一个协同域的一组态射（又名同态集），且仅当这个群的所有这些态射都可以逆转，同时保持同态的代数配对性质，它才能认为是存在。这就是为什么在确认同构之前，列举域中的所有态射很重要的原因。在不考虑所有可能态射的情况下，也许会出现两个对象是同构的，而实际上它们并非同构。同构的前兆是域的基数。对于两个域，此值必须相同。如果域含有不匹配的基数，则它们之间的同态无法逆转，因为从一个域中，您将有多个元素映射到同一辅助元素。因此，我们需要域之间的一组态射来定义同构。典型情况是我们需要两个态射，一个从衬衫到裤子，另一个从裤子到衬衫，并在衬衫和裤子的尺寸之间建立一对一的对应关系。这些态射应该是彼此逆反的，这意味着如果一个态射将“小”号的衬衫转换到 “28” 码的裤子上，另一个态射应该将 “28” 码的裤子逆转成“小”码的衬衫。当我们复合这两个态射时，它应该为我们提供我们始建域的等同态射。

范畴论中的这一公理要求推断出需要自映射态射。然而，对于它们是否与界定一个类别有关，仍然存在争议。

接下来，我们来以 MQL5 解述同构。我已经重写了第一篇文章中共享的大部分脚本，现在还包括模板。从元素类到范畴类的所有类，都包含运用模板数据类型，从而实现了灵活性。不过，我还“列举”了范畴类中可用的类型。它们是：'datetime','string','double' 和 int。 “int” 类型是默认的，如果是诸如 “color” 之类的数据类型，就用到它。所有代码都附在文末。此处是我们新的同态类。

//+------------------------------------------------------------------+
//| HOMO-MORPHISM CLASS                                              |
//+------------------------------------------------------------------+
template <typename TD,typename TC>
class CHomomorphism                 : public CObject{protected:int                           morphisms;public:CDomain<TD>                   domain;CDomain<TC   (string(typename(TD))!=string(typename(TDD)))||(string(typename(TC))!=string(typename(TDC)))||){return(false);}// if(ValueIndex>=0 && ValueIndex<Morphisms()){Value.domain=domain;Value.codomain=codomain;if(Index(Value)==-1){morphism[ValueIndex]=Value;return(true);} }return(false); };template <typename TDD,typename TDC>int                           Index(CMorphism<TDD,TDC> &Value){int _index=-1;//if((string(typename(TD))!=string(typename(TDD)))||(string(typename(TC))!=string(typename(TDC)))||){return(_index);}// for(int m=0; m<morphisms; m++){if(MorphismMatch(Value,morphism[m])){_index=m; break;}}return(_index);}CHomomorphism(void){  Morphisms(0); };~CHomomorphism(void){};};

为了测试同构，我们取上一篇文章中所用的相同域，并将通过 “IsIsomorphic” 函数运行它们。该函数返回一个布尔值，其中 true 表示成功，而 false 表示失败。

//+------------------------------------------------------------------+
//| Get Isomorphisms function                                        |
//+------------------------------------------------------------------+
template <typename TD,typename TC>
bool IsIsomorphic(CDomain<TD> &A,CDomain<TC> &B,CHomomorphism<TD,TC> &Output[]){if(A.Cardinality()!=B.Cardinality()){return(false);}int _cardinal=A.Cardinality();uint _factorial=MathFactorial(_cardinal);ArrayResize(Output,_factorial);for(uint f=0;f<_factorial;f++){ArrayResize(Output[f].morphism,_cardinal);//for(int c=0;c<_cardinal;c++){Output[f].morphism[c].domain=A;Output[f].morphism[c].codomain=B;}}int _index=0;CDomain<TC> _output[];ArrayResize(_output,_factorial);GetIsomorphisms(B, 0, _cardinal-1, _cardinal, _index, _output);for(uint f=0;f<_factorial;f++){for(int c=0;c<_cardinal;c++){CElement<TC> _ec;if(_output[f].Get(c,_ec)){for(int cc=0;cc<_cardinal;cc++){CElement<TC> _ecc;if(B.Get(cc,_ecc)){if(ElementMatch(_ec,_ecc)){if(Output[f].morphism[c].Codomain(cc)){break;}}}}}if(Output[f].morphism[c].Domain(c)){}}}return(true);}

输出同态需要在现场指定，在我们的示例中，我们使用变量 “_h_i”。这个输出值是同态类的数组，将包括两个输入域之间所有可能的同构同态的枚举。

      //IDENTITYCHomomorphism<int,int> _h_i[];//is evens isomorphic to odds?if(IsIsomorphic(_evens,_odds,_h_i)){printf(__FUNCSIG__+" evens can be isomorphic to odds by up to: "+IntegerToString(ArraySize(_h_i))+" homomorphisms. These could be... ");for(int s=0; s<ArraySize(_h_i); s++){printf(__FUNCSIG__);string _print="";for(int ss=0; ss<ArraySize(_h_i[s].morphism); ss++){_print+=PrintMorphism(_h_i[s].morphism[ss],0);}printf(_print+" at: "+IntegerToString(s));}}

如果我们运行此代码，我们的日志应如下所示。

2023.01.26 10:42:56.909 ct_2 (EURGBP.ln,H1)     void OnStart() evens can be isomorphic to odds by up to: 6 homomorphisms. These could be...
2023.01.26 10:42:56.909 ct_2 (EURGBP.ln,H1)     void OnStart()
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (0)|----->(1)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (2)|----->(3)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (4)|----->(5)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)      at: 0
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     void OnStart()
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (0)|----->(1)2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (2)|----->(5)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (4)|----->(3)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)      at: 1
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     void OnStart()
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (0)|----->(3)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (2)|----->(1)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (4)|----->(5)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)      at: 2
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     void OnStart()
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (0)|----->(3)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (2)|----->(5)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (4)|----->(1)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)      at: 3
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     void OnStart()
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (0)|----->(5)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (2)|----->(3)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (4)|----->(1)
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)      at: 4
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     void OnStart()
2023.01.26 10:42:56.910 ct_2 (EURGBP.ln,H1)     (0)|----->(5)
2023.01.26 10:42:56.911 ct_2 (EURGBP.ln,H1)     (2)|----->(1)
2023.01.26 10:42:56.911 ct_2 (EURGBP.ln,H1)     (4)|----->(3)
2023.01.26 10:42:56.911 ct_2 (EURGBP.ln,H1)      at: 5

若这是一个偶数域，其打印是：

2023.01.26 10:42:56.899 ct_2 (EURGBP.ln,H1)     void OnStart() evens are... {(0),(2),(4)}

若这是一个奇数域，其打印是：

2023.01.26 10:42:56.899 ct_2 (EURGBP.ln,H1)     void OnStart() odds are... {(1),(3),(5)}

关联

在范畴论中，关联公理是类别必须满足的基本性质之一。使用服装类别的示例，其中域是特定的服装项目，诸如衬衫、裤子和鞋子，态射则是根据适用性与服装配对的函数。关联公理，也称为“结合性定律”，表示态射组合是关联的。这意味着在合成多个态射时，它们的应用顺序不会影响最终结果。

例如，考虑态射“搭配穿”跨越所有 3 个服装域（衬衫、裤子和鞋子）。若说我们有一个态射 f: T 恤 -> 纽扣衬衫，g: 纽扣衬衫 -> 牛仔裤，和 h: 牛仔裤 -> 运动鞋。使用关联公理，我们可以将这些态射的组合定义为 h o (g o f) = (h o g) o f。这意味着态射的顺序无关紧要，我们可以按任何我们想要的方式将它们分组在一起。这令类别的定义更简单，因为它允许我们避免计算多个态射的括号。取而代之，我们可以将态射分组在一起，无论它们的顺序如何，最终结果将是相同的。

我们看看在 MQL5 中它如何动作。我们需要重新组合我在上一篇文章中共享的范畴类。

//+------------------------------------------------------------------+
//| CATEGORY CLASS                                                   |
//+------------------------------------------------------------------+
class CCategory{protected:int                           domains_datetime;int                           domains_string;int                           domains_double;int                           domains_int;int                           ontologies;CDomain<datetime>             domain_datetime[];CDomain<string>               domain_string[];CDomain<double>               domain_double[];CDomain<int>                  domain_int[];COntology                     ontology[];public:int                           Domain(string T){ if(T=="datetime"){ return(domains_datetime); }else if(T=="string"){ return(domains_string); }else if(T=="double"){ return(domains_double); }return(domains_int);};bool                          Domain(string T,int Value){ if(Value>=0 && Value<INT_MAX){ if(T=="datetime"){ if(ArrayResize(domain_datetime,Value)>=Value){domains_datetime=Value;  return(true); } }else if(T=="string"){ if(ArrayResize(domain_string,Value)>=Value){domains_string=Value;  return(true); } }else if(T=="double"){ if(ArrayResize(domain_double,Value)>=Value){domains_double=Value;  return(true); } }else //if(T=="int"){ if(ArrayResize(domain_int,Value)>=Value){domains_int=Value;  return(true);}  }} return(false); };int                           Ontology(){ return(ontologies); };bool                          Ontology(int Value){ if(Value>=0 && Value<INT_MAX){ ontologies=Value; ArrayResize(ontology,ontologies); return(true); } return(false); };template <typename T>bool                          Set(int ValueIndex,CDomain<T> &Value){if(Index(Value)==-1 && ValueIndex>=0){if(ValueIndex<Domain(string(typename(T)))||(ValueIndex>=Domain(string(typename(T))) && Domain(string(typename(T)),ValueIndex+1))){if(string(typename(T))=="datetime"){domain_datetime[ValueIndex]=Value;return(true);}else if(string(typename(T))=="string"){domain_string[ValueIndex]=Value;return(true);}else if(string(typename(T))=="double"){domain_double[ValueIndex]=Value;return(true);}else //if(string(typename(T))=="int"){domain_int[ValueIndex]=Value;return(true);}}}//return(false);};template <typename T>bool                          Get(int DomainIndex,CDomain<T> &D){if(DomainIndex>=0 && DomainIndex<Domain(string(typename(T)))){if(string(typename(T))=="datetime"){D=domain_datetime[DomainIndex];return(true);}else if(string(typename(T))=="string"){D=domain_string[DomainIndex];return(true);}else if(string(typename(T))=="double"){D=domain_double[DomainIndex];return(true);}else //if(string(typename(T))=="int"){D=domain_int[DomainIndex];return(true);}}return(false);};bool                          Set(int ValueIndex,COntology &Value){if(ValueIndex>=0 && ValueIndex<Ontology()){ontology[ValueIndex]=Value;return(true);}else if(ValueIndex>=Ontology()){if(Ontology(Ontology()+1)){ontology[Ontology()-1]=Value;return(true);}}//reak;}}else if(string(typename(T))=="datetime"){if(DomainMatch(Value,domain_int[d])){_index=d; break;}}else if(string(typename(T))=="double"){if(DomainMatch(Value,domain_double[d])){_index=d; break;}}else if(string(typename(T))=="int"){if(DomainMatch(Value,domain_int[d])){_index=d; break;}}}return(_index);}int                           Index(COntology &Value){int _index=-1;//for(int o=0; o<Ontology(); o++){if(!OntologyMatch(Value,ontology[o])){_index=o; break;}}return(_index);}CCategory(){ domains_datetime=0; domains_string=0; domains_double=0; domains_int=0; ontologies=0; };~CCategory(){ };};

请注意 “enumerated” 数据类型是允许的。在以后的文章中，我将尝试将它们作为一个对象集成到单个数组之中，从而令它更整洁。除了上一篇文章中用自然数填充域的函数之外，还添加了 “FillDomain” 函数。

//+------------------------------------------------------------------+
//| Fill Domain(Set) with one-cardinal elements from input E array.  |
//+------------------------------------------------------------------+
template <typename TD,typename TE>
void FillDomain(CDomain<TD> &D,CElement<TE> &E[]){if(string(typename(TD))!=string(typename(TE))){return;}int _cardinal=ArraySize(E);//if(_cardinal<0||INT_MAX<=_cardinal){return;}//Set its cardinal to input array sizeif(D.Cardinality(_cardinal)){for(int c=0;c<_cardinal;c++){D.Set(c,E[c],true);}}}

故此，为了检查关联，我们将创建一个类别 “_ca”。然后我们声明 3 个简单的字符串类型集合，每个都填充一种服装类型。我们将这些集合（数组）复制到新的元素数组（'_et'、'_ep'、'_es'），然后将这些元素中的每一个添加到它自己的域（'_dt'、'_dp'、'_ds'）。完成此操作后，我们将类别的域数设置为 3，然后继续按索引用新创建并填充了服装类型元素的域来设置。

      //ASSOCIATIONCCategory _ca;string _tops[__EA]={"T-shirt","button-up","polo","sweatshirt","tank top"};          //domain 0string _pants[__EA]={"jeans","slacks","khakis","sweatpants","shorts"};              //domain 1string _shoes[__EA]={"sneakers","dress shoes","loafers","running shoes","sandals"}; //domain 2CElement<string> _et[];ArrayResize(_et,__EA);CElement<string> _ep[];ArrayResize(_ep,__EA);CElement<string> _es[];ArrayResize(_es,__EA);for(int e=0;e<__EA;e++){ _et[e].Cardinality(1); _et[e].Set(0,_tops[e]);_ep[e].Cardinality(1); _ep[e].Set(0,_pants[e]);_es[e].Cardinality(1); _es[e].Set(0,_shoes[e]); }CDomain<string> _dt,_dp,_ds;FillDomain(_dt,_et);FillDomain(_dp,_ep);FillDomain(_ds,_es);//if(_ca.Domain("string",__DA))//resize domains array to 3{if(_ca.Set(0,_dt) && _ca.Set(1,_dp) && _ca.Set(2,_ds))//assign each filled domain above to a spot (index) within the category{if(_ca.Domain("string")==__DA)//check domains count {for(int e=0;e<__EA;e++){COntology _o_01_2;CMorphism<string,string> _m1_01_2,_m2_01_2;SetCategory(_ca,0,1,e,e,_o_01_2," is worn with ",_m1_01_2);SetCategory(_ca,1,2,e,e,_o_01_2," is worn with ",_m2_01_2,ONTOLOGY_POST);printf(__FUNCSIG__+" (0 & 1) followed by 2 Log is: "+_o_01_2.ontology);COntology _o_0_12;CMorphism<string,string> _m1_0_12,_m2_0_12;SetCategory(_ca,1,2,e,e,_o_0_12," is worn with ",_m1_0_12);SetCategory(_ca,0,2,e,e,_o_0_12," is worn with ",_m2_0_12,ONTOLOGY_PRE);printf(__FUNCSIG__+" 0 following (1 & 2) Log is: "+_o_0_12.ontology);

MQL5 中的范畴论相关推荐

MQL5 中的绘图风格
简介 MQL4 中有 6 种绘图风格.而 MQL5 中则有 18 种绘图风格.因此,可能很有必要撰写一篇文章,专门介绍 MQL5 的绘图风格. 我们会在本文研究 MQL5 中的绘图风格详情.此外,我们 ...
[程序] 程序设计中的范畴论 (第一部分)
程序设计中的范畴论 (第一部分) 文章目录程序设计中的范畴论 (第一部分) 0 引言 0.1 抽象 0.2 悖论 1 范畴 (Category) 1.1 交换图 1.2 示例正整数与偏序关系矩阵 ...
在 MQL5 中寻找趋势的几种方法
简介所有交易员都知道一个规则:"趋势是您的好朋友,要跟着它走."但是到底什么是趋势,这却是仁者见仁智者见智的问题.几乎每位交易员都听说过一些可怕的故事,这些故事的中心思想就是:逆 ...
MQL5 细则手册：在 MQL5 中开发多交易品种波动指标
简介本文将探讨如何开发多交易品种波动指标.对于 MQL5 开发新手来说,开发多交易品种指标可能有些难度,本文将帮他们理清开发过程.开发多交易品种指标的主要问题:其它交易品种的数据与当前交易品种之间的 ...
MQL5 中对象创建和析构的顺序
本文主要内容 MQL5 程序的编写基于面向对象编程 (OOP) 理念,这不仅为创建自定义库带来了新的可能性,并允许您使用其他开发人员的完整且经过测试的类.MetaTrader 5 客户端的标准库中有数 ...
MQL5 中艾略特波浪自动分析的实施
简介艾略特波浪理论是最流行的市场分析方法之一.然而,这个过程非常复杂,从而导致我们使用额外的工具.自动标记器是其中一种工具. 本文描述用 MQL5 语言创建艾略特波浪的自动分析程序.假定读者已经熟悉 ...
价格直方图(市场概况)及其在 MQL5 中的实施
简介很久以前,我在浏览杂志订阅信息时在一份俄国杂志 "Valutny Spekulant"(现名 "Active Trader") 上读过一篇文章" ...
mql5的include库文件中自定义enum类型在指标文件中的调用方式
在mql5中编写指标,调用的include文件中某个类中使用了自定义ENUM枚举类型,如图所示: enum Smooth_Method { MODE_SMA_, //SMA MODE_EMA_, // ...
用 DELPHI 为 MQL5 编写 DLL 指南
简介考虑使用 Delphi 2009 开发环境来作为编写 DLL 的机制的例子.之所以选择这个版本是因为在 MQL5 中,所有代码行都是以 Unicode 格式存储的.在旧版本的 Delphi 中, ...

MQL5 中的范畴论

识别

关联

MQL5 中的范畴论相关推荐

最新文章

热门文章