201801 DDD DSL Design War Measurement System in Python - xiaoxianfaye/Courses GitHub Wiki
- 1 Problem
- 2 Showcase & Discuss
- 3 Analysis
- 4 Design
- 5 Implementation
- 6 Summary
- 7 Homework
- 8 My Homework
实现一个长度(Length)库。通过这个库，用户可以以Mile为单位来表示一个长度，精度为1 Mile。可以对比两个长度的相等性：
3 Mile == 3 Mile
3 Mile != 2 Mile
3 Mile != 4 Mile
用户除了可以使用Mile为单位来表示长度之外，还可以使用Yard为单位来表示长度。
- 当以Mile为单位来表示一个长度时，精度为1 Mile；
- 当以Yard为单位来表示一个长度时，精度为1 Yard。
可以对比任意两个长度的相等性：
1 Mile == 1760 Yard
3 Yard == 3 Yard
1 Mile != 1761 Yard
3 Yard != 4 Yard
增加两个新的长度单位：Feet和Inch，用户可以使用它们为单位来表现一个长度。
- 当以Feet为单位来表示一个长度时，精度为1 Feet；
- 当以Inch为单位来表示一个长度时，精度为1 Inch。
可以对比任意两个长度的相等性：
1 Yard == 3 Feet
1 Feet == 12 Inch
这套库发布之后，用户只能使用既有单位(Mile、Yard、Feet、Inch)，而不应该有能力创建新的单位。以避免用户由于某些原因创建一些现实中不存在的单位，从而让系统变得不可理解。
任意两个长度可以进行加法运算。例如：
13 Inch + 11 Inch = 2 Feet
3 Feet + 2 Yard = 3 Yard
实现一个容量(Volume)库。通过这个库，用户可以使用TSP(茶匙)、TBSP(汤匙)、OZ(盎司)为单位来表示一个容量。
- 当以TBSP为单位来表示一个容量时，精度为1 TBSP；
- 当以TSP为单位来表示一个容量时，精度为1 TSP；
- 当以OZ为单位来表示一个容量时，精度为1 OZ。
可以对比任意两个容量的相等性：
1 TBSP = 3 TSP
1 OZ = 2 TBSP
只允许用户使用现有的三个容量单位来表示容量。两个容量可以相加。
基于调试等目的需要，可以将一个长度对象输出到屏幕上。输入格式的规则如下：
- 如果一个对象的“基准单位数量”在一个更大的单位上的倍数非0，则显示此对象在此单位上的倍数，以及此单位的名字；
- 如果一个对象的“基准单位数量”在一个更大的单位上的倍数为0，则无须显示此对象在此单位上的倍数，以及此单位的名字；
- 如果余数在一个较小的单位上倍数非0，则显示此对象在此单位上的倍数，以及此单位的名字；
- 如果余数在一个较小的单位上倍数为0，则无须显示此对象在此单位上的倍数，以及此单位的名字；
- 如果一个对象的“基准单位数量”为0，则显示0，以及基准单位的名字；
- 如果存在多个“数量＋单位”组合，则按照单位大小，从左向右排列；
- 数量和单位之间，由一个空格分开；
- “数量＋单位”之间由一个空格分开。
增加一种新的长度对象输出格式，以Inch为单位输出任何Length对象。数量和单位之间以一个空格分隔。
请学员展示自己之前的设计思路和实现方式，大家可以互相点评、讨论。以学员为主，讲师为辅。
分析：定义清楚问题是什么。
- 需求一到需求五是英制长度计量系统的相关需求，要实现长度的相等性和加法运算；
- 需求六是英制容量计量系统的相关需求，要实现容量的相等性和加法运算；
- 需求七是计量系统的规格化表达需求；
- 需求八是计量系统的基准化表达需求。
设计：问题分析清楚以后，提出解决问题的逻辑框架。
1 Mile, 2 Yard, 3 Feet, 4 Inch, …
1 Mile 2 Yard, 1765 Yard 40 Inch, …
1 Mile 2 Yard 3 Feet 4 Inch, …
Q：What are these?
Length in Imperial Length Measurement System (英制长度计量系统中的长度)
1 OZ 2 TBSP 3 TSP，…
15 TSP，…
Q：What are these?
Volume in Imperial Volume Measurement System (英制容量计量系统中的容量)
Q：Can we give them an abstract name?
Quantity in Measurement System (计量系统中的数量)
既然是数量，我们就可以比较它们的大小(Equality)，对它们进行加、减运算(Add)。
以英制长度计量系统为例 (In Imperial Length Measurement System)，先来一个小测验(Quiz)。
这里有一个容易犯错的地方：单位层级完全相同的情况下，对应层级单位的量值相等，一定相等；对应层级单位的量值不同，不一定不相等，因为“进位”的缘故。
Why? How? 仔细体会一下大脑的计算过程，慢下来。
3 Mile == 3 Mile ? √
3 Yard == 4 Yard ? ×
- 特点：相同层级、一级单位。
- 方法：两个长度的一级单位完全相同，且无需进位处理，直接判断对应层级单位的量值，量值相等则相等，反之则不等。
3 Yard 4 Feet == 3 Yard 4 Feet ? √
3 Yard 4 Feet == 4 Yard 1 Feet ? √
- 特点：相同层级、多级单位、可以进位。
- 方法：两个长度的多级单位完全相同，需要进位处理。有两种方法。
方法一：先自右向左进行进位处理，再判断对应层级单位的量值，量值相等则相等，反之则不等。
3 Yard 4 Feet -> 4 Yard 1 Feet
方法二：先自左向右换算成较小层级的单位，再判断较小层级单位的量值，量值相等则相等，反之则不等。
3 Yard 4 Feet -> 13 Feet
4 Yard 1 Feet -> 13 Feet
3 Yard 4 Feet == 4 Yard 1 Feet
1 Mile 2 Yard 3 Feet 4 Inch == 1 Mile 2 Yard 3 Feet 4 Inch ? √
1 Mile 2 Yard 3 Feet 4 Inch == 1 Mile 3 Yard 0 Feet 4 Inch ? √
- 特点：相同的、完整的层级单位、可以进位。
- 方法：两个长度都是完整的单位层级，需要进位处理。两种方法同上，只是方法二中的较小层级单位略有不同，这里就是基准层级单位(最小层级单位)。
方法一：
1 Mile 2 Yard 3 Feet 4 Inch -> 1 Mile 3 Yard 0 Feet 4 Inch
方法二：
1 Mile 2 Yard 3 Feet 4 Inch
-> (1 * 1760 * 3 * 12) Inch + (2 * 3 * 12) Inch + (3 * 12) Inch + 4 Inch
-> 63472 Inch
1 Mile 3 Yard 0 Feet 4 Inch
-> (1 * 1760 * 3 * 12) Inch + (3 * 3 * 12) Inch + (0 * 12) Inch + 4 Inch
-> 63472 Inch
以上都是单位层级相同的情况。下面再看一下单位层级不同的情况。
1 Mile 2 Yard == 1762 Yard ? √
1 Mile 2 Yard == 2 Mile ? ×
- 特点：不同层级但未包含基准层级、多个单位。
- 方法：有两种方法。
方法一：先按照较小层级的单位对齐单位层级，再进行自右向左的进位处理，然后再判断对应层级单位的量值，量值相等则相等，反之则不等。
1762 Yard -> 0 Mile 1762 Yard -> 1 Mile 2 Yard
方法二：先自左向右换算成较小层级的单位，再判断较小层级单位的量值，量值相等则相等，反之则不等。
1 Mile 2 Yard -> (1 * 1760) Yard + 2 Yard -> 1762 Yard
1 Mile 2 Yard 3 Feet 4 Inch == 63472 Inch ? √
1765 Yard 40 Inch == 1 Mile 6 Yard 4 Inch ? √
- 特点：不同层级且包含基准层级、多个单位。
- 方法：两种方法同上，只是方法二中的较小层级单位略有不同，这里就是基准层级单位。
方法一：
1 Mile 2 Yard 3 Feet 4 Inch -> 1 Mile 3 Yard 0 Feet 4 Inch
63472 Inch -> 0 Mile 0 Yard 0 Feet 63472 Inch -> 1 Mile 3 Yard 0 Feet 4 Inch
1765 Yard 40 Inch -> 0 Mile 1765 Yard 0 Feet 40 Inch -> 1 Mile 6 Yard 0 Feet 4 Inch
1 Mile 6 Yard 4 Inch -> 1 Mile 6 Yard 0 Feet 4 Inch
方法二：
1 Mile 2 Yard 3 Feet 4 Inch
-> (1 * 1760 * 3 * 12) Inch + (2 * 3 * 12) Inch + (3 * 12) Inch + 4 Inch
-> 63472 Inch
1765 Yard 40 Inch -> (1765 * 3 * 12) Inch + 40 Inch -> 63580 Inch
1 Mile 6 Yard 4 Inch
-> (1 * 1760 * 3 * 12) Inch + (6 * 3 * 12) Inch + 4 Inch
-> 63580 Inch
Can we unify and simplify this process?
方法一：先按照基准层级的单位对齐单位层级，再进行自右向左的进位处理，然后再判断对应层级单位的量值，量值相等则相等，反之则不等。
方法二：先自左向右换算成基准层级的单位，再判断基准层级单位的量值，量值相等则相等，反之则不等。
这些方法不仅适用于英制长度计量系统，而且也适用于英制容量计量系统、甚至其它计量系统。
4.1.3 Something hidden before is coming up
Conversion of Units of Measurement System (计量系统的单位换算体系)
每个计量系统都有自己的单位换算体系。例如：
- Imperial Length Measurement System
System Units：Mile，Yard，Feet，Inch
Conversion of Units：1 Mile = 1760 Yard，1 Yard = 3 Feet，1 Feet = 12 Inch
- Imperial Volume Measurement System
System Units：OZ，TBSP，TSP
Conversion of Units：1 OZ = 2 TBSP，1 TBSP = 3 TSP
以英制长度计量系统为例 (In Imperial Length Measurement System)，再来一个小测验(Quiz)。
Why? How? 仔细体会一下大脑的计算过程，慢下来。
1 Mile + 2 Mile = ?
3 Feet + 4 Feet = ?
1 Yard 1 Feet + 2 Yard 2 Feet = ?
1 Mile 2 Yard 1 Feet 13 Inch + 1 Mile 2 Yard 1 Feet 11 Inch = ?
- 特点：相同层级、一级或多级单位，可以进位。
- 方法：在单位层级相同的情况下，先将对应层级单位的量值相加，再进行自右向左的进位处理。
1 Mile + 2 Mile = 3 Mile
3 Feet + 4 Feet = 7 Feet -> 2 Yard 1 Feet
1 Yard 1 Feet + 2 Yard 2 Feet = 3 Yard 3 Feet -> 4 Yard
1 Mile 2 Yard 1 Feet 13 Inch + 1 Mile 2 Yard 1 Feet 11 Inch
= 2 Mile 4 Yard 2 Feet 24 Inch
-> 2 Mile 5 Yard 1 Feet
以上都是单位层级相同的情况。下面再看一下单位层级不同的情况。
1 Mile + 2 Yard = ?
3 Feet + 2 Yard = ?
- 特点：不同层级但未包含基准层级、多个单位。
- 方法：有两种方法。
方法一：先按照较小层级的单位对齐单位层级，再将对应层级单位的量值相加，然后再进行自右向左的进位处理。
1 Mile -> 1 Mile 0 Yard
2 Yard -> 0 Mile 2 Yard
1 Mile + 2 Yard = 1 Mile 0 Yard + 0 Mile 2 Yard = 1 Mile 2 Yard
3 Feet -> 0 Yard 3 Feet
2 Yard -> 2 Yard 0 Feet
3 Feet + 2 Yard = 0 Yard 3 Feet + 2 Yard 0 Feet = 2 Yard 3 Feet -> 3 Yard
方法二：先自左向右换算成较小层级的单位，再将较小层级单位的量值相加，然后再进行自右向左的进位处理。
1 Mile + 2 Yard = 1760 Yard + 2 Yard = 1762 Yard -> 1 Mile 2 Yard
3 Feet + 2 Yard = 3 Feet + 6 Feet = 9 Feet -> 3 Yard
1 Mile 3 Feet + 2 Yard 4 Inch ?
- 特点：不同层级且包含基准层级、多个单位。
- 方法：两种方法同上，只是方法二中的较小层级单位略有不同，这里就是基准层级单位。
方法一：
1 Mile 3 Feet + 2 Yard 4 Inch
= 1 Mile 0 Yard 3 Feet 0 Inch + 0 Mile 2 Yard 0 Feet 4 Inch
= 1 Mile 2 Yard 3 Feet 4 Inch -> 1 Mile 3 Yard 4 Inch
方法二：
1 Mile 3 Feet + 2 Yard 4 Inch = 63396 Inch + 76 Inch = 63472 Inch = 1 Mile 3 Yard 4 Inch
Can we unify and simplify this process?
方法一：先按照基准层级的单位对齐单位层级，再将对应层级单位的量值相加，然后再进行自右向左的进位处理。
方法二：先自左向右换算成基准层级的单位，再将基准层级单位的量值相加，然后再进行自右向左的进位处理。
这些方法不仅适用于英制长度计量系统，而且也适用于英制容量计量系统、甚至其它计量系统。
经过上述的思考，问题领域中的核心概念如下图所示：
上面两张图可以“抽象”为：
核心概念包括：
- Quantity (数量)
- Conversion of Units (单位换算体系)
- 对Quantity的操作：
- equal (相等)、add (相加)
- normalize (规格化)、base (基准化)
其中equal和add来自于外部功能需求，normalize和base是为了满足外部功能需求而抽取的内部概念。这里的base当作动词用。
设计的第一步：找到合适的语义。
如何找到合适的语义呢？
我们在做领域驱动设计时，首先考虑是否能将问题领域映射到一个熟悉的同构领域。如果能，就可以借用那个领域的机制来表达问题领域的概念，而不是重新发明。如果能找到这样一种同构领域，应该是一个最好的结果，如果实在找不到，再自己发明。但一般来说，最终一定能在数学层面上找到一个同构领域，有可能只是没找到而已。
In Imperial Length Measurement System,
1 Mile 2 Yard 3 Feet 4 Inch
1 Mile 2 Yard
3 Yard 6 Inch
In Imperial Volume Measurement System,
1 OZ 2 TBSP 3 TSP
15 TSP
Quantity可以映射为行向量(Row Vector)。行向量的维数是计量系统的单位层级数。行向量的分量(Component)自左向右对应的单位层级从大到小。
虽然向量在数学领域有严格的定义，但是在这里我们可以给出一个最直接的定义：把数值罗列起来就是向量。横着罗列就是行向量，竖着罗列就是列向量。
1 Mile 2 Yard 3 Feet 4 Inch -> (1, 2, 3, 4)
1 Mile 2 Yard -> (1, 2, 0, 0)
3 Yard 6 Inch -> (0, 3, 0, 6)
1 OZ 2 TBSP 3 TSP -> (1, 2, 3)
15 TSP -> (0, 0, 15)
1 OZ 2 TSP -> (1, 0, 2)
后续equal、add、normalize、base等操作的语义都基于向量化的Quantity定义。向量化的Quantity以下简称为Quantity向量。
In Imperial Length Measurement System,
1 Mile = 1760 Yard, 1 Yard = 3 Feet, 1 Feet = 12 Inch
In Imperial Volume Measurement System,
1 OZ = 2 TBSP, 1 TBSP = 3 TSP
计量系统的单位换算体系可以分成两个部分：一系列转换因子(Factor)和一系列单位(Unit)。
Factors可以映射为列向量(Column Vector)。列向量的维数设计为计量系统的单位层级数。列向量的分量自上向下对应的单位层级从大到小。
Factors有两种计算方法：
- 步进式(Step-Factors)
- 基准式(Base-Factors)
1 Mile = 1760 Yard, 1 Yard = 3 Feet, 1 Feet = 12 Inch ->
Step-Factors: (0x7fffffff, 1760, 3, 12)T
Base-Factors: (1760 * 3 * 12, 3 * 12, 12, 1)T
1 OZ = 2 TBSP, 1 TBSP = 3 TSP ->
Step-Factors: (0x7fffffff, 2, 3)T
Base-Factors: (2 * 3, 3, 1)T
T: Transposed
对Quantity向量进行**base(基准化)**操作是指：根据Quantity所属计量系统的单位换算体系，将Quantity向量的分量自左向右(从最大单位向最小单位)换算到最小单位(基准单位)的过程。
对Quantity向量进行base操作可以映射为Quantity行向量与Base-Factors列向量的点积。
向量的点积(Dot Product，也叫内积)公式为：
对“1 Mile 2 Yard 3 Feet 4 Inch”进行base操作：
Quantity行向量: (1, 2, 3, 4)
Base-Factors列向量: (1760 * 3 * 12, 3 * 12, 12, 1)T
(1, 2, 3, 4)·(1760 * 3 * 12, 3 * 12, 12, 1)T
= 1 * (1760 * 3 * 12) + 2 * (3 * 12) + 3 * 12 + 4 * 1
= 63472
对“1 Mile 2 Yard 3 Feet 4 Inch”进行base操作的结果是63472。
对“1 OZ 0 TBSP 1 TSP”进行base操作：
Quantity行向量: (1, 0, 1)
Base-Factors列向量: (2 * 3, 3, 1)T
(1, 0, 1)·(2 * 3, 3, 1)T
= 1 * (2 * 3) + 0 * 3 + 1 * 1
= 7
对“1 OZ 0 TBSP 1 TSP”进行base操作的结果是7。
对Quantity向量进行**normalize(规格化)**操作是指：根据Quantity所属计量系统的单位换算体系，将Quantity向量的分量自右向左(从最小单位向最大单位)逐级“进位”的过程。
对Quantity向量进行normalize操作有两种映射方法。
- 方法一：映射为Quantity向量与Step-Factors向量的除法(divide)。
在数学领域中，向量的除法是没有定义的。我们可以根据问题领域的需要增加向量除法这个语义，只要和已有的语义不矛盾就可以。
向量除法的计算要点：不区分行向量和列向量。以两个行向量相除为例。自右向左，将两个向量的分量逐个相除，将余数自右向左存放到结果向量中，将商作为进位(Carry)和紧邻的左边的分量相加，作为被除数继续向左计算。
使用方法一对“24 Inch”进行normalize操作：
Quantity向量: (0, 0, 0, 24)
Step-Factors向量: (0x7fffffff, 1760, 3, 12)
(0, 0, 0, 24) / (0x7fffffff, 1760, 3, 12) = (0, 0, 2, 0)
对“24 Inch”进行normalize(规格化)操作的结果是(0, 0, 2, 0)。
使用方法一对“2 TBSP 1 TSP”进行normalize操作：
Quantity向量: (0, 2, 1)
Step-Factors向量: (0x7fffffff, 2, 3)
(0, 2, 1) / (0x7fffffff, 2, 3) = (1, 0, 1)
对“2 TBSP 1 TSP”进行normalize操作的结果是(1, 0, 1)。
- 方法二：映射为Quantity向量的基准值(Value)与Base-Factors向量的点除(Dot Divide)。
Quantity向量的基准值是指Quantity向量经过base操作以后得到的数值。
在数学领域中，向量的点除是没有定义的。我们可以根据问题领域的需要增加点除这个语义，只要和已有的语义不矛盾就可以。
向量点除的计算要点：自左向右，用数值逐个除以向量的分量，将商自左向右存放到结果向量中，将余数作为被除数继续向右计算。
使用方法二对“24 Inch”进行normalize操作：
Quantity向量: (0, 0, 0, 24)，基准值为24
Base-Factors向量: (1760 * 3 * 12, 3 * 12, 12, 1)
24 ·/ (1760 * 3 * 12, 3 * 12, 12, 1) = (0, 0, 2, 0)
对“24 Inch”进行normalize操作的结果是(0, 0, 2, 0)。
使用方法二对“2 TBSP 1 TSP”进行normalize操作：
Quantity向量: (0, 2, 1)，基准值为7
Base-Factors向量: (2 * 3, 3, 1)
7 ·/ (2 * 3, 3, 1) = (1, 0, 1)
对“2 TBSP 1 TSP”进行normalize操作的结果是(1, 0, 1)。
有两种方法判断两个Quantity向量的相等性。
- 方法一：映射为判断Quantity向量normalize(规格化)后的向量的相等性。
使用方法一判断“1765 Yard 40 Inch”和“1 Mile 5 Yard 3 Feet 4 Inch”的相等性：
Quantity向量1: (0, 1765, 0, 40), normalize后的向量为(1, 6, 0, 4)
Quantity向量2: (1, 5, 3, 4), normalize后的向量为(1, 6, 0, 4)
∵ (1, 6, 0, 4) == (1, 6, 0, 4)
∴ 1765 Yard 40 Inch == 1 Mile 5 Yard 3 Feet 4 Inch
使用方法一判断“2 TBSP 1 TSP”和“1 OZ 1 TSP”的相等性：
Quantity向量1: (0, 2, 1), normalize后的向量为(1, 0, 1)
Quantity向量2: (1, 0, 1), normalize后的向量还是(1, 0, 1)
∵ (1, 0, 1) == (1, 0, 1)
∴ 2 TBSP 1 TSP == 1 OZ 1 TSP
- 方法二：映射为判断Quantity向量base(基准化)后的基准值(Value)的相等性。
映射为判断Quantity向量base(基准化)后的基准值(Value)的相等性。
使用方法二判断“1765 Yard 40 Inch”和“1 Mile 5 Yard 3 Feet 4 Inch”的相等性：
Quantity向量1: (0, 1765, 0, 40), base后的基准值为63580
Quantity向量2: (1, 5, 3, 4), base后的基准值为63580
∵ 63580 == 63580
∴ 1765 Yard 40 Inch == 1 Mile 5 Yard 3 Feet 4 Inch
使用方法二判断“2 TBSP 1 TSP”和“1 OZ 1 TSP” 的相等性：
Quantity向量1: (0, 2, 1), base后的基准值为7
Quantity向量2: (1, 0, 1), base后的基准值为7
∵ 7 == 7
∴ 2 TBSP 1 TSP == 1 OZ 1 TSP
有两种方法对两个Quantity向量进行相加操作。
- 方法一：映射为两个向量相加，并将相加后的向量normalize(规格化)。
向量的加法公式为：
使用方法一对“13 Inch”和“11 Inch”进行相加操作：
Quantity向量1: (0, 0, 0, 13)
Quantity向量2: (0, 0, 0, 11)
(0, 0, 0, 13) + (0, 0, 0, 11) = (0, 0, 0, 24), normalize后的向量为(0, 0, 2, 0)
13 Inch + 11 Inch = 2 Feet
使用方法一对“1 OZ”和“3 TBSP 3 TSP”进行相加操作：
Quantity向量1: (1, 0, 0)
Quantity向量2: (0, 3, 3)
(1, 0, 0) + (0, 3, 3) = (1, 3, 3), normalize后的向量为(3, 0, 0)
1 OZ + 3 TBSP 3 TSP = 3 OZ
- 方法二：映射为Quantity向量base(基准化)后的基准值(Value)相加，并将相加后的值normalize(规格化)。
使用方法二对“13 Inch”和“11 Inch”进行相加操作：
Quantity向量1: (0, 0, 0, 13), base后的基准值为13
Quantity向量2: (0, 0, 0, 11), base后的基准值为11
13 + 11 = 24, normalize后的向量为(0, 0, 2, 0)
13 Inch + 11 Inch = 2 Feet
使用方法二对“1 OZ”和“3 TBSP 3 TSP”进行相加操作：
Quantity向量1: (1, 0, 0), base后的基准值为6
Quantity向量2: (0, 3, 3), base后的基准值为12
6 + 12 = 18, normalize后的向量为(3, 0, 0)
1 OZ + 3 TBSP 3 TSP = 3 OZ
这样，我们就可以把计量系统问题领域映射到“向量空间”的语义领域，或者映射到“向量空间+算术运算”的语义领域。
设计的第二步：形式化地表达语义。
语义(Semantics)需要形式化地表达(Formalize)，否则没法可计算化。一旦要表达，就必须选择一种记法，用符号来表达。可能有很多种表达方式，选择的记法一定要是可计算的，可以教给计算机去做的，而且语义层次还要高。注意先不要考虑如何实现。
System Units: <u1, …, un> System Unit Level: <ul1, …, uln>
Both <*u1, …, un*> and <*ul1, …, uln*> are not vectors,
and not belong to the core semantics domain.
The elements of <*u1, …, un*> are mapped to the elements of <*ul1, …, uln*> one by one.
The n is the number of system unit levels.
uli > ulj (i < j, 1 ≤ i, j ≤ n)
Step-Factors Vector: (0x7fffffff, sfvc2,… , sfvcn)T
The n is the number of system unit levels.
The first component of the step-factors is 0x7fffffff.
The sfvci is the ith component of the step-factors vector.
The components are mapped to the elements of <ul1, …, uln> one by one.
Base-Factors Vector: (bfvc1, … , bfvcn-1, 1)T
The n is the number of system unit levels.
The last component of the base-factors is 1.
The bfvci is the ith component of the base-factors vector.
The components are mapped to the elements of <ul1, …, uln> one by one.
Quantity Vector: (qvc1, qvc2, …, qvcn)
The n is the number of system unit levels.
The qvci is the ith component of the quantity vector.
The components are mapped to the elements of <ul1, …, uln> one by one.
(qvc1, qvc2, …, qvcn)·(bfvc1, … , bfvcn-1, 1)T
Vector Space: (qvc1, qvc2, …, qvcn) / (0x7fffffff, sfvc2,… , sfvcn)
Vector Space + Arithmetic: base (qvc1, qvc2, …, qvcn) ·/ (bfvc1, … , bfvcn-1, 1)
Quantity Vector 1: (qvc1, qvc2, …, qvcn)1
Quantity Vector 2: (qvc1, qvc2, …, qvcn)2
Vector Space: normalize ((qvc1, qvc2, …, qvcn)1) == normalize ((qvc1, qvc2, …, qvcn)2)
Vector Space + Arithmetic: base ((qvc1, qvc2, …, qvcn)1) == base ((qvc1, qvc2, …, qvcn)2)
Quantity Vector 1: (qvc1, qvc2, …, qvcn)1
Quantity Vector 2: (qvc1, qvc2, …, qvcn)2
Vector Space: normalize ((qvc1, qvc2, …, qvcn)1 + (qvc1, qvc2, …, qvcn)2)
Vector Space + Arithmetic: normalize (base (qvc1, qvc2, …, qvcn)1 + base (qvc1, qvc2, …, qvcn)2)
做个小结：
-
以上都是语义层面的，不涉及到任何实现，也是系统的核心。
-
可以看到，通过这样一种方式，不用考虑实现，只需要考虑语义。将计量系统问题领域映射到了“向量空间”或者“向量空间+算术运算”的数学领域。用“向量空间”或者“向量空间+算术运算”的语言形式化地表达问题领域的整个语义模型。还可以根据问题领域的需要增加映射领域中没有的语义，只要和已有的语义不矛盾就可以。
-
两个步骤：
- 找到合适的同构语义领域；
- 用同构语义领域的语言精确地形式化地表达语义。 这就是“建模”的本质。
- 思考一下，这两种映射有何异同？
两种映射都比OO好太多。例如，如果想新增一个单位，两种映射都只需要改一下“Conversion of Units”即可，可如果是OO呢，……。根本原因是两种映射对应的计算模型的语义与计量系统问题领域的根本需求相匹配，而OO则不然。
比较两种映射，映射到“向量空间”的语义层次更高一些。在实现映射到“向量空间和算术运算”语义的时候，需要在两个层次之间上上下下。比如，我们的大脑在计算“1 Mile 2 Yard + 1 Mile 2 Yard ”可能会直接得出 “2 Mile 4 Yard”的结果，而不会说先基准化为Inch，再相加，再规格化。
计量系统的核心计算模型已经有了，现在再来看一下计量系统的外围部分，即计量系统和用户的交互部分Measure System UI (UI：User Interface)。
我们可以为用户提供一套小语言。
用户可以这样告诉我们计量系统的名字和单位换算体系：
Imperial Length
Mile 1760 Yard 3 Feet 12 Inch
Imperial Volume
OZ 2 TBSP 3 TSP
说明：
- 计量系统的名字目前暂时没有用到，只是作为一个系统标识。如果后续继续开发跨计量系统的功能时就会用到了。
- 单位换算体系的格式特点是：按层级从高到低、自左向右排列单位，在单位排列间隔中放置换算因子，中间均以空格分隔。
- 前后或者中间不小心多敲了空格没有关系。
用户可以这样告诉我们计量系统中的数量：
1 Mile 6 Yard 4 Inch
2 OZ 1 TBSP 1 TSP
说明：
- 数量的格式特点是：按层级从高到低、自左向右排列单位，单位的左边放置该单位的量值，中间均以空格分隔。
- 前后或者中间不小心多敲了空格没有关系。
所以，Measure System UI需要提供parse和format功能。
- parse：负责将用户输入的小语言解析成系统核心内部数据结构。
- 将用户输入的“单位换算体系”解析成System Units和Step-Factors Vector
- 将用户输入的“数量”解析成Quantity Vector
- format：负责将系统核心数据结构格式化为满足需求、便于用户理解的小语言。
- 将Quantity Vector格式化
- 将Quantity Vector基准格式化
- System Units只需要保存在Measure System UI中。在Measure System中只需要Step-Factors和Base-Factors。可以将System Units理解为“Labels”，只用于显示，不参与核心计算。
计量系统问题领域 -> “向量空间”语义领域。
计量系统问题领域 -> “向量空间+算术运算”语义领域。
因为系统分了层，所以即使两种映射不一样，Measurement System UI和User都不会受到任何影响，一模一样。
时序图。
实现：选择实现技术把逻辑框架的软件模型实现出来。
在课堂上，我们一起来实现将计量系统问题领域映射到“向量空间”语义领域。将计量系统问题领域映射到“向量空间+算术运算”语义领域实现留作课后作业。
按照系统层次，从下往上实现。这里选用Python语言实现并详细讲解实现过程。其他语言的实现过程是一样的，只是落实到实现语言层面的语言细节略有不同。
代码路径：vector.original
- 有的语言已经提供了向量操作的库，比如Python的numpy包，但需要额外安装。出于练习的目的，我们自己实现向量操作，打造自己的工具箱。
- 用Python语言实现的话，Vector用List数据结构是比较合适的。
- vecop作为向量操作的工具模块，应该是需要考虑参数校验的，但因为不是本次课程的重点，这里就不实现了。
- 虽然两种映射需要的向量操作不太一样，但都可以在vecop中统一实现。
test_all.py
import unittest
from tests.test_vecop import TestVecop
if __name__ == '__main__':
unittest.main()tests.test_vecop.py
import unittest
from vecop import *
class TestVecop(unittest.TestCase):
def test_equal(self):
self.assertTrue(equal([1, 2, 3], [1, 2, 3]))
self.assertTrue(equal([], []))
self.assertFalse(equal([1, 2], [1, 2, 3]))
self.assertFalse(equal([1, 3, 4], [1, 2, 3]))vecop.py
def equal(v1, v2):
return v1 == v2tests.test_vecop.py
def test_add(self):
self.assertEquals([5, 7, 9], add([1, 2, 3], [4, 5, 6]))
self.assertEquals([], add([], []))vecop.py
def add(v1, v2):
return [vc1 + vc2 for (vc1, vc2) in zip(v1, v2)]tests.test_vecop.py
def test_dotproduct(self):
self.assertEquals(102, dotproduct([1, 0, 2], [100, 10, 1]))
self.assertEquals(0, dotproduct([], []))vecop.py
def dotproduct(v1, v2):
return sum([vc1 * vc2 for (vc1, vc2) in zip(v1, v2)])用了loop(div)和reduce(div2)两种方法实现。
tests.test_vecop.py
class TestVecop(unittest.TestCase):
PLACEHOLDER = 0x7FFFFFFF
def test_div(self):
self.assertEquals([0, 0, 2, 0], div([0, 0, 0, 24], [TestVecop.PLACEHOLDER, 1760, 3, 12]))
self.assertEquals([2, 6, 0, 4], div([1, 1765, 0, 40], [TestVecop.PLACEHOLDER, 1760, 3, 12]))
self.assertEquals([0, 0, 2, 0], div2([0, 0, 0, 24], [TestVecop.PLACEHOLDER, 1760, 3, 12]))
self.assertEquals([2, 6, 0, 4], div2([1, 1765, 0, 40], [TestVecop.PLACEHOLDER, 1760, 3, 12]))vecop.py
def div(v1, v2):
result = []
quotient = 0
for (vc1, vc2) in zip(v1[::-1], v2[::-1]):
dividend = vc1 + quotient
divisor = vc2
quotient = dividend / divisor
result.append(dividend % divisor)
return result[::-1]
def div2(v1, v2):
def acc_div2((result, wquotient), (vc1, vc2)):
dividend = vc1 + wquotient[0]
divisor = vc2
wquotient[0] = dividend / divisor
result.append(dividend % divisor)
return result, wquotient
return reduce(acc_div2, zip(v1[::-1], v2[::-1]), ([], [0]))[0][::-1]用了loop(dotdiv)和reduce(dotdiv2)两种方法实现。
tests.test_vecop.py
def test_dotdiv(self):
self.assertEquals([1, 0, 2], dotdiv(102, [100, 10, 1]))
self.assertEquals([1, 0, 2], dotdiv2(102, [100, 10, 1]))vecop.py
def dotdiv(c, v):
result = []
remainder = c
for vc in v:
quotient = remainder / vc
remainder = remainder % vc
result.append(quotient)
return result
def dotdiv2(c, v):
def acc_dotdiv2((v, wc), vc):
quotient = wc[0] / vc
wc[0] = wc[0] % vc
v.append(quotient)
return v, wc
return reduce(acc_dotdiv2, v, [[], [c]])[0]根据之前的设计，measuresystem接收stepfactors，但在measuresystem内部还会用到basefactors，所以要将stepfactors转换成basefactors。
用了loop(basefactors)和reduce(basefactors2)两种方法实现。
test_all.py
from tests.test_measuresystem import TestMeasuresystemtests.test_measuresystem.py
import unittest
from measuresystem import *
class TestMeasuresystem(unittest.TestCase):
STEPFACTORS = [0x7FFFFFFF, 1760, 3, 12]
BASEFACTORS = [1760 * 3 * 12, 3 * 12, 12, 1]
def test_basefactors(self):
self.assertEquals(TestMeasuresystem.BASEFACTORS,
basefactors(TestMeasuresystem.STEPFACTORS))
self.assertEquals(TestMeasuresystem.BASEFACTORS,
basefactors2(TestMeasuresystem.STEPFACTORS))measuresystem.py
def basefactors(stepfactors):
result = []
for (i, stepfactor) in enumerate(stepfactors):
result.append(reduce(lambda x, y: x * y, stepfactors[i + 1:], 1))
return result
def basefactors2(stepfactors):
def acc_basefactors2(acc, stepfactor):
acc.append(acc[-1] * stepfactor)
return acc
return reduce(acc_basefactors2, stepfactors[::-1][:-1], [1])[::-1]tests.test_measuresystem.py
def test_base(self):
self.assertEquals(63472, base([1, 2, 3, 4], TestMeasuresystem.BASEFACTORS))
self.assertEquals(63396, base([1, 0, 3, 0], TestMeasuresystem.BASEFACTORS))measuresystem.py
import vecop
def base(quantityvec, basefactors):
return vecop.dotproduct(quantityvec, basefactors)要实现equal，需要先实现normalize。
tests.test_measuresystem.py
def test_normalize(self):
self.assertEquals([1, 4, 0, 1],
normalize([0, 1762, 5, 13], TestMeasuresystem.STEPFACTORS))measuresystem.py
def normalize(quantityvec, stepfactors):
return vecop.div(quantityvec, stepfactors)tests.test_measuresystem.py
def test_equal(self):
self.assertTrue(equal([1, 2, 3, 4], [0, 0, 0, 63472], TestMeasuresystem.STEPFACTORS))
self.assertTrue(equal([0, 1765, 0, 40], [1, 6, 0, 4], TestMeasuresystem.STEPFACTORS))
self.assertFalse(equal([0, 1765, 0, 41], [1, 6, 0, 4], TestMeasuresystem.STEPFACTORS))measuresystem.py
def equal(quantityvec1, quantityvec2, stepfactors):
return vecop.equal(normalize(quantityvec1, stepfactors),
normalize(quantityvec2, stepfactors))tests.test_measuresystem.py
def test_add(self):
self.assertEquals([0, 0, 2, 0],
add([0, 0, 0, 13], [0, 0, 0, 11], TestMeasuresystem.STEPFACTORS))
self.assertEquals([0, 3, 0, 0],
add([0, 0, 3, 0], [0, 2, 0, 0], TestMeasuresystem.STEPFACTORS))measuresystem.py
def add(quantityvec1, quantityvec2, stepfactors):
return normalize(vecop.add(quantityvec1, quantityvec2), stepfactors)根据之前的设计，measuresystem_ui接收单位换算体系(Conversion of Units)的描述，要从传入的unitconversion_desc中解析出sysunits和stepfactors。
用了loop(parse_unitconversion_desc)和reduce(parse_unitconversion_desc2)两种方法实现。
test_all.py
from tests.test_measuresystem_ui import TestMeasuresystemUItests.test_measuresystem_ui.py
import unittest
from measuresystem_ui import *
class TestMeasuresystemUI(unittest.TestCase):
STEPFACTORS = [0x7FFFFFFF, 1760, 3, 12]
SYSUNITS = ['Mile', 'Yard', 'Feet', 'Inch']
def test_parse_unitconversion_desc(self):
self.assertEquals((TestMeasuresystemUI.STEPFACTORS, TestMeasuresystemUI.SYSUNITS),
parse_unitconversion_desc(' Mile 1760 Yard 3 Feet 12 Inch '))
self.assertEquals((TestMeasuresystemUI.STEPFACTORS, TestMeasuresystemUI.SYSUNITS),
parse_unitconversion_desc2(' Mile 1760 Yard 3 Feet 12 Inch '))measuresystem_ui.py
import re
import string
PLACEHOLDER = 0x7FFFFFFF
def parse_unitconversion_desc(desc):
tokens = re.split(r' +', string.strip(desc))
stepfactors = [PLACEHOLDER]
sysunits = []
for token in tokens:
sysunits.append(token) if evenindex(token, tokens) else stepfactors.append(int(token))
return stepfactors, sysunits
def parse_unitconversion_desc2(desc):
def acc_parse_unitconversion_desc2((stepfactors, sysunits, tokens), token):
sysunits.append(token) if evenindex(token, tokens) else stepfactors.append(int(token))
return stepfactors, sysunits, tokens
tokens = re.split(r' +', string.strip(desc))
(stepfactors, sysunits, tokens) = reduce(acc_parse_unitconversion_desc2, tokens, ([PLACEHOLDER], [], tokens))
return stepfactors, sysunits
def evenindex(token, tokens):
return tokens.index(token) % 2 == 0根据之前的设计，用户在调用measuresystem_ui提供的equal()和add()等函数时，会传入数量(Quantity)的描述，需要先解析为Quantity Vector。
用了loop(parse_quantity_desc)和reduce(parse_quantity_desc2)两种方法实现。
tests.test_measuresystem_ui.py
def test_parse_quantity_desc(self):
self.assertEquals([1, 2, 3, 4], parse_quantity_desc(' 1 Mile 2 Yard 3 Feet 4 Inch ', TestMeasuresystemUI.SYSUNITS))
self.assertEquals([1, 2, 0, 4], parse_quantity_desc('1 Mile 4 Inch 2 Yard', TestMeasuresystemUI.SYSUNITS))
self.assertEquals([1, 2, 0, 4], parse_quantity_desc('1 Mile 2 Yard 4 Inch', TestMeasuresystemUI.SYSUNITS))
self.assertEquals([0, 0, 3, 0], parse_quantity_desc('3 Feet', TestMeasuresystemUI.SYSUNITS))
self.assertEquals([1, 2, 3, 4], parse_quantity_desc2(' 1 Mile 2 Yard 3 Feet 4 Inch ', TestMeasuresystemUI.SYSUNITS))
self.assertEquals([1, 2, 0, 4], parse_quantity_desc2('1 Mile 4 Inch 2 Yard', TestMeasuresystemUI.SYSUNITS))
self.assertEquals([1, 2, 0, 4], parse_quantity_desc2('1 Mile 2 Yard 4 Inch', TestMeasuresystemUI.SYSUNITS))
self.assertEquals([0, 0, 3, 0], parse_quantity_desc2('3 Feet', TestMeasuresystemUI.SYSUNITS))measuresystem_ui.py
def parse_quantity_desc(desc, sysunits):
tokens = re.split(r' +', string.strip(desc))
values = []
units = []
for token in tokens:
values.append(int(token)) if evenindex(token, tokens) else units.append(token)
return [values[units.index(sysunit)] if sysunit in units else 0 for sysunit in sysunits]
def parse_quantity_desc2(desc, sysunits):
def acc_parse_quantity_desc2((values, units, tokens), token):
values.append(int(token)) if evenindex(token, tokens) else units.append(token)
return values, units, tokens
tokens = re.split(r' +', string.strip(desc))
(values, units, tokens) = reduce(acc_parse_quantity_desc2, tokens, ([], [], tokens))
return [values[units.index(sysunit)] if sysunit in units else 0 for sysunit in sysunits]parse_unitconversion_desc()函数和parse_quantity_desc()函数之间存在重复代码，抽取tokenize()、partitioning_by_index_parity()、ints()、_acc_parse_desc()等函数去除重复。
measuresystem_ui.py
def parse_unitconversion_desc(desc):
(sysunits, stepfactorstrs) = partitioning_by_index_parity(tokenize(desc))
stepfactors = ints(stepfactorstrs)
stepfactors.insert(0, PLACEHOLDER)
return stepfactors, sysunits
def parse_unitconversion_desc2(desc):
tokens = tokenize(desc)
(sysunits, stepfactorstrs, tokens) = reduce(_acc_parse_desc, tokens, ([], [], tokens))
stepfactors = ints(stepfactorstrs)
stepfactors.insert(0, PLACEHOLDER)
return stepfactors, sysunits
def parse_quantity_desc(desc, sysunits):
(valuestrs, units) = partitioning_by_index_parity(tokenize(desc))
values = ints(valuestrs)
return [values[units.index(sysunit)] if sysunit in units else 0 for sysunit in sysunits]
def parse_quantity_desc2(desc, sysunits):
tokens = tokenize(desc)
(valuestrs, units, tokens) = reduce(_acc_parse_desc, tokens, ([], [], tokens))
values = ints(valuestrs)
return [values[units.index(sysunit)] if sysunit in units else 0 for sysunit in sysunits]
def tokenize(desc):
return re.split(r' +', string.strip(desc))
def partitioning_by_index_parity(tokens):
part1 = []
part2 = []
for token in tokens:
part1.append(token) if evenindex(token, tokens) else part2.append(token)
return part1, part2
def ints(strs):
return [int(s) for s in strs]
def _acc_parse_desc((part1, part2, tokens), token):
part1.append(token) if evenindex(token, tokens) else part2.append(token)
return part1, part2, tokenstests.test_measuresystem_ui.py
def test_equal(self):
self.assertTrue(equal('1 Mile 2 Yard 3 Feet 4 Inch', '63472 Inch',
TestMeasuresystemUI.SYSUNITS, TestMeasuresystemUI.STEPFACTORS))
self.assertTrue(equal('1765 Yard 40 Inch', '1 Mile 6 Yard 4 Inch',
TestMeasuresystemUI.SYSUNITS, TestMeasuresystemUI.STEPFACTORS))
self.assertFalse(equal('1765 Yard 41 Inch', '1 Mile 6 Yard 4 Inch',
TestMeasuresystemUI.SYSUNITS, TestMeasuresystemUI.STEPFACTORS))measuresystem_ui.py
import measuresystem as ms
def equal(quantitydesc1, quantitydesc2, sysunits, stepfactors):
return ms.equal(parse_quantity_desc(quantitydesc1, sysunits),
parse_quantity_desc(quantitydesc2, sysunits),
stepfactors)tests.test_measuresystem_ui.py
def test_format(self):
self.assertEquals('1 Mile 3 Yard 4 Inch', format([1, 3, 0, 4], TestMeasuresystemUI.SYSUNITS))
self.assertEquals('2 Feet 0 Inch', format([0, 0, 2, 0], TestMeasuresystemUI.SYSUNITS))measuresystem_ui.py
def format(quantityvec, sysunits):
valueunits = [' '.join([str(value), unit])
for (value, unit) in zip(quantityvec, sysunits)
if value != 0 or unit == sysunits[-1]]
return ' '.join(valueunits)tests.test_measuresystem_ui.py
def test_add(self):
self.assertEquals('2 Feet 0 Inch',
add('13 Inch', '11 Inch',
TestMeasuresystemUI.SYSUNITS, TestMeasuresystemUI.STEPFACTORS))
self.assertEquals('3 Yard 0 Inch',
add('3 Feet', '2 Yard',
TestMeasuresystemUI.SYSUNITS, TestMeasuresystemUI.STEPFACTORS))measuresystem_ui.py
def add(quantitydesc1, quantitydesc2, sysunits, stepfactors):
return format(ms.add(parse_quantity_desc(quantitydesc1, sysunits),
parse_quantity_desc(quantitydesc2, sysunits), stepfactors),
sysunits)tests.test_measuresystem_ui.py
def test_base_format(self):
self.assertEquals('63472 Inch',
base_format([1, 3, 0, 4],
TestMeasuresystemUI.SYSUNITS, TestMeasuresystemUI.STEPFACTORS))measuresystem_ui.py
def base_format(quantityvec, sysunits, stepfactors):
basevalue = str(ms.base(quantityvec, ms.basefactors(stepfactors)))
return ' '.join([basevalue, sysunits[-1]])measuresystem_ui.py
if __name__ == '__main__':
implen_stepfactors, implen_sysunits = parse_unitconversion_desc('Mile 1760 Yard 3 Feet 12 Inch')
r1 = equal("1765 Yard 40 Inch", "1 Mile 6 Yard 4 Inch", implen_sysunits, implen_stepfactors)
print '1765 Yard 40 Inch == 1 Mile 6 Yard 4 Inch ? %s' % (r1)
r2 = add('13 Inch', '11 Inch', implen_sysunits, implen_stepfactors)
print '13 Inch + 11 Inch = %s' % (r2)
impvol_stepfactors, impvol_sysunits = parse_unitconversion_desc('OZ 2 TBSP 3 TSP')
r3 = equal('1 OZ 10 TSP', '2 OZ 1 TBSP 1 TSP', impvol_sysunits, impvol_stepfactors)
print '1 OZ 10 TSP == 2 OZ 1 TBSP 1 TSP ? %s' % (r3)
r4 = add('1 OZ', '3 TBSP 3 TSP', impvol_sysunits, impvol_stepfactors)
print '1 OZ + 3 TBSP 3 TSP = %s' % (r4)运行结果如下：
1765 Yard 40 Inch == 1 Mile 6 Yard 4 Inch ? True
13 Inch + 11 Inch = 2 Feet 0 Inch
1 OZ 10 TSP == 2 OZ 1 TBSP 1 TSP ? True
1 OZ + 3 TBSP 3 TSP = 3 OZ 0 TSP
设计就是把问题变成可计算的。
设计出的计算模型所提供的语义和问题领域的根本需求是否匹配，匹配就是好的设计，不匹配就是不好的设计。
- 对问题领域进行深入分析，发现问题领域的核心需求；
- 通过核心需求驱动出计算模型和语义；
- 再围绕这个计算模型提供一套语言，给外面的人使用这个计算模型提供一个接口，这个接口可以是API、可以是数据表达、也可以是语言；
- 最终要实现这个计算模型，实现的方法有解释器和编译器两种。
这就是DDD！这才是DDD！
这就是DSL！这才是DSL！
| “编程”不过是在某个计算模型上用某种语言去表达计算。 | 用DSL编程不过是在问题领域的计算模型上用DSL来表达计算。 |
| 计算模型是相应领域中的“通用机器”。 | 问题领域的计算模型是问题领域的通用机器。 |
| 编程语言不过是描述计算机器的一种方法。 | DSL描述的是DSL语言的计算机器。 |
| 程序是对特定机器的描述，这个特定机器可以被通用机器仿真。 | 用DSL程序实现了问题领域中的某个功能，这个DSL程序就是对这个功能(特定机器)的描述。 |
- 从问题领域导出核心需求，得到领域的计算模型(通用计算机器)，在上面可以包装一个DSL语言或者数据或者API，基于这些开发程序和应用。
- 领域的计算模型和通用语言的计算模型之间存在鸿沟，可以用解释器或者编译器来填补。
- 解释器和编译器听起来很复杂，其实思想很简单，而且我们没有必要实现一个工业级别的、非常全面的解释器和编译器，只要借鉴这个思想实现我们的计算模型就够了。
Common Languages(Java/C) UML对应Java/C/Python通用语言。
Common Languages(Java/C) UM对应Java/C/Python通用语言提供的计算模型(通用计算机器)。
提升设计能力的根本在于提升计算模型构造和语义定义能力。
Thinking, thinking and thinking …
Practice, practice and practice …
No shortcuts.
- 【必选】增加时间的单位换算体系“1 Day = 24 Hour，1 Hour = 60 Minute，1 Minute = 60 Second”，以下表达式的计算结果是什么？
7 Hour 59 Minute 60 Second == 8 Hour ?
1 Day 23 Hour 59 Minute 59 Second + 1 Second = ?
- 【必选】假设英制长度的单位换算体系由“1 Mile = 1760 Yard，1 Yard = 3 Feet，1 Feet = 12 Inch”改为“1 Mile = 4 Miya，1 Miya = 440 Yard，1 Yard = 3 Feet，1 Feet = 12 Inch”，以下表达式的计算结果是什么？
4 Miya 446 Yard 40 Inch == 1 Mile 1 Miya 7 Yard 4 Inch ?
3 Miya 13 Inch + 445 Yard 11 Inch = ?
- 【必选】任意长度对象或容量对象可以被放大N倍，其中N为大于等于0的整数，放大以后还可以和其它任意长度或容量对象进行加法运算。例如：
2 * 2 Yard 3 Feet = 6 Yard 0 Inch
3 * 1 OZ 10 TSP = 8 OZ 0 TSP
2 * 2 Yard 3 Feet + 13 Inch = 6 Yard 1 Feet 1 Inch
3 * 1 OZ 10 TSP + 3 TBSP 1 TSP = 9 OZ 1 TBSP 1 TSP
提示：这里会用到向量的标量乘法(scale)，公式如下：
其中，c为任意常数。
- 【可选】实现将计量系统问题领域映射到“向量空间+算术运算”领域的设计。
【必选】增加时间的单位换算体系“1 Day = 24 Hour，1 Hour = 60 Minute，1 Minute = 60 Second”，以下表达式的计算结果是什么？
7 Hour 59 Minute 60 Second == 8 Hour ?
1 Day 23 Hour 59 Minute 59 Second + 1 Second = ?
measuresystem_ui.py
if __name__ == '__main__':
...
time_stepfactors, time_sysunits = parse_unitconversion_desc('Day 24 Hour 60 Minute 60 Second')
r5 = equal('7 Hour 59 Minute 60 Second', '8 Hour', time_sysunits, time_stepfactors)
print '7 Hour 59 Minute 60 Second == 8 Hour ? %s' % (r5)
r6 = add('1 Day 23 Hour 59 Minute 59 Second', '1 Second', time_sysunits, time_stepfactors)
print '1 Day 23 Hour 59 Minute 59 Second + 1 Second = %s' % (r6)运行结果如下：
7 Hour 59 Minute 60 Second == 8 Hour ? True
1 Day 23 Hour 59 Minute 59 Second + 1 Second = 2 Day 0 Second
【必选】假设英制长度的单位换算体系由“1 Mile = 1760 Yard，1 Yard = 3 Feet，1 Feet = 12 Inch”改为“1 Mile = 4 Miya，1 Miya = 440 Yard，1 Yard = 3 Feet，1 Feet = 12 Inch”，以下表达式的计算结果是什么？
4 Miya 446 Yard 40 Inch == 1 Mile 1 Miya 7 Yard 4 Inch ?
3 Miya 13 Inch + 445 Yard 11 Inch = ?
measuresystem_ui.py
if __name__ == '__main__':
...
implen2_stepfactors, implen2_sysunits = parse_unitconversion_desc('Mile 4 Miya 440 Yard 3 Feet 12 Inch')
r7 = equal('4 Miya 446 Yard 40 Inch', '1 Mile 1 Miya 7 Yard 4 Inch', implen2_sysunits, implen2_stepfactors)
print '4 Miya 446 Yard 40 Inch == 1 Mile 1 Miya 7 Yard 4 Inch ? %s' % (r7)
r8 = add('3 Miya 13 Inch', '445 Yard 11 Inch', implen2_sysunits, implen2_stepfactors)
print '3 Miya 13 Inch + 445 Yard 11 Inch = %s' % (r8)运行结果如下：
4 Miya 446 Yard 40 Inch == 1 Mile 1 Miya 7 Yard 4 Inch ? True
3 Miya 13 Inch + 445 Yard 11 Inch = 1 Mile 5 Yard 2 Feet 0 Inch
【必选】任意长度对象或容量对象可以被放大N倍，其中N为大于等于0的整数，放大以后还可以和其它任意长度或容量对象进行加法运算。例如：
2 * 2 Yard 3 Feet = 6 Yard 0 Inch
3 * 1 OZ 10 TSP = 8 OZ 0 TSP
2 * 2 Yard 3 Feet + 13 Inch = 6 Yard 1 Feet 1 Inch
3 * 1 OZ 10 TSP + 3 TBSP 1 TSP = 9 OZ 1 TBSP 1 TSP
代码路径：vector.scale
tests.test_vecop.py
def test_scale(self):
self.assertEquals([2, 4, 6], scale(2, [1, 2, 3]))
self.assertEquals([0, 0], scale(0, [1, 2]))
self.assertEquals([], scale(2, []))vecop.py
def scale(c, v):
return [c * vc for vc in v]tests.test_measuresystem.py
def test_scale(self):
self.assertEquals([0, 6, 0, 0], scale(2, [0, 2, 3, 0], TestMeasuresystem.STEPFACTORS))
self.assertEquals([0, 6, 1, 2], scale(2, [0, 2, 3, 7], TestMeasuresystem.STEPFACTORS))measuresystem.py
def scale(c, quantityvec, stepfactors):
return normalize(vecop.scale(c, quantityvec), stepfactors)tests.test_measuresystem_ui.py
def test_scale(self):
self.assertEquals('6 Yard 0 Inch',
scale('2', '2 Yard 3 Feet',
TestMeasuresystemUI.SYSUNITS, TestMeasuresystemUI.STEPFACTORS))
self.assertEquals('6 Yard 1 Feet 2 Inch',
scale('2', '2 Yard 3 Feet 7 Inch',
TestMeasuresystemUI.SYSUNITS, TestMeasuresystemUI.STEPFACTORS))measuresystem_ui.py
def scale(c, quantitydesc, sysunits, stepfactors):
return format(ms.scale(int(c), parse_quantity_desc(quantitydesc, sysunits), stepfactors), sysunits)
if __name__ == '__main__':
...
r9 = scale('2', '2 Yard 3 Feet', implen_sysunits, implen_stepfactors)
print '2 * 2 Yard 3 Feet = %s' % (r9)
r10 = add(scale('2', '2 Yard 3 Feet', implen_sysunits, implen_stepfactors), '13 Inch',
implen_sysunits, implen_stepfactors)
print '2 * 2 Yard 3 Feet + 13 Inch = %s' % (r10)
r11 = scale('3', '1 OZ 10 TSP', impvol_sysunits, impvol_stepfactors)
print '3 * 1 OZ 10 TSP = %s' % (r11)
r12 = add(scale('3', '1 OZ 10 TSP', impvol_sysunits, impvol_stepfactors), '3 TBSP 1 TSP',
impvol_sysunits, impvol_stepfactors)
print '3 * 1 OZ 10 TSP + 3 TBSP 1 TSP = %s' % (r12)运行结果如下：
2 * 2 Yard 3 Feet = 6 Yard 0 Inch
2 * 2 Yard 3 Feet + 13 Inch = 6 Yard 1 Feet 1 Inch
3 * 1 OZ 10 TSP = 8 OZ 0 TSP
3 * 1 OZ 10 TSP + 3 TBSP 1 TSP = 9 OZ 1 TBSP 1 TSP
映射到“向量空间+算术运算”的实现与映射到“向量空间”的实现相比较，最底层的vecop不用修改。measuresystem的测试代码和产品代码需要修改。measuresystem_ui的测试代码不需要修改，产品代码因为measuresystem的修改需要修改。
代码路径：vecarith
equal不再依赖于normalize。equal()方法不再传入stepfactors而是传入basefactors。
tests.test_measuresystem.py
def test_equal(self):
self.assertTrue(equal([1, 2, 3, 4], [0, 0, 0, 63472], TestMeasuresystem.BASEFACTORS))
self.assertTrue(equal([0, 1765, 0, 40], [1, 6, 0, 4], TestMeasuresystem.BASEFACTORS))
self.assertFalse(equal([0, 1765, 0, 41], [1, 6, 0, 4], TestMeasuresystem.BASEFACTORS))measuresystem.py
def equal(quantityvec1, quantityvec2, basefactors):
return base(quantityvec1, basefactors) == base(quantityvec2, basefactors)measuresystem_ui.py。需要将stepfactors转换为basefactors。
def equal(quantitydesc1, quantitydesc2, sysunits, stepfactors):
return ms.equal(parse_quantity_desc(quantitydesc1, sysunits),
parse_quantity_desc(quantitydesc2, sysunits),
ms.basefactors(stepfactors))normalize()不再传入数量向量和stepfactors而是传入数量数值和basefactors。
tests.test_measuresystem.py
def test_normalize(self):
self.assertEquals([1, 4, 0, 1],
normalize(63505, TestMeasuresystem.BASEFACTORS))measuresystem.py
def normalize(quantityvalue, basefactors):
return vecop.dotdiv(quantityvalue, basefactors)此时，measuresystem和measuresystem_ui中add()和scale()因为都调用了normalize()还没来得及修改，相关测试用例需要先暂时注释掉，再一个一个放开。
add()不再传入stepfactors而是传入basefactors。
tests.test_measuresystem.py
def test_add(self):
self.assertEquals([0, 0, 2, 0],
add([0, 0, 0, 13], [0, 0, 0, 11], TestMeasuresystem.BASEFACTORS))
self.assertEquals([0, 3, 0, 0],
add([0, 0, 3, 0], [0, 2, 0, 0], TestMeasuresystem.BASEFACTORS))measuresystem.py
def add(quantityvec1, quantityvec2, basefactors):
return normalize(base(quantityvec1, basefactors) + base(quantityvec2, basefactors), basefactors)measuresystem_ui.py。需要将stepfactors转换为basefactors。
def add(quantitydesc1, quantitydesc2, sysunits, stepfactors):
return format(ms.add(parse_quantity_desc(quantitydesc1, sysunits),
parse_quantity_desc(quantitydesc2, sysunits), ms.basefactors(stepfactors)),
sysunits)scale()不再传入stepfactors而是传入basefactors。
tests.test_measuresystem.py
def test_scale(self):
self.assertEquals([0, 6, 0, 0], scale(2, [0, 2, 3, 0], TestMeasuresystem.BASEFACTORS))
self.assertEquals([0, 6, 1, 2], scale(2, [0, 2, 3, 7], TestMeasuresystem.BASEFACTORS))measuresystem.py
def scale(c, quantityvec, basefactors):
return normalize(c * base(quantityvec, basefactors), basefactors)measuresystem_ui.py。需要将stepfactors转换为basefactors。
def scale(c, quantitydesc, sysunits, stepfactors):
return format(ms.scale(int(c), parse_quantity_desc(quantitydesc, sysunits), ms.basefactors(stepfactors)), sysunits)