Skip to content

Commit 7acfae8

Browse files
BeardedManZhaoBeardedManZhao
authored
1.31 版本发布 (#20)
* update * update * update * update * update * update * update * update * update * 1.26版本发布 * 1.27 版本发布 * update * 1.28 版本发布 * Update README.md * 修复向量不能自动刷新的问题 * 1.29 版本发布 * 帮助信息的获取使用备份链接 在 1.30 版本中会启用此链接 * 1.3.0版本开始开发 * update * 1.30版本发布 * 1.31 版本开始开发 * update * 1.31 版本发布
1 parent d4f2792 commit 7acfae8

21 files changed

+923
-406
lines changed

‎AsLib/libBeardedManZhao.dll

0 Bytes
Binary file not shown.

‎README-Chinese.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@ AS库目录有多个版本，如果希望查询不同版本的更新日志以及
2323
<dependency>
2424
<groupId>io.github.BeardedManZhao</groupId>
2525
<artifactId>algorithmStar</artifactId>
26-
<version>1.30</version>
26+
<version>1.31</version>
2727
</dependency>
2828
</dependencies>
2929
```

‎README.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ can add it to your maven project, or you can download it from Releases and manua
2929
<dependency>
3030
<groupId>io.github.BeardedManZhao</groupId>
3131
<artifactId>algorithmStar</artifactId>
32-
<version>1.30</version>
32+
<version>1.31</version>
3333
</dependency>
3434
</dependencies>
3535
```

‎src_code/README-Chinese.md

Lines changed: 64 additions & 122 deletions
Original file line numberDiff line numberDiff line change
@@ -8,152 +8,94 @@
88

99
### 更新日志
1010

11-
* 框架版本：1.29 - 1.30
12-
* 新增单位数值类操作数，此操作数可以实现基本计算，同时还可以实现带有单位的计算效果，其还具有单位转换操作，且允许自定义单位!!!
13-
* 内置了 BaseValue 类，其可以实现加减乘除运算，同时还支持单位数值的转换，可以直接使用
11+
* 框架版本：1.30 - 1.31
12+
* 针对单位数值中的减法进行修复，被减数与减数之间的位置进行的矫正
13+
* 针对单位数值中的乘除算法进行升级，您在自定义单位数值的时候可以通过在 `@BaseUnit` 中指定了 `needUnifiedUnit`
14+
属性，来决定计算乘除的时候是否需要进行单位统一，这有利于区分数值计算和物理计算，物理计算需要保持单位一致
15+
* 针对内置的单位数值进行矫正和升级，对于物理单位和数学单位能够实现各自的计算
16+
* 针对内置单位数值 `DateValue` 进行升级，其可以接收更多的时间单位
1417

1518
```java
1619
package zhao.algorithmMagic;
1720

1821
import zhao.algorithmMagic.core.AlgorithmStar;
1922
import zhao.algorithmMagic.core.BaseValueFactory;
2023
import zhao.algorithmMagic.operands.unit.BaseValue;
21-
22-
import java.net.MalformedURLException;
24+
import zhao.algorithmMagic.operands.unit.DateValue;
2325

2426
public class MAIN1 {
25-
public static void main(String[] args) {
26-
// 构建一个用来创建 BaseValue.class 的工厂类 TODO 这里的类型可以是其它的 但是要确保是 BaseValue 的子类
27-
final BaseValueFactory baseValueFactory = AlgorithmStar.baseValueFactory(BaseValue.class);
28-
// 获取到数值
29-
final BaseValue number_1 = baseValueFactory.parse(200);
30-
System.out.println("number_1 = " + number_1);
31-
final BaseValue number_2 = baseValueFactory.parse(1024);
32-
System.out.println("number_2 = " + number_2);
33-
34-
// 基本的运算演示
35-
System.out.println("============");
36-
System.out.println(number_2 + " + " + number_1 + " = " + number_1.add(number_2));
37-
System.out.println(number_2 + " + " + 2 + number_2.getNowBase().getValue() + " = " + number_2.add(2));
38-
39-
System.out.println("============");
40-
System.out.println(number_2 + " - " + number_1 + " = " + number_1.diff(number_2));
41-
System.out.println(number_2 + " - " + 2 + number_2.getNowBase().getValue() + " = " + number_2.diff(2));
42-
43-
System.out.println("============");
44-
System.out.println(number_2 + " * " + number_1 + " = " + number_1.multiply(number_2));
45-
System.out.println(number_2 + " * " + 2 + number_2.getNowBase().getValue() + " = " + number_2.multiply(2));
46-
47-
System.out.println("============");
48-
System.out.println(number_2 + " / " + number_1 + " = " + number_1.divide(number_2));
49-
System.out.println(number_2 + " / " + 2 + number_2.getNowBase().getValue() + " = " + number_2.divide(2));
50-
51-
// 将 1.024千 转换为 10.24百 和 0.1024 万
52-
System.out.println("============");
53-
System.out.println(number_2.switchUnits("百"));
54-
System.out.println(number_2.switchUnits("万"));
55-
}
56-
}
57-
58-
```
59-
60-
* 如果需要自定义单位，可以直接继承 BaseValue 类，然后标注 BaseUnit 注解即可，下面是一个基本的实例（下面的类也已经加入到了AS库）
61-
* 继承 BaseValue 并重写静态的 parse 函数
62-
* 标注 BaseUnit 注解 在其中设置单位 与 进制值
63-
64-
```java
65-
package zhao.algorithmMagic.operands.unit;
66-
67-
import zhao.algorithmMagic.utils.dataContainer.KeyValue;
68-
69-
/**
70-
* 重量单位数值，在这里可以直接使用重量相关的单位！
71-
*
72-
* Weight unit value, weight related units can be directly used here!
73-
* @author zhao
74-
*/
75-
@BaseUnit(value = {
76-
"t（吨）", "kg（千克）", "g（克）", "mg（毫克）", "ug（微克）", "ng（纳克）", "pg（皮克）", "fg（飞克）"
77-
}, baseValue = 1000)
78-
public class WeightValue extends BaseValue {
79-
80-
protected WeightValue(double valueNumber, Class<? extends BaseValue> c, KeyValue<Integer, String> baseNameKeyValue) {
81-
super(valueNumber, c, baseNameKeyValue);
82-
}
8327

84-
/**
85-
* @param valueNumber 需要被解析的数值
86-
* <p>
87-
* Value that needs to be parsed
88-
* @return 解析之后的单位数值对象
89-
* <p>
90-
* Parsed Unit Value Object
91-
*/
92-
public static BaseValue parse(double valueNumber) {
93-
return parse(valueNumber, null);
94-
}
95-
96-
/**
97-
* @param valueNumber 需要被解析的数值
98-
* <p>
99-
* Value that needs to be parsed
100-
* @param baseNameKeyValue 单位的键值对，如果您需要指定数值的单位，您可以在这里进行指定，如果您不需要可以直接设置为 null，请注意 如果您不设置为null 此操作将不会对数值进行任何化简.
101-
* <p>
102-
* The key value pairs of units. If you need to specify the unit of a numerical value, you can specify it here. If you don't need it, you can directly set it to null. Please note that if you don't set it to null, this operation will not simplify the numerical value in any way.
103-
* @return 解析之后的单位数值对象
104-
* <p>
105-
* Parsed Unit Value Object
106-
*/
107-
protected static BaseValue parse(double valueNumber, KeyValue<Integer, String> baseNameKeyValue) {
108-
return new BaseValue(valueNumber, WeightValue.class, baseNameKeyValue);
109-
}
28+
public static void main(String[] args) {
29+
// 在这里我们获取到的就是单位数值的工厂类 在这里的函数参数是工厂要构造的单位数值的类型
30+
// 请确保您在这里提供的单位数值类具有 @BaseUnit 注解和 parse 函数
31+
// 内置的单位数值类都是有 @BaseUnit 注解和 parse 函数的，如果您有自定义单位数值的需求需要注意
32+
final BaseValueFactory baseValueFactory = AlgorithmStar.baseValueFactory(DateValue.class);
33+
final BaseValue parse1 = baseValueFactory.parse(2000);
34+
// 使用工厂类 准备一个时间对象 这里的单位是毫秒开始的 所以这个数值是 1.024 秒
35+
final BaseValue parse2 = baseValueFactory.parse(1024);
36+
// 在这里我们再构建一个 1 天
37+
final BaseValue parse3 = baseValueFactory.parse(24 * 60 * 60 * 1000);
38+
System.out.println(parse3);
39+
40+
// 打印结果
41+
System.out.println(parse2);
42+
// 计算 1.024 秒 / 2
43+
System.out.println(parse2.divide(2));
44+
// 计算 1.024 秒 / 2000 毫秒 如果 isNeedUnifiedUnit = true 代表的这里会先将 单位统一然后再计算
45+
// TODO 针对乘除法来说 一般可能不需要带着单位计算哦！
46+
System.out.println(parse2.divide(parse1));
47+
// 计算 1天 * 2
48+
System.out.println(parse3.multiply(2));
49+
50+
// 查看此单位数值是否需要进行单位统一再计算
51+
System.out.println(parse2.isNeedUnifiedUnit());
52+
}
11053
}
111-
11254
```
11355

114-
然后就可以进行使用啦
56+
* 针对单位数值注解 `@BaseUnit` 进行升级，其可以实现自定义单位的进制，也可以像原来一样指定一个通用进制，通用进制会形成一种等比效应。
11557

11658
```java
11759
package zhao.algorithmMagic;
11860

11961
import zhao.algorithmMagic.core.AlgorithmStar;
12062
import zhao.algorithmMagic.core.BaseValueFactory;
12163
import zhao.algorithmMagic.operands.unit.BaseValue;
122-
import zhao.algorithmMagic.operands.unit.WeightValue;
123-
124-
import java.net.MalformedURLException;
64+
import zhao.algorithmMagic.operands.unit.DateValue;
12565

12666
public class MAIN1 {
67+
12768
public static void main(String[] args) {
128-
// 构建一个用来创建 WeightValue.class 的工厂类 TODO 这里的类型可以是其它的 但是要确保是 BaseValue 的子类
129-
final BaseValueFactory baseValueFactory = AlgorithmStar.baseValueFactory(WeightValue.class);
130-
// 获取到数值
131-
final BaseValue number_1 = baseValueFactory.parse(200);
132-
System.out.println("number_1 = " + number_1);
133-
// 将第一个的单位转换为 克
134-
number_1.switchUnitsNotChange("g（克）");
135-
System.out.println("number_1 = " + number_1);
136-
// 获取到第二个数值
137-
final BaseValue number_2 = baseValueFactory.parse(102.4);
138-
// 将第二个转换为 毫克
139-
number_2.switchUnitsNotChange("mg（毫克）");
140-
System.out.println("number_2 = " + number_2);
141-
// 进行一个计算
142-
System.out.println("number_1 + number_2 = " + number_1.add(number_2));
69+
// 在这里我们获取到的就是单位数值的工厂类 在这里的函数参数是工厂要构造的单位数值的类型
70+
// 请确保您在这里提供的单位数值类具有 @BaseUnit 注解和 parse 函数
71+
final BaseValueFactory baseValueFactory = AlgorithmStar.baseValueFactory(BaseValue.class);
72+
// 使用工厂类 将 1024 转换成为一个单位数值
73+
final BaseValue parse1 = baseValueFactory.parse(2);
74+
// 使用工厂类 将 1024000 转换成为一个单位数值
75+
final BaseValue parse2 = baseValueFactory.parse(1024);
76+
// 计算加减乘除结果
77+
System.out.println(parse2.add(parse1));
78+
System.out.println(parse2.diff(parse1));
79+
System.out.println(parse2.multiply(parse1));
80+
System.out.println(parse2.divide(parse1));
81+
82+
System.out.println("==============");
83+
84+
final BaseValueFactory baseValueFactory1 = AlgorithmStar.baseValueFactory(DateValue.class);
85+
final BaseValue parse11 = baseValueFactory1.parse(100);
86+
final BaseValue parse12 = baseValueFactory1.parse(10000);
87+
final BaseValue parse23 = baseValueFactory1.parse(1000 * 60);
88+
System.out.println(parse11);
89+
System.out.println(parse12);
90+
System.out.println(parse23);
91+
System.out.println(parse12.add(parse11));
92+
System.out.println(parse12.diff(parse11));
93+
System.out.println(parse12.multiply(parse11));
94+
System.out.println(parse12.divide(parse11));
95+
96+
System.out.println(parse23.divide(parse12));
14397
}
14498
}
145-
14699
```
147100

148-
* 内置的单位数值类
149-
150-
| 类路径 | 名称 | 加入版本 | 支持计算 |
151-
|-----------------------------------------------|---------|-------|------|
152-
| zhao.algorithmMagic.operands.unit.BaseValue | 基础单位数值类 | v1.30 | yes |
153-
| zhao.algorithmMagic.operands.unit.DataValue | 数据单位数值类 | v1.30 | yes |
154-
| zhao.algorithmMagic.operands.unit.VolumeValue | 容量单位数值类 | v1.30 | yes |
155-
| zhao.algorithmMagic.operands.unit.WeightValue | 重量单位数值类 | v1.30 | yes |
156-
| zhao.algorithmMagic.operands.unit.DateValue | 时间单位数值类 | v1.30 | yes |
157-
158-
159-
### Version update date : 2024-01-30
101+
### Version update date : 2024-02-09

0 commit comments

Comments
 (0)