11 | {
12 | // Find the key or null for a given unit
13 | internal UnitFactorSynonyms FindUnit(UnitFactorSynonyms synonyms)
14 | {
15 | return this.Keys.FirstOrDefault(factor => factor.Contains(synonyms));
16 | }
17 |
18 | // Get the factor for a given unit
19 | internal decimal FindFactor(UnitFactorSynonyms synonyms)
20 | {
21 | var unit = this.FirstOrDefault(factor => factor.Key.Contains(synonyms));
22 | if (unit.Key == null) {
23 | throw new UnitNotSupportedException(synonyms.ToString());
24 | }
25 | return unit.Value;
26 | }
27 | }
28 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm.WebTest/Pages/Error.cshtml:
--------------------------------------------------------------------------------
1 | @page
2 | @model ErrorModel
3 | @{
4 | ViewData["Title"] = "Error";
5 | }
6 |
7 | Error.
8 | An error occurred while processing your request.
9 |
10 | @if (Model.ShowRequestId)
11 | {
12 |
13 | Request ID: @Model.RequestId
14 |
15 | }
16 |
17 | Development Mode
18 |
19 | Swapping to the Development environment displays detailed information about the error that occurred.
20 |
21 |
22 | The Development environment shouldn't be enabled for deployed applications.
23 | It can result in displaying sensitive information from exceptions to end users.
24 | For local debugging, enable the Development environment by setting the ASPNETCORE_ENVIRONMENT environment variable to Development
25 | and restarting the app.
26 |
27 |
--------------------------------------------------------------------------------
/java/toolgood.algorithm/.project:
--------------------------------------------------------------------------------
1 |
2 |
3 | algorithm
4 |
6 |
7 |
8 |
9 | org.eclipse.jdt.core.javabuilder
10 |
11 |
12 |
13 |
14 | org.eclipse.m2e.core.maven2Builder
15 |
16 |
17 |
18 |
19 |
20 | org.eclipse.jdt.core.javanature
21 | org.eclipse.m2e.core.maven2Nature
22 |
23 |
24 |
25 | 1695360233274
26 | 30
28 |
29 | org.eclipse.core.resources.regexFilterMatcher
30 | node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__
31 |
32 |
33 |
34 |
35 |
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Constants.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet;
2 |
3 | public class Constants {
4 | /// The number log[e](pi)
5 | public final static double LnPi = 1.1447298858494001741434273513530587116472948129153d;
6 |
7 | /// The number sqrt(2)
8 | public final static double Sqrt2 = 1.4142135623730950488016887242096980785696718753769d;
9 |
10 | /// The number sqrt(2pi)
11 | public final static double Sqrt2Pi = 2.5066282746310005024157652848110452530069867406099d;
12 |
13 | /// The number log(2 * sqrt(e / pi))
14 | public final static double LogTwoSqrtEOverPi = 0.6207822376352452223455184457816472122518527279025978;
15 |
16 | /// The number 2 * sqrt(e / pi)
17 | public final static double TwoSqrtEOverPi = 1.8603827342052657173362492472666631120594218414085755;
18 |
19 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Distributions/LogNormal.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet.Distributions;
2 |
3 | import toolgood.algorithm.mathNet.Constants;
4 | import toolgood.algorithm.mathNet.SpecialFunctions;
5 |
6 | public class LogNormal {
7 | public static double CDF(double mu, double sigma, double x)
8 | {
9 | //if (sigma < 0.0) {
10 | // throw new ArgumentException("InvalidDistributionParameters");
11 | //}
12 |
13 | return x < 0.0 ? 0.0
14 | : 0.5 * (1.0 + SpecialFunctions.Erf((Math.log(x) - mu) / (sigma * Constants.Sqrt2)));
15 | }
16 |
17 | public static double InvCDF(double mu, double sigma, double p)
18 | {
19 | //if (sigma < 0.0) {
20 | // throw new ArgumentException("InvalidDistributionParameters");
21 | //}
22 |
23 | return p <= 0.0 ? 0.0 : p >= 1.0 ? Double.POSITIVE_INFINITY
24 | : Math.exp(mu - sigma * Constants.Sqrt2 * SpecialFunctions.ErfcInv(2.0 * p));
25 | }
26 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm.WebTest/Pages/Test.cshtml:
--------------------------------------------------------------------------------
1 | @page
2 | @{
3 | Layout = null;
4 | }
5 |
6 |
7 |
8 | QUnit Test Suite
9 |
10 |
11 |
17 |
4 | /// 操作数类型
5 | ///
6 | public enum OperandType : byte
7 | {
8 | ///
9 | /// NULL
10 | ///
11 | NULL,
12 |
13 | ///
14 | /// 错误
15 | ///
16 | ERROR,
17 |
18 | ///
19 | /// 日期
20 | ///
21 | DATE,
22 |
23 | ///
24 | /// 数组
25 | ///
26 | ARRARY,
27 |
28 | ///
29 | /// 数字
30 | ///
31 | NUMBER,
32 |
33 | ///
34 | /// 布尔
35 | ///
36 | BOOLEAN,
37 |
38 | ///
39 | /// 字符串
40 | ///
41 | TEXT,
42 |
43 | ///
44 | /// JSON格式
45 | ///
46 | JSON,
47 |
48 | ///
49 | /// JSON格式
50 | ///
51 | ARRARYJSON,
52 | }
53 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm.WebTest/wwwroot/web.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
21 |
22 |
23 |
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/MathNet/Constants.cs:
--------------------------------------------------------------------------------
1 | namespace ToolGood.Algorithm.MathNet.Numerics
2 | {
3 | ///
4 | /// 常量
5 | ///
6 | internal static class Constants
7 | {
8 | #region Mathematical Constants
9 |
10 | /// The number log[e](pi)
11 | public const double LnPi = 1.1447298858494001741434273513530587116472948129153d;
12 |
13 | /// The number sqrt(2)
14 | public const double Sqrt2 = 1.4142135623730950488016887242096980785696718753769d;
15 |
16 | /// The number sqrt(2pi)
17 | public const double Sqrt2Pi = 2.5066282746310005024157652848110452530069867406099d;
18 |
19 | /// The number log(2 * sqrt(e / pi))
20 | public const double LogTwoSqrtEOverPi = 0.6207822376352452223455184457816472122518527279025978;
21 |
22 | /// The number 2 * sqrt(e / pi)
23 | public const double TwoSqrtEOverPi = 1.8603827342052657173362492472666631120594218414085755;
24 |
25 | #endregion Mathematical Constants
26 | }
27 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/unitConversion/UnitFactorSynonyms.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.unitConversion;
2 |
3 | import java.util.ArrayList;
4 | import java.util.Collections;
5 | import java.util.List;
6 |
7 | public class UnitFactorSynonyms {
8 | public List Synonyms = new ArrayList<>();
9 |
10 | public UnitFactorSynonyms() {
11 | }
12 |
13 | public UnitFactorSynonyms(String item) {
14 | Synonyms.add(item);
15 | }
16 |
17 | public UnitFactorSynonyms(String[] items) {
18 | Collections.addAll(Synonyms, items);
19 | }
20 |
21 | public boolean Contains(UnitFactorSynonyms synonyms) {
22 | for (String syn : synonyms.Synonyms) {
23 | if (this.Contains(syn)) {
24 | return true;
25 | }
26 | }
27 | return false;
28 | }
29 |
30 | private boolean Contains(String synonym) {
31 | for (String str : Synonyms) {
32 | if (str.equalsIgnoreCase(synonym)) {
33 | return true;
34 | }
35 | }
36 | return false;
37 | }
38 |
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Distributions/FisherSnedecor.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet.Distributions;
2 |
3 | import java.util.function.Function;
4 |
5 | import toolgood.algorithm.mathNet.SpecialFunctions;
6 | import toolgood.algorithm.mathNet.RootFinding.Brent;
7 |
8 | public class FisherSnedecor {
9 | public static double CDF(double d1, double d2, double x)
10 | {
11 | //if (d1 <= 0.0 || d2 <= 0.0) {
12 | // throw new ArgumentException(Resources.InvalidDistributionParameters);
13 | //}
14 |
15 | return SpecialFunctions.BetaRegularized(d1 / 2.0, d2 / 2.0, d1 * x / (d1 * x + d2));
16 | }
17 |
18 | public static double InvCDF(double d1, double d2, double p) throws Exception
19 | {
20 | //if (d1 <= 0.0 || d2 <= 0.0) {
21 | // throw new ArgumentException(Resources.InvalidDistributionParameters);
22 | //}
23 | Function f= x->{
24 | return SpecialFunctions.BetaRegularized(d1 / 2.0, d2 / 2.0, d1 * x / (d1 * x + d2)) - p;
25 | };
26 |
27 | return Brent.FindRoot(f, 0, 1000, 1e-12);
28 | }
29 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm.WebTest/Pages/Shared/_Layout.cshtml.css:
--------------------------------------------------------------------------------
1 | /* Please see documentation at https://learn.microsoft.com/aspnet/core/client-side/bundling-and-minification
2 | for details on configuring this project to bundle and minify static web assets. */
3 |
4 | a.navbar-brand {
5 | white-space: normal;
6 | text-align: center;
7 | word-break: break-all;
8 | }
9 |
10 | a {
11 | color: #0077cc;
12 | }
13 |
14 | .btn-primary {
15 | color: #fff;
16 | background-color: #1b6ec2;
17 | border-color: #1861ac;
18 | }
19 |
20 | .nav-pills .nav-link.active, .nav-pills .show > .nav-link {
21 | color: #fff;
22 | background-color: #1b6ec2;
23 | border-color: #1861ac;
24 | }
25 |
26 | .border-top {
27 | border-top: 1px solid #e5e5e5;
28 | }
29 |
30 | .border-bottom {
31 | border-bottom: 1px solid #e5e5e5;
32 | }
33 |
34 | .box-shadow {
35 | box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
36 | }
37 |
38 | button.accept-policy {
39 | font-size: 1rem;
40 | line-height: inherit;
41 | }
42 |
43 | .footer {
44 | position: absolute;
45 | bottom: 0;
46 | width: 100%;
47 | white-space: nowrap;
48 | line-height: 60px;
49 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/enums/DistanceUnitType.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.enums;
2 |
3 | public enum DistanceUnitType {
4 | ///
5 | /// 毫米
6 | ///
7 | MM(1),
8 | ///
9 | /// 厘米
10 | ///
11 | CM(2),
12 | ///
13 | /// 分米
14 | ///
15 | DM(3),
16 | ///
17 | /// 米
18 | ///
19 | M(4),
20 | ///
21 | /// 千米
22 | ///
23 | KM(5);
24 |
25 | private final int value;
26 |
27 | DistanceUnitType(int v) {
28 | value = v;
29 | }
30 |
31 | public static DistanceUnitType intToEnum(int value) {
32 | switch (value) {
33 | case 1:
34 | return MM;
35 | case 2:
36 | return CM;
37 | case 3:
38 | return DM;
39 | case 4:
40 | return M;
41 | case 5:
42 | return KM;
43 | default:
44 | return null;
45 | }
46 | }
47 |
48 | public int getValue() {
49 | return value;
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/HtmlEditor/ace-ext/mirror.js:
--------------------------------------------------------------------------------
1 | ace.define("ace/worker/mirror",["require","exports","module","ace/range","ace/document","ace/lib/lang"],function(require,exports,module){var Range=require("../range").Range;var Document=require("../document").Document;var lang=require("../lib/lang");var Mirror=exports.Mirror=function(sender){this.sender=sender;var doc=this.doc=new Document("");var deferredUpdate=this.deferredUpdate=lang.delayedCall(this.onUpdate.bind(this));var _self=this;sender.on("change",function(e){var data=e.data;if(data[0].start)doc.applyDeltas(data);else for(var i=0;i
5 | /// 平方毫米
6 | ///
7 | MM2(11),
8 | ///
9 | /// 平方厘米
10 | ///
11 | CM2(12),
12 | ///
13 | /// 平方分米
14 | ///
15 | DM2(13),
16 | ///
17 | /// 平方米
18 | ///
19 | M2(14),
20 | ///
21 | /// 平方千米
22 | ///
23 | KM2(15);
24 |
25 | private final int value;
26 |
27 | AreaUnitType(int v) {
28 | value = v;
29 | }
30 |
31 | public static AreaUnitType intToEnum(int value) {
32 | switch (value) {
33 | case 11:
34 | return MM2;
35 | case 12:
36 | return CM2;
37 | case 13:
38 | return DM2;
39 | case 14:
40 | return M2;
41 | case 15:
42 | return KM2;
43 | default:
44 | return null;
45 | }
46 | }
47 |
48 | public int getValue() {
49 | return value;
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/enums/VolumeUnitType.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.enums;
2 |
3 | public enum VolumeUnitType {
4 | ///
5 | /// 立方毫米
6 | ///
7 | MM3(21),
8 | ///
9 | /// 立方厘米
10 | ///
11 | CM3(22),
12 | ///
13 | /// 立方分米
14 | ///
15 | DM3(23),
16 | ///
17 | /// 立方米
18 | ///
19 | M3(24),
20 | ///
21 | /// 立方千米
22 | ///
23 | KM3(25);
24 |
25 | private final int value;
26 |
27 | VolumeUnitType(int v) {
28 | value = v;
29 | }
30 |
31 | public static VolumeUnitType intToEnum(int value) {
32 | switch (value) {
33 | case 21:
34 | return MM3;
35 | case 22:
36 | return CM3;
37 | case 23:
38 | return DM3;
39 | case 24:
40 | return M3;
41 | case 25:
42 | return KM3;
43 | default:
44 | return null;
45 | }
46 | }
47 |
48 | public int getValue() {
49 | return value;
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/HtmlEditor/ace/ext-linking.js:
--------------------------------------------------------------------------------
1 | define("ace/ext/linking",["require","exports","module","ace/editor","ace/config"],function(e,t,n){function i(e){var n=e.editor,r=e.getAccelKey();if(r){var n=e.editor,i=e.getDocumentPosition(),s=n.session,o=s.getTokenAt(i.row,i.column);t.previousLinkingHover&&t.previousLinkingHover!=o&&n._emit("linkHoverOut"),n._emit("linkHover",{position:i,token:o}),t.previousLinkingHover=o}else t.previousLinkingHover&&(n._emit("linkHoverOut"),t.previousLinkingHover=!1)}function s(e){var t=e.getAccelKey(),n=e.getButton();if(n==0&&t){var r=e.editor,i=e.getDocumentPosition(),s=r.session,o=s.getTokenAt(i.row,i.column);r._emit("linkClick",{position:i,token:o})}}var r=e("../editor").Editor;e("../config").defineOptions(r.prototype,"editor",{enableLinking:{set:function(e){e?(this.on("click",s),this.on("mousemove",i)):(this.off("click",s),this.off("mousemove",i))},value:!1}}),t.previousLinkingHover=!1}); (function() {
2 | window.require(["ace/ext/linking"], function(m) {
3 | if (typeof module == "object" && typeof exports == "object" && module) {
4 | module.exports = m;
5 | }
6 | });
7 | })();
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Evaluate.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet;
2 |
3 |
4 | public class Evaluate {
5 | public static double Polynomial(double z, double[] coefficients) {
6 | double sum = coefficients[coefficients.length - 1];
7 | for (int i = coefficients.length - 2; i >= 0; --i) {
8 | sum *= z;
9 | sum += coefficients[i];
10 | }
11 |
12 | return sum;
13 | }
14 |
15 | // public static double Series(Function f) {
16 | // double compensation = 0.0;
17 | // double current;
18 | // double factor = 1 << 16;
19 |
20 | // double sum = f.apply(0.0);
21 |
22 | // do {
23 | // // Kahan Summation
24 | // // NOTE (ruegg): do NOT optimize. Now, how to tell that the compiler?
25 | // current = f.apply(0.0);
26 | // double y = current - compensation;
27 | // double t = sum + y;
28 | // compensation = t - sum;
29 | // compensation -= y;
30 | // sum = t;
31 | // } while (Math.abs(sum) < Math.abs(factor * current));
32 |
33 | // return sum;
34 | // }
35 |
36 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm.Test/AlgorithmEngine/AlgorithmEngineTest_vlookup.cs:
--------------------------------------------------------------------------------
1 | using PetaTest;
2 |
3 | namespace ToolGood.Algorithm
4 | {
5 | [TestFixture]
6 | public class AlgorithmEngineTest_vlookup
7 | {
8 | [Test]
9 | public void vlookup_test()
10 | {
11 | AlgorithmEngine engine = new AlgorithmEngine();
12 | var num = engine.TryEvaluate("vlookup(array(array(1,2,3),array(2,3,4),array(3,4,5),array(4,5,6)),3,2)", 0);
13 | Assert.AreEqual(num, 4);
14 |
15 | num = engine.TryEvaluate("vlookup(array(array(1,'2',3),array(2,3,4),array(3,'4',5),array(4,'5',6)),3,2)", 0);
16 | Assert.AreEqual(num, 4);
17 |
18 | num = engine.TryEvaluate("vlookup(array(array(1,'2',3),array(2,3,4),array(3.1,'4',5),array(4,'5',6)),3.1,2)", 0);
19 | Assert.AreEqual(num, 4);
20 |
21 | num = engine.TryEvaluate("vlookup(array(array(1,'2',3),array(2,3,4),array('3a','4',5),array(4,'5',6)),'3a',2)", 0);
22 | Assert.AreEqual(num, 4);
23 |
24 | num = engine.TryEvaluate("vlookup(array(array(1,'2',3),array(2,3,4),array(5,'4',5),array(6,'5',6)),'3',2,0)", 0);
25 | Assert.AreEqual(num, 0);
26 | }
27 |
28 | }
29 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/UnitConversion/BaseUnitConverter.cs:
--------------------------------------------------------------------------------
1 | namespace ToolGood.Algorithm.UnitConversion
2 | {
3 | internal abstract class BaseUnitConverter
4 | {
5 | ///
6 | /// Set Unit conversions and initial Left/Right conversion
7 | ///
8 | protected void Instantiate(UnitFactors conversionFactors, string leftUnit, string rightUnit)
9 | {
10 | units = conversionFactors;
11 |
12 | unitLeft = leftUnit;
13 | unitRight = rightUnit;
14 | }
15 |
16 | private UnitFactors units;
17 | private string unitLeft;
18 | private string unitRight;
19 |
20 | ///
21 | /// Convert the Unit on the Left to the Unit on the Right
22 | ///
23 | /// The converted value
25 | public decimal LeftToRight(decimal value)
26 | {
27 | var startFactor = units.FindFactor(unitLeft);
28 | var endFactor = units.FindFactor(unitRight);
29 | var result = (value / startFactor) * endFactor;
30 | return result;//.CheckCloseEnoughValue();
31 | }
32 | }
33 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/Internals/AntlrErrorListener.cs:
--------------------------------------------------------------------------------
1 | using Antlr4.Runtime;
2 | using System.IO;
3 |
4 | namespace ToolGood.Algorithm.Internals
5 | {
6 | ///
7 | /// 自定义ErrorListener
8 | ///
9 | sealed class AntlrErrorListener : IAntlrErrorListener
10 | {
11 | ///
12 | /// 是否出错
13 | ///
14 | public bool IsError { get; private set; }
15 |
16 | ///
17 | /// 出错信息
18 | ///
19 | public string ErrorMsg { get; private set; }
20 |
21 | ///
22 | /// 重写
23 | ///
24 | ///
6 | /// Continuous Univariate Log-Normal distribution.
7 | /// For details about this distribution, see
8 | /// Wikipedia - Log-Normal distribution .
9 | ///
10 | internal sealed class LogNormal
11 | {
12 | public static double CDF(double mu, double sigma, double x)
13 | {
14 | //if (sigma < 0.0) {
15 | // throw new ArgumentException("InvalidDistributionParameters");
16 | //}
17 |
18 | return x < 0.0 ? 0.0
19 | : 0.5 * (1.0 + SpecialFunctions.Erf((Math.Log(x) - mu) / (sigma * Constants.Sqrt2)));
20 | }
21 |
22 | public static double InvCDF(double mu, double sigma, double p)
23 | {
24 | //if (sigma < 0.0) {
25 | // throw new ArgumentException("InvalidDistributionParameters");
26 | //}
27 |
28 | return p <= 0.0 ? 0.0 : p >= 1.0 ? double.PositiveInfinity
29 | : Math.Exp(mu - sigma * Constants.Sqrt2 * SpecialFunctions.ErfcInv(2.0 * p));
30 | }
31 | }
32 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm.WebTest/Program.cs:
--------------------------------------------------------------------------------
1 | using Microsoft.AspNetCore.StaticFiles;
2 |
3 | namespace ToolGood.Algorithm2.WebTest
4 | {
5 | public class Program
6 | {
7 | public static void Main(string[] args)
8 | {
9 | var builder = WebApplication.CreateBuilder(args);
10 |
11 | // Add services to the container.
12 | builder.Services.AddRazorPages();
13 |
14 | var app = builder.Build();
15 |
16 | // Configure the HTTP request pipeline.
17 | if (!app.Environment.IsDevelopment()) {
18 | app.UseExceptionHandler("/Error");
19 | }
20 | var provider = new FileExtensionContentTypeProvider();
21 | provider.Mappings[".gz"] = "application/octet-stream";
22 | provider.Mappings[".dat"] = "application/octet-stream";
23 | provider.Mappings[".wasm"] = "application/wasm";
24 | provider.Mappings[".pdb"] = "application/pdb";
25 | app.UseStaticFiles(new StaticFileOptions {
26 | ContentTypeProvider = provider,//应用新的映射关系
27 | });
28 |
29 | app.UseRouting();
30 |
31 | app.UseAuthorization();
32 |
33 | app.MapRazorPages();
34 |
35 | app.Run();
36 | }
37 | }
38 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/unitConversion/UnitFactors.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.unitConversion;
2 |
3 | import java.math.BigDecimal;
4 | import java.util.HashMap;
5 |
6 | public class UnitFactors extends HashMap {
7 |
8 | public UnitFactorSynonyms FindUnit(String synonyms) {
9 | return FindUnit(new UnitFactorSynonyms(synonyms));
10 | }
11 |
12 | public UnitFactorSynonyms FindUnit(UnitFactorSynonyms synonyms) {
13 | for (UnitFactorSynonyms factor : this.keySet()) {
14 | if (factor.Contains(synonyms)) {
15 | return factor;
16 | }
17 | }
18 | return null;
19 | }
20 |
21 | public BigDecimal FindFactor(String synonyms) throws UnitNotSupportedException {
22 | return FindFactor(new UnitFactorSynonyms(synonyms));
23 | }
24 |
25 | // Get the factor for a given unit
26 | public BigDecimal FindFactor(UnitFactorSynonyms synonyms) throws UnitNotSupportedException {
27 | for (UnitFactorSynonyms factor : this.keySet()) {
28 | if (factor.Contains(synonyms)) {
29 | return this.get(factor);
30 | }
31 | }
32 | throw new UnitNotSupportedException(synonyms.toString());
33 | }
34 |
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/internals/AntlrCharStream.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.internals;
2 |
3 | import org.antlr.v4.runtime.CharStream;
4 | import org.antlr.v4.runtime.misc.Interval;
5 |
6 | public class AntlrCharStream implements CharStream {
7 | final CharStream stream;
8 |
9 | public AntlrCharStream(CharStream stream) {
10 | this.stream = stream;
11 | }
12 |
13 | @Override
14 | public String getText(Interval interval) {
15 | return stream.getText(interval);
16 | }
17 |
18 | @Override
19 | public void consume() {
20 | stream.consume();
21 | }
22 |
23 | @Override
24 | public int LA(int i) {
25 | int c = stream.LA(i);
26 | if (c <= 0) {
27 | return c;
28 | }
29 | return CharUtil.StandardChar((char)c);
30 | }
31 |
32 | @Override
33 | public int mark() {
34 | return stream.mark();
35 | }
36 |
37 | @Override
38 | public void release(int marker) {
39 | stream.release(marker);
40 | }
41 |
42 | @Override
43 | public int index() {
44 | return stream.index();
45 | }
46 |
47 | @Override
48 | public void seek(int index) {
49 | stream.seek(index);
50 | }
51 |
52 | @Override
53 | public int size() {
54 | return stream.size();
55 | }
56 |
57 | @Override
58 | public String getSourceName() {
59 | return stream.getSourceName();
60 | }
61 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Distributions/Hypergeometric.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet.Distributions;
2 |
3 | import toolgood.algorithm.mathNet.SpecialFunctions;
4 |
5 | public class Hypergeometric {
6 | ///
7 | /// Computes the probability mass (PMF) at k, i.e. P(X = k).
8 | ///
9 | /// the probability mass at location
14 | public static double PMF(int population, int success, int draws, int k)
15 | {
16 | //if (!(population >= 0 && success >= 0 && draws >= 0 && success <= population && draws <= population)) {
17 | // throw new ArgumentException("InvalidDistributionParameters");
18 | //}
19 |
20 | return SpecialFunctions.Binomial(success, k) * SpecialFunctions.Binomial(population - success, draws - k) / SpecialFunctions.Binomial(population, draws);
21 | }
22 |
23 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/MathNet/Statistics/SortedArrayStatistics.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | namespace ToolGood.Algorithm.MathNet.Numerics.Statistics
4 | {
5 | internal static partial class SortedArrayStatistics
6 | {
7 | public static double QuantileRank(double[] data, double x)
8 | {
9 | if (x < data[0]) {
10 | return 0.0;
11 | }
12 |
13 | if (x >= data[data.Length - 1]) {
14 | return 1.0;
15 | }
16 |
17 | int right = Array.BinarySearch(data, x);
18 | if (right >= 0) {
19 | int left = right;
20 |
21 | while (left > 0 && data[left - 1] == data[left]) {
22 | left--;
23 | }
24 |
25 | while (right < data.Length - 1 && data[right + 1] == data[right]) {
26 | right++;
27 | }
28 |
29 | return left / (double)(data.Length - 1);
30 | } else {
31 | right = ~right;
32 | int left = right - 1;
33 |
34 | var a = left / (double)(data.Length - 1);
35 | var b = right / (double)(data.Length - 1);
36 | return ((data[right] - x) * a + (x - data[left]) * b) / (data[right] - data[left]);
37 | }
38 | }
39 | }
40 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/MathNet/SpecialFunctions/Evaluate.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | namespace ToolGood.Algorithm.MathNet.Numerics
4 | {
5 | internal static class Evaluate
6 | {
7 | public static double Polynomial(double z, params double[] coefficients)
8 | {
9 | double sum = coefficients[coefficients.Length - 1];
10 | for (int i = coefficients.Length - 2; i >= 0; --i) {
11 | sum *= z;
12 | sum += coefficients[i];
13 | }
14 |
15 | return sum;
16 | }
17 |
18 | internal static double Series(Func nextSummand)
19 | {
20 | double compensation = 0.0;
21 | double current;
22 | const double factor = 1 << 16;
23 |
24 | double sum = nextSummand();
25 |
26 | do {
27 | // Kahan Summation
28 | // NOTE (ruegg): do NOT optimize. Now, how to tell that the compiler?
29 | current = nextSummand();
30 | double y = current - compensation;
31 | double t = sum + y;
32 | compensation = t - sum;
33 | compensation -= y;
34 | sum = t;
35 | }
36 | while (Math.Abs(sum) < Math.Abs(factor * current));
37 |
38 | return sum;
39 | }
40 | }
41 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm.WebTest/wwwroot/_framework/emcc-props.json:
--------------------------------------------------------------------------------
1 | {
2 | "items": {
3 | "EmccProperties": [
4 | { "identity": "RuntimeEmccVersion", "value": "3.1.34" },
5 | { "identity": "RuntimeEmccVersionRaw", "value": "emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 3.1.34 (57b21b8fdcbe3ebb523178b79465254668eab408)" },
6 | { "identity": "RuntimeEmccVersionHash", "value": "57b21b8fdcbe3ebb523178b79465254668eab408" }
7 | ],
8 | "WasmOptConfigurationFlags": [
9 | { "identity": "WasmOptConfigurationFlags", "value": " " }
10 | ],
11 | "EmccDefaultExportedFunctions": ["_free","_htons","_malloc","_memalign","_memset","_ntohs","stackAlloc","stackRestore","stackSave","_fmod","_atan2","_fma","_pow","_fmodf","_atan2f","_fmaf","_powf","_asin","_asinh","_acos","_acosh","_atan","_atanh","_cbrt","_cos","_cosh","_exp","_log","_log2","_log10","_sin","_sinh","_tan","_tanh","_asinf","_asinhf","_acosf","_acoshf","_atanf","_atanhf","_cbrtf","_cosf","_coshf","_expf","_logf","_log2f","_log10f","_sinf","_sinhf","_tanf","_tanhf"],
12 | "EmccDefaultExportedRuntimeMethods": ["FS","out","err","ccall","cwrap","setValue","getValue","UTF8ToString","UTF8ArrayToString","stringToUTF8Array","FS_createPath","FS_createDataFile","removeRunDependency","addRunDependency","addFunction","safeSetTimeout","runtimeKeepalivePush","runtimeKeepalivePop","maybeExit","abort"]
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm.Test/Tests/IssuesTest.cs:
--------------------------------------------------------------------------------
1 | using PetaTest;
2 | using System;
3 | using ToolGood.Algorithm;
4 |
5 | namespace ToolGood.Algorithm.Test
6 | {
7 | [TestFixture]
8 | public class IssuesTest
9 | {
10 | [Test]
11 | public void issues_12()
12 | {
13 | AlgorithmEngine engine = new AlgorithmEngine();
14 | var dt = engine.TryEvaluate("Year(44406)=2021", false);
15 | Assert.AreEqual(dt, true);
16 | dt = engine.TryEvaluate("MONTH(44406)=7", false);
17 | Assert.AreEqual(dt, true);
18 | dt = engine.TryEvaluate("DAY(44406)=29", false);
19 | Assert.AreEqual(dt, true);
20 |
21 | int num = engine.TryEvaluate("date(2011,2,2)", 0);
22 | Assert.AreEqual(num, 40576);
23 | }
24 |
25 | [Test]
26 | public void issues_13()
27 | {
28 | AlgorithmEngine engine = new AlgorithmEngine();
29 | var dt = engine.TryEvaluate("days360(date(2020,5,31),date(2023,12,15))", 0);
30 | Assert.AreEqual(dt, 1275);
31 | }
32 |
33 | [Test]
34 | public void issues_27()
35 | {
36 | AlgorithmEngine engine = new AlgorithmEngine();
37 | var dt = engine.TryEvaluate("DATE(2024, 8, 1) + TIME(8, 0, 0)", DateTime.Now);
38 | Assert.AreEqual(dt, DateTime.Parse("2024-08-01 8:0"));
39 | }
40 | }
41 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm.Test/AlgorithmEngine/Cylinder.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using ToolGood.Algorithm.math;
4 |
5 | namespace ToolGood.Algorithm
6 | {
7 | //定义圆柱信息
8 | public class Cylinder : AlgorithmEngineEx
9 | {
10 | private int _radius;
11 | private int _height;
12 |
13 | public Cylinder(int radius, int height)
14 | {
15 | _radius = radius;
16 | _height = height;
17 | }
18 |
19 | public override Operand GetParameter(string parameter)
20 | {
21 | if (parameter == "半径") {
22 | return Operand.Create(_radius);
23 | }
24 | if (parameter == "直径") {
25 | return Operand.Create(_radius * 2);
26 | }
27 | if (parameter == "高") {
28 | return Operand.Create(_height);
29 | }
30 | return base.GetParameter(parameter);
31 | }
32 |
33 |
34 | public override Operand ExecuteDiyFunction( string funcName, List operands)
35 | {
36 | if (funcName == "求面积") {
37 | if (operands.Count == 1) {
38 | var r = (double)operands[0].ToNumber().NumberValue;
39 | return r * r * Math.PI;
40 | }
41 | }
42 | return base.ExecuteDiyFunction( funcName, operands);
43 | }
44 | }
45 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/UnitConversion/DistanceConverter.cs:
--------------------------------------------------------------------------------
1 | namespace ToolGood.Algorithm.UnitConversion
2 | {
3 | internal sealed class DistanceConverter : BaseUnitConverter
4 | {
5 | private static UnitFactors units = new UnitFactors()
6 | {
7 | { new UnitFactorSynonyms("m", "metre","米"), 1 },
8 | { new UnitFactorSynonyms("km", "kilometre","千米"), 0.001m },
9 | { new UnitFactorSynonyms("dm","decimetre", "分米"), 10 },
10 | { new UnitFactorSynonyms("cm", "centimetre", "厘米"), 100 },
11 | { new UnitFactorSynonyms("mm", "millimetre", "毫米"), 1000 },
12 | { new UnitFactorSynonyms("ft", "foot", "feet","英尺"), 1250m / 381 },
13 | { new UnitFactorSynonyms("yd", "yard","码"), 1250m / 1143 },
14 | { new UnitFactorSynonyms("mile","英里"), 125m / 201168 },
15 | { new UnitFactorSynonyms("in", "inch","英寸"), 5000m / 127 },
16 | { "au", 1m / 149600000000}
17 | };
18 |
19 | public DistanceConverter(string leftUnit, string rightUnit)
20 | {
21 | Instantiate(units, leftUnit, rightUnit);
22 | }
23 |
24 | public static bool Exists(string leftSynonym, string rightSynonym)
25 | {
26 | if (units.FindUnit(leftSynonym) != null) {
27 | return units.FindUnit(rightSynonym) != null;
28 | }
29 | return false;
30 | }
31 | }
32 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/UnitConversion/MassConverter.cs:
--------------------------------------------------------------------------------
1 | namespace ToolGood.Algorithm.UnitConversion
2 | {
3 | internal sealed class MassConverter : BaseUnitConverter
4 | {
5 | private static UnitFactors units = new UnitFactors()
6 | {
7 | { new UnitFactorSynonyms("kg", "kilogram","千克"), 1 },
8 | { new UnitFactorSynonyms("gram", "g","克"), 1000 },
9 | { new UnitFactorSynonyms("ton", "t", "吨"), 1M/1000 },
10 | { new UnitFactorSynonyms("lb", "lbs", "pound", "pounds","英镑"), 100000000m / 45359237 },
11 | { new UnitFactorSynonyms("st", "stone","石"), 50000000m / 317514659 },
12 | { new UnitFactorSynonyms("oz", "ounce","盎司"), 1600000000m / 45359237 },
13 | { new UnitFactorSynonyms("quintal","英担"), 0.01m },
14 | { new UnitFactorSynonyms("short ton", "net ton", "us ton","短吨","美吨"), 0.00110231m },
15 | { new UnitFactorSynonyms("long ton", "weight ton", "gross ton", "imperial ton","长吨","英吨"), 0.000984207m },
16 | };
17 |
18 | public MassConverter(string leftUnit, string rightUnit)
19 | {
20 | Instantiate(units, leftUnit, rightUnit);
21 | }
22 |
23 | public static bool Exists(string leftSynonym, string rightSynonym)
24 | {
25 | if (units.FindUnit(leftSynonym) != null) {
26 | return units.FindUnit(rightSynonym) != null;
27 | }
28 | return false;
29 | }
30 | }
31 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/test/java/toolgood/algorithm/Tests/Cylinder.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.Tests;
2 |
3 | import java.util.List;
4 |
5 | import toolgood.algorithm.AlgorithmEngine;
6 | import toolgood.algorithm.Operand;
7 | import toolgood.algorithm.internals.MyParameter;
8 |
9 | public class Cylinder extends AlgorithmEngine {
10 | private int _radius;
11 | private int _height;
12 |
13 | public Cylinder(int radius, int height) {
14 | _radius = radius;
15 | _height = height;
16 | }
17 |
18 | @Override
19 | protected Operand GetParameter(MyParameter parameter) {
20 | if (parameter.Name.equals("半径")) {
21 | return Operand.Create(_radius);
22 | }
23 | if (parameter.Name.equals("直径"))
24 | {
25 | return Operand.Create(_radius * 2);
26 | }
27 | if (parameter.Name.equals("高"))
28 | {
29 | return Operand.Create(_height);
30 | }
31 | return super.GetParameter(parameter);
32 | }
33 |
34 | @Override
35 | protected Operand ExecuteDiyFunction(String funcName, List operands)
36 | {
37 | if (funcName.equals("求面积"))
38 | {
39 | if (operands.size() == 1)
40 | {
41 | int r =(int) operands.get(0).ToNumber(null).NumberValue().intValue();
42 | return Operand.Create(r * r * Math.PI);
43 | }
44 | }
45 | return super.ExecuteDiyFunction(funcName, operands);
46 | }
47 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/UnitConversion/UnitFactorSynonyms.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | #if WebAssembly
4 | using System.Linq2;
5 | #else
6 | using System.Linq;
7 | #endif
8 |
9 | namespace ToolGood.Algorithm.UnitConversion
10 | {
11 | internal sealed class UnitFactorSynonyms
12 | {
13 | public UnitFactorSynonyms(params string[] items)
14 | {
15 | _synonyms.AddRange(items);
16 | }
17 |
18 | private List _synonyms = new List();
19 |
20 | // Find if some synonym of a given UnitFactor is included in this UnitFactor
21 | internal bool Contains(UnitFactorSynonyms synonyms)
22 | {
23 | foreach (var syn in synonyms._synonyms) {
24 | if (this.Contains(syn)) {
25 | return true;
26 | }
27 | }
28 | return false;
29 | }
30 |
31 | // Find if some synonym is included in this UnitFactor
32 | internal bool Contains(string synonym)
33 | {
34 | return _synonyms.Contains(synonym, StringComparer.CurrentCultureIgnoreCase);
35 | }
36 |
37 | public override string ToString()
38 | {
39 | return string.Join(", ", _synonyms);
40 | }
41 |
42 | // Allow strings to be interpreted as a UnitDictionaryKey
43 | public static implicit operator UnitFactorSynonyms(string synonym)
44 | {
45 | return new UnitFactorSynonyms(synonym);
46 | }
47 | }
48 | }
--------------------------------------------------------------------------------
/HtmlEditor/ace/ext-spellcheck.js:
--------------------------------------------------------------------------------
1 | define("ace/ext/spellcheck",["require","exports","module","ace/lib/event","ace/editor","ace/config"],function(e,t,n){"use strict";var r=e("../lib/event");t.contextMenuHandler=function(e){var t=e.target,n=t.textInput.getElement();if(!t.selection.isEmpty())return;var i=t.getCursorPosition(),s=t.session.getWordRange(i.row,i.column),o=t.session.getTextRange(s);t.session.tokenRe.lastIndex=0;if(!t.session.tokenRe.test(o))return;var u="\x01\x01",a=o+" "+u;n.value=a,n.setSelectionRange(o.length,o.length+1),n.setSelectionRange(0,0),n.setSelectionRange(0,o.length);var f=!1;r.addListener(n,"keydown",function l(){r.removeListener(n,"keydown",l),f=!0}),t.textInput.setInputHandler(function(e){if(e==a)return"";if(e.lastIndexOf(a,0)===0)return e.slice(a.length);if(e.substr(n.selectionEnd)==a)return e.slice(0,-a.length);if(e.slice(-2)==u){var r=e.slice(0,-2);if(r.slice(-1)==" ")return f?r.substring(0,n.selectionEnd):(r=r.slice(0,-1),t.session.replace(s,r),"")}return e})};var i=e("../editor").Editor;e("../config").defineOptions(i.prototype,"editor",{spellcheck:{set:function(e){var n=this.textInput.getElement();n.spellcheck=!!e,e?this.on("nativecontextmenu",t.contextMenuHandler):this.removeListener("nativecontextmenu",t.contextMenuHandler)},value:!0}})}); (function() {
2 | window.require(["ace/ext/spellcheck"], function(m) {
3 | if (typeof module == "object" && typeof exports == "object" && module) {
4 | module.exports = m;
5 | }
6 | });
7 | })();
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/test/java/toolgood/algorithm/Tests/IssuesTest.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.Tests;
2 |
3 | import static org.junit.Assert.assertEquals;
4 |
5 | import org.junit.Test;
6 |
7 | import toolgood.algorithm.AlgorithmEngine;
8 | import toolgood.algorithm.MyDate;
9 |
10 | public class IssuesTest {
11 |
12 | @Test
13 | public void issues_12() {
14 | AlgorithmEngine engine = new AlgorithmEngine();
15 | boolean dt = engine.TryEvaluate("Year(44406)=2021", false);
16 | assertEquals(dt, true);
17 | dt = engine.TryEvaluate("MONTH(44406)=7", false);
18 | assertEquals(dt, true);
19 | dt = engine.TryEvaluate("DAY(44406)=29", false);
20 | assertEquals(dt, true);
21 |
22 | int num = engine.TryEvaluate("date(2011,2,2)", 0);
23 | assertEquals(num, 40576);
24 | }
25 |
26 | public void issues_13() {
27 | AlgorithmEngine engine = new AlgorithmEngine();
28 | int dt = engine.TryEvaluate("days360(date(2020,5,31),date(2023,12,15))", 0);
29 | assertEquals(dt, 1275);
30 |
31 | }
32 |
33 | @Test
34 | public void issues_27()
35 | {
36 | AlgorithmEngine engine = new AlgorithmEngine();
37 | MyDate dt = engine.TryEvaluate("DATE(2024, 8, 1) + TIME(8, 0, 0)", MyDate.now());
38 | assertEquals(dt.toString(), "2024-08-01 08:00:00");
39 |
40 | MyDate dt2 = engine.TryEvaluate("DATE(2024, 8, 1, 16,0,0) - TIME(8, 0, 0)", MyDate.now());
41 | assertEquals(dt2.toString(), "2024-08-01 08:00:00");
42 | }
43 |
44 | }
45 |
--------------------------------------------------------------------------------
/HtmlEditor/ace/ext-themelist.js:
--------------------------------------------------------------------------------
1 | define("ace/ext/themelist",["require","exports","module"],function(e,t,n){"use strict";var r=[["Chrome"],["Clouds"],["Crimson Editor"],["Dawn"],["Dreamweaver"],["Eclipse"],["GitHub"],["IPlastic"],["Solarized Light"],["TextMate"],["Tomorrow"],["XCode"],["Kuroir"],["KatzenMilch"],["SQL Server","sqlserver","light"],["Ambiance","ambiance","dark"],["Chaos","chaos","dark"],["Clouds Midnight","clouds_midnight","dark"],["Dracula","","dark"],["Cobalt","cobalt","dark"],["Gruvbox","gruvbox","dark"],["Green on Black","gob","dark"],["idle Fingers","idle_fingers","dark"],["krTheme","kr_theme","dark"],["Merbivore","merbivore","dark"],["Merbivore Soft","merbivore_soft","dark"],["Mono Industrial","mono_industrial","dark"],["Monokai","monokai","dark"],["Nord Dark","nord_dark","dark"],["One Dark","one_dark","dark"],["Pastel on dark","pastel_on_dark","dark"],["Solarized Dark","solarized_dark","dark"],["Terminal","terminal","dark"],["Tomorrow Night","tomorrow_night","dark"],["Tomorrow Night Blue","tomorrow_night_blue","dark"],["Tomorrow Night Bright","tomorrow_night_bright","dark"],["Tomorrow Night 80s","tomorrow_night_eighties","dark"],["Twilight","twilight","dark"],["Vibrant Ink","vibrant_ink","dark"]];t.themesByName={},t.themes=r.map(function(e){var n=e[1]||e[0].replace(/ /g,"_").toLowerCase(),r={caption:e[0],theme:"ace/theme/"+n,isDark:e[2]=="dark",name:n};return t.themesByName[n]=r,r})}); (function() {
2 | window.require(["ace/ext/themelist"], function(m) {
3 | if (typeof module == "object" && typeof exports == "object" && module) {
4 | module.exports = m;
5 | }
6 | });
7 | })();
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Statistics/SortedArrayStatistics.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet.Statistics;
2 |
3 | public class SortedArrayStatistics {
4 | public static double QuantileRank(double[] data, double x) {
5 | if (x < data[0]) {
6 | return 0.0;
7 | }
8 |
9 | if (x >= data[data.length - 1]) {
10 | return 1.0;
11 | }
12 |
13 | int right = binarySearch(data, x);
14 | if (right >= 0) {
15 | int left = right;
16 |
17 | while (left > 0 && data[left - 1] == data[left]) {
18 | left--;
19 | }
20 |
21 | while (right < data.length - 1 && data[right + 1] == data[right]) {
22 | right++;
23 | }
24 |
25 | return left / (double) (data.length - 1);
26 |
27 | } else {
28 | right = ~right;
29 | int left = right - 1;
30 |
31 | double a = left / (double) (data.length - 1);
32 | double b = right / (double) (data.length - 1);
33 | return ((data[right] - x) * a + (x - data[left]) * b) / (data[right] - data[left]);
34 | }
35 | }
36 | private static int binarySearch(double[] array, double key) {
37 | int low = 0;
38 | int high = array.length - 1;
39 | while (low <= high) {
40 | int mid = (low + high) >>> 1;
41 | if (key < array[mid]) {
42 | high = mid - 1;
43 | } else if (key > array[mid]) {
44 | low = mid + 1;
45 | } else {
46 | return mid;
47 | }
48 | }
49 | return -1;
50 | }
51 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Distributions/Exponential.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet.Distributions;
2 |
3 | public class Exponential {
4 | ///
5 | /// Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x.
6 | ///
7 | /// the density at
10 | /////
21 | /// Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x).
22 | ///
23 | /// the cumulative distribution at location
26 | /////
4 | /// Discrete Univariate Hypergeometric distribution.
5 | /// This distribution is a discrete probability distribution that describes the number of successes in a sequence
6 | /// of n draws from a finite population without replacement, just as the binomial distribution
7 | /// describes the number of successes for draws with replacement
8 | /// Wikipedia - Hypergeometric distribution .
9 | ///
10 | sealed class Hypergeometric
11 | {
12 | ///
13 | /// Computes the probability mass (PMF) at k, i.e. P(X = k).
14 | ///
15 | /// the probability mass at location
20 | public static double PMF(int population, int success, int draws, int k)
21 | {
22 | //if (!(population >= 0 && success >= 0 && draws >= 0 && success <= population && draws <= population)) {
23 | // throw new ArgumentException("InvalidDistributionParameters");
24 | //}
25 |
26 | return SpecialFunctions.Binomial(success, k) * SpecialFunctions.Binomial(population - success, draws - k) / SpecialFunctions.Binomial(population, draws);
27 | }
28 | }
29 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Distributions/StudentT.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet.Distributions;
2 |
3 | import java.util.function.Function;
4 |
5 | import toolgood.algorithm.mathNet.SpecialFunctions;
6 | import toolgood.algorithm.mathNet.RootFinding.Brent;
7 |
8 | public class StudentT {
9 | public static double CDF(double location, double scale, double freedom, double x)
10 | {
11 | //if (scale <= 0.0 || freedom <= 0.0) {
12 | // throw new ArgumentException(Resources.InvalidDistributionParameters);
13 | //}
14 |
15 | if (Double.isInfinite(freedom)) {
16 | return Normal.CDF(location, scale, x);
17 | }
18 |
19 | double k = (x - location) / scale;
20 | double h = freedom / (freedom + (k * k));
21 | double ib = 0.5 * SpecialFunctions.BetaRegularized(freedom / 2.0, 0.5, h);
22 | return x <= location ? ib : 1.0 - ib;
23 | }
24 | public static double InvCDF(double location, double scale, double freedom, double p) throws Exception
25 | {
26 | //if (scale <= 0.0 || freedom <= 0.0) {
27 | // throw new ArgumentException(Resources.InvalidDistributionParameters);
28 | //}
29 |
30 | if (Double.isInfinite(freedom)) {
31 | return Normal.InvCDF(location, scale, p);
32 | }
33 |
34 | if (p == 0.5d) {
35 | return location;
36 | }
37 | Function f=x->{
38 | double k = (x - location) / scale;
39 | double h = freedom / (freedom + (k * k));
40 | double ib = 0.5 * SpecialFunctions.BetaRegularized(freedom / 2.0, 0.5, h);
41 | return x <= location ? ib - p : 1.0 - ib - p;
42 | };
43 |
44 | return Brent.FindRoot(f, -800, 800, 1e-12);
45 | }
46 |
47 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/unitConversion/MassConverter.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.unitConversion;
2 |
3 |
4 |
5 | import java.math.BigDecimal;
6 |
7 | public class MassConverter extends BaseUnitConverter {
8 |
9 | static UnitFactors units;
10 |
11 | static {
12 | units = new UnitFactors();
13 | units.put(new UnitFactorSynonyms(new String[]{"kg", "kilogram", "千克"}), new BigDecimal("1"));
14 | units.put(new UnitFactorSynonyms(new String[]{"gram", "g", "克"}), new BigDecimal("1000"));
15 | units.put(new UnitFactorSynonyms(new String[]{"ton", "t", "吨"}), BigDecimal.valueOf(1 / 1000d));
16 | units.put(new UnitFactorSynonyms(new String[]{"lb", "lbs", "pound", "pounds", "英镑"}), BigDecimal.valueOf(100000000d / 45359237));
17 | units.put(new UnitFactorSynonyms(new String[]{"st", "stone", "石"}), BigDecimal.valueOf(50000000d / 317514659));
18 | units.put(new UnitFactorSynonyms(new String[]{"oz", "ounce", "盎司"}), BigDecimal.valueOf(1600000000d / 45359237));
19 | units.put(new UnitFactorSynonyms(new String[]{"quintal", "英担"}), new BigDecimal("0.01"));
20 | units.put(new UnitFactorSynonyms(new String[]{"short ton", "net ton", "us ton", "短吨", "美吨"}), new BigDecimal("0.00110231"));
21 | units.put(new UnitFactorSynonyms(new String[]{"long ton", "weight ton", "gross ton", "imperial ton", "长吨", "英吨"}), new BigDecimal("0.000984207"));
22 |
23 |
24 | }
25 |
26 | public MassConverter(String leftUnit, String rightUnit) {
27 | Instantiate(units, leftUnit, rightUnit);
28 | }
29 |
30 | public static Boolean Exists(String leftSynonym, String rightSynonym) {
31 | if (units.FindUnit(leftSynonym) != null) {
32 | return units.FindUnit(rightSynonym) != null;
33 | }
34 | return false;
35 | }
36 |
37 | }
38 |
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Distributions/Poisson.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet.Distributions;
2 |
3 | import toolgood.algorithm.mathNet.SpecialFunctions;
4 |
5 | public class Poisson {
6 | ///
7 | /// Computes the probability mass (PMF) at k, i.e. P(X = k).
8 | ///
9 | /// the probability mass at location
12 | public static double PMF(double lambda, int k)
13 | {
14 | //if (!(lambda > 0.0)) {
15 | // throw new ArgumentException("InvalidDistributionParameters");
16 | //}
17 |
18 | return Math.exp(-lambda + (k * Math.log(lambda)) - SpecialFunctions.FactorialLn(k));
19 | }
20 |
21 | ///
22 | /// Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x).
23 | ///
24 | /// the cumulative distribution at location
27 | /////
10 | /// Initializes static members of the SpecialFunctions class.
11 | ///
12 | static SpecialFunctions()
13 | {
14 | InitializeFactorial();
15 | }
16 |
17 | private static void InitializeFactorial()
18 | {
19 | _factorialCache = new double[171];
20 | _factorialCache[0] = 1.0;
21 | for (int i = 1; i < _factorialCache.Length; i++) {
22 | _factorialCache[i] = _factorialCache[i - 1] * i;
23 | }
24 | }
25 |
26 | public static double Binomial(int n, int k)
27 | {
28 | if (k < 0 || n < 0 || k > n) {
29 | return 0.0;
30 | }
31 |
32 | return Math.Floor(0.5 + Math.Exp(FactorialLn(n) - FactorialLn(k) - FactorialLn(n - k)));
33 | }
34 |
35 | public static double FactorialLn(int x)
36 | {
37 | //if (x < 0) {
38 | // throw new ArgumentOutOfRangeException("x", "ArgumentPositive");
39 | //}
40 |
41 | if (x <= 1) {
42 | return 0d;
43 | }
44 |
45 | if (x < _factorialCache.Length) {
46 | return Math.Log(_factorialCache[x]);
47 | }
48 |
49 | return GammaLn(x + 1.0);
50 | }
51 |
52 | public static double BinomialLn(int n, int k)
53 | {
54 | if (k < 0 || n < 0 || k > n) {
55 | return double.NegativeInfinity;
56 | }
57 |
58 | return FactorialLn(n) - FactorialLn(k) - FactorialLn(n - k);
59 | }
60 | }
61 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/unitConversion/DistanceConverter.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.unitConversion;
2 |
3 |
4 | import java.math.BigDecimal;
5 |
6 | public class DistanceConverter extends BaseUnitConverter {
7 | static UnitFactors units;
8 |
9 | static {
10 | units = new UnitFactors();
11 | units.put(new UnitFactorSynonyms(new String[]{"m", "metre", "meter", "米"}), new BigDecimal("1"));
12 | units.put(new UnitFactorSynonyms(new String[]{"km", "kilometre", "kilometer", "千米"}), new BigDecimal("0.001"));
13 | units.put(new UnitFactorSynonyms(new String[]{"dm", "decimetre", "decimeter", "分米"}), new BigDecimal("10"));
14 | units.put(new UnitFactorSynonyms(new String[]{"cm", "centimetre", "centimeter", "厘米"}), new BigDecimal("100"));
15 | units.put(new UnitFactorSynonyms(new String[]{"mm", "millimetre", "millimeter", "毫米"}), new BigDecimal("1000"));
16 | units.put(new UnitFactorSynonyms(new String[]{"ft", "foot", "feet", "英尺"}), BigDecimal.valueOf(1250d / 381));
17 | units.put(new UnitFactorSynonyms(new String[]{"yd", "yard", "码"}), BigDecimal.valueOf(1250d / 1143));
18 | units.put(new UnitFactorSynonyms(new String[]{"mile", "英里"}), BigDecimal.valueOf(125d / 201168));
19 | units.put(new UnitFactorSynonyms(new String[]{"in", "inch", "英寸"}), BigDecimal.valueOf(5000d / 127));
20 | units.put(new UnitFactorSynonyms(new String[]{"au"}), BigDecimal.valueOf(1d / 149600000000d));
21 | }
22 |
23 | public DistanceConverter(String leftUnit, String rightUnit) {
24 | Instantiate(units, leftUnit, rightUnit);
25 | }
26 |
27 | public static Boolean Exists(String leftSynonym, String rightSynonym) {
28 | if (units.FindUnit(leftSynonym) != null) {
29 | return units.FindUnit(rightSynonym) != null;
30 | }
31 | return false;
32 | }
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/DiyNameInfo.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 |
4 | namespace ToolGood.Algorithm
5 | {
6 | ///
7 | /// 自定义类型
8 | ///
9 | public sealed class DiyNameInfo
10 | {
11 | ///
12 | /// 自定义 参数
13 | ///
14 | public List Parameters { get; private set; }
15 |
16 | ///
17 | /// 自定义方法
18 | ///
19 | public List Functions { get; private set; }
20 |
21 | ///
22 | /// 自定义类型
23 | ///
24 | public DiyNameInfo()
25 | {
26 | Parameters = new List();
27 | Functions = new List();
28 | }
29 | }
30 |
31 | ///
32 | /// 参数信息
33 | ///
34 | public sealed class ParameterInfo
35 | {
36 | ///
37 | ///
38 | ///
39 | ///
50 | /// 名称
51 | ///
52 | public string Name { get; set; }
53 |
54 | ///
55 | /// 开始位置
56 | ///
57 | public int Start { get; set; }
58 |
59 | ///
60 | /// 结束位置
61 | ///
62 | public int End { get; set; }
63 |
64 | ///
65 | /// 重写
66 | ///
67 | /// n)return{start:o.index,end:o.index+o[2].length};if(s&&s[2])return u=t+s[2].length,{start:u,end:u+s[3].length}}var n=t.column||e.getOption("printMarginColumn"),i=t.allowMerge!=0,s=Math.min(t.startRow,t.endRow),o=Math.max(t.startRow,t.endRow),u=e.session;while(s<=o){var a=u.getLine(s);if(a.length>n){var f=m(a,n,5);if(f){var l=/^\s*/.exec(a)[0];u.replace(new r(s,f.start,s,f.end),"\n"+l)}o++}else if(i&&/\S/.test(a)&&s!=o){var c=u.getLine(s+1);if(c&&/\S/.test(c)){var h=a.replace(/\s+$/,""),p=c.replace(/^\s+/,""),d=h+" "+p,f=m(d,n,5);if(f&&f.start>h.length||d.length
2 |
3 |
4 | net10.0
5 | enable
6 |
7 |
8 |
9 |
10 |
18 |
19 |
20 |
24 |
25 |
26 |
27 |
28 |
35 |
36 |
37 |
38 |
40 |
41 |
42 |
44 |
45 |
46 |
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/MathNet/Distributions/Beta.cs:
--------------------------------------------------------------------------------
1 | using ToolGood.Algorithm.MathNet.Numerics.RootFinding;
2 |
3 | namespace ToolGood.Algorithm.MathNet.Numerics.Distributions
4 | {
5 | internal sealed class Beta
6 | {
7 | public static double CDF(double a, double b, double x)
8 | {
9 | //if (a < 0.0 || b < 0.0) {
10 | // throw new ArgumentException(Resources.InvalidDistributionParameters);
11 | //}
12 |
13 | if (x < 0.0) {
14 | return 0.0;
15 | }
16 |
17 | if (x >= 1.0) {
18 | return 1.0;
19 | }
20 |
21 | if (double.IsPositiveInfinity(a) && double.IsPositiveInfinity(b)) {
22 | return x < 0.5 ? 0.0 : 1.0;
23 | }
24 |
25 | if (double.IsPositiveInfinity(a)) {
26 | return x < 1.0 ? 0.0 : 1.0;
27 | }
28 |
29 | if (double.IsPositiveInfinity(b)) {
30 | return x >= 0.0 ? 1.0 : 0.0;
31 | }
32 |
33 | if (a == 0.0 && b == 0.0) {
34 | if (x >= 0.0 && x < 1.0) {
35 | return 0.5;
36 | }
37 |
38 | return 1.0;
39 | }
40 |
41 | if (a == 0.0) {
42 | return 1.0;
43 | }
44 |
45 | if (b == 0.0) {
46 | return x >= 1.0 ? 1.0 : 0.0;
47 | }
48 |
49 | if (a == 1.0 && b == 1.0) {
50 | return x;
51 | }
52 |
53 | return SpecialFunctions.BetaRegularized(a, b, x);
54 | }
55 |
56 | public static double InvCDF(double a, double b, double p)
57 | {
58 | //if (a < 0.0 || b < 0.0 || p < 0.0 || p > 1.0) {
59 | // throw new ArgumentException(Resources.InvalidDistributionParameters);
60 | //}
61 |
62 | return Brent.FindRoot(x => SpecialFunctions.BetaRegularized(a, b, x) - p, 0.0, 1.0, accuracy: 1e-12);
63 | }
64 | }
65 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Distributions/NegativeBinomial.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet.Distributions;
2 |
3 | import toolgood.algorithm.mathNet.SpecialFunctions;
4 |
5 | public class NegativeBinomial {
6 | ///
7 | /// Computes the probability mass (PMF) at k, i.e. P(X = k).
8 | ///
9 | /// the probability mass at location
13 | public static double PMF(double r, double p, int k)
14 | {
15 | return Math.exp(PMFLn(r, p, k));
16 | }
17 |
18 | ///
19 | /// Computes the log probability mass (lnPMF) at k, i.e. ln(P(X = k)).
20 | ///
21 | /// the log probability mass at location
25 | public static double PMFLn(double r, double p, int k)
26 | {
27 | //if (!(r >= 0.0 && p >= 0.0 && p <= 1.0)) {
28 | // throw new ArgumentException("InvalidDistributionParameters");
29 | //}
30 |
31 | return SpecialFunctions.GammaLn(r + k)
32 | - SpecialFunctions.GammaLn(r)
33 | - SpecialFunctions.GammaLn(k + 1.0)
34 | + (r * Math.log(p))
35 | + (k * Math.log(1.0 - p));
36 | }
37 |
38 | }
--------------------------------------------------------------------------------
/java/toolgood.algorithm/src/main/java/toolgood/algorithm/mathNet/Distributions/Beta.java:
--------------------------------------------------------------------------------
1 | package toolgood.algorithm.mathNet.Distributions;
2 |
3 | import java.util.function.Function;
4 |
5 | import toolgood.algorithm.mathNet.SpecialFunctions;
6 | import toolgood.algorithm.mathNet.RootFinding.Brent;
7 |
8 | public class Beta {
9 |
10 | public static double CDF(double a, double b, double x)
11 | {
12 | //if (a < 0.0 || b < 0.0) {
13 | // throw new ArgumentException(Resources.InvalidDistributionParameters);
14 | //}
15 |
16 | if (x < 0.0) {
17 | return 0.0;
18 | }
19 |
20 | if (x >= 1.0) {
21 | return 1.0;
22 | }
23 |
24 | if (Double.isInfinite(a) && Double.isInfinite(b)) {
25 | return x < 0.5 ? 0.0 : 1.0;
26 | }
27 |
28 | if (Double.isInfinite(a)) {
29 | return x < 1.0 ? 0.0 : 1.0;
30 | }
31 |
32 | if (Double.isInfinite(b)) {
33 | return x >= 0.0 ? 1.0 : 0.0;
34 | }
35 |
36 | if (a == 0.0 && b == 0.0) {
37 | if (x >= 0.0 && x < 1.0) {
38 | return 0.5;
39 | }
40 |
41 | return 1.0;
42 | }
43 |
44 | if (a == 0.0) {
45 | return 1.0;
46 | }
47 |
48 | if (b == 0.0) {
49 | return x >= 1.0 ? 1.0 : 0.0;
50 | }
51 |
52 | if (a == 1.0 && b == 1.0) {
53 | return x;
54 | }
55 |
56 | return SpecialFunctions.BetaRegularized(a, b, x);
57 | }
58 |
59 | public static double InvCDF(double a, double b, double p) throws Exception
60 | {
61 |
62 | //if (a < 0.0 || b < 0.0 || p < 0.0 || p > 1.0) {
63 | // throw new ArgumentException(Resources.InvalidDistributionParameters);
64 | //}
65 | Function f= x->{
66 | return SpecialFunctions.BetaRegularized(a, b, x) - p;
67 | };
68 |
69 | return Brent.FindRoot(f, 0.0, 1.0, 1e-12);
70 | }
71 |
72 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/UnitConversion/VolumeConverter.cs:
--------------------------------------------------------------------------------
1 | namespace ToolGood.Algorithm.UnitConversion
2 | {
3 | internal sealed class VolumeConverter : BaseUnitConverter
4 | {
5 | private static UnitFactors units = new UnitFactors()
6 | {
7 | { new UnitFactorSynonyms("l", "L", "lt", "ltr", "liter", "litre", "dm³", "dm3", "cubic decimetre", "cubic decimeter","升","立方分米"), 1 },
8 | { new UnitFactorSynonyms("m³", "m3", "cubic metre","cubic meter", "立方米"), 0.001m },
9 | { new UnitFactorSynonyms("km³", "km3", "cubic kilometre","cubic kilometer", "立方千米"), 0.001m* 0.001m* 0.001m* 0.001m },
10 | { new UnitFactorSynonyms("cm³", "cm3", "cubic centimetre","cubic centimeter","立方厘米","毫升"), 1000 },
11 | { new UnitFactorSynonyms("mm³", "mm3", "cubic millimetre","cubic millimeter", "立方毫米"), 1000000 },
12 | { new UnitFactorSynonyms("ft³", "ft3", "cubic foot", "cubic feet", "cu ft","立方英尺"), 0.0353147m },
13 | { new UnitFactorSynonyms("in³", "in3", "cu in", "cubic inch","立方英寸"), 61.0237m },
14 | { new UnitFactorSynonyms("imperial pint", "imperial pt", "imperial p"), 1.75975m },
15 | { new UnitFactorSynonyms("imperial gallon", "imperial gal"), 0.219969m },
16 | { new UnitFactorSynonyms("imperial quart", "imperial qt"), 0.879877m },
17 | { new UnitFactorSynonyms("US pint", "US pt", "US p"), 2.11337643513819m },
18 | { new UnitFactorSynonyms("US gallon", "US gal"), 0.264172m },
19 | { new UnitFactorSynonyms("US quart", "US qt"), 2.11338m },
20 | };
21 |
22 | public VolumeConverter(string leftUnit, string rightUnit)
23 | {
24 | Instantiate(units, leftUnit, rightUnit);
25 | }
26 |
27 | public static bool Exists(string leftSynonym, string rightSynonym)
28 | {
29 | if (units.FindUnit(leftSynonym) != null) {
30 | return units.FindUnit(rightSynonym) != null;
31 | }
32 | return false;
33 | }
34 | }
35 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/MathNet/Distributions/StudentT.cs:
--------------------------------------------------------------------------------
1 | using ToolGood.Algorithm.MathNet.Numerics.RootFinding;
2 |
3 | namespace ToolGood.Algorithm.MathNet.Numerics.Distributions
4 | {
5 | internal sealed class StudentT
6 | {
7 | public static double CDF(double location, double scale, double freedom, double x)
8 | {
9 | //if (scale <= 0.0 || freedom <= 0.0) {
10 | // throw new ArgumentException(Resources.InvalidDistributionParameters);
11 | //}
12 |
13 | // TODO JVG we can probably do a better job for Cauchy special case
14 | if (double.IsPositiveInfinity(freedom)) {
15 | return Normal.CDF(location, scale, x);
16 | }
17 |
18 | var k = (x - location) / scale;
19 | var h = freedom / (freedom + (k * k));
20 | var ib = 0.5 * SpecialFunctions.BetaRegularized(freedom / 2.0, 0.5, h);
21 | return x <= location ? ib : 1.0 - ib;
22 | }
23 |
24 | public static double InvCDF(double location, double scale, double freedom, double p)
25 | {
26 | //if (scale <= 0.0 || freedom <= 0.0) {
27 | // throw new ArgumentException(Resources.InvalidDistributionParameters);
28 | //}
29 |
30 | // TODO JVG we can probably do a better job for Cauchy special case
31 | if (double.IsPositiveInfinity(freedom)) {
32 | return Normal.InvCDF(location, scale, p);
33 | }
34 |
35 | if (p == 0.5d) {
36 | return location;
37 | }
38 |
39 | // TODO PERF: We must implement this explicitly instead of solving for CDF^-1
40 | return Brent.FindRoot(x => {
41 | var k = (x - location) / scale;
42 | var h = freedom / (freedom + (k * k));
43 | var ib = 0.5 * SpecialFunctions.BetaRegularized(freedom / 2.0, 0.5, h);
44 | return x <= location ? ib - p : 1.0 - ib - p;
45 | }, -800, 800, accuracy: 1e-12);
46 | }
47 | }
48 | }
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/MathNet/Distributions/Exponential.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | namespace ToolGood.Algorithm.MathNet.Numerics.Distributions
4 | {
5 | ///
6 | /// Continuous Univariate Exponential distribution.
7 | /// The exponential distribution is a distribution over the real numbers parameterized by one non-negative parameter.
8 | /// Wikipedia - exponential distribution .
9 | ///
10 | sealed class Exponential
11 | {
12 | ///
13 | /// Computes the probability density of the distribution (PDF) at x, i.e. ∂P(X ≤ x)/∂x.
14 | ///
15 | /// the density at
18 | /////
29 | /// Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x).
30 | ///
31 | /// the cumulative distribution at location
34 | ///// 新增项目公式 - FlowVision
7 |
6 | /// Discrete Univariate Poisson distribution.
7 | ///
8 | ///
9 | /// Distribution is described at Wikipedia - Poisson distribution .
10 | /// Knuth's method is used to generate Poisson distributed random variables.
11 | /// f(x) = exp(-λ)*λ^x/x!;
12 | ///
13 | sealed class Poisson
14 | {
15 | ///
16 | /// Computes the probability mass (PMF) at k, i.e. P(X = k).
17 | ///
18 | /// the probability mass at location
21 | public static double PMF(double lambda, int k)
22 | {
23 | //if (!(lambda > 0.0)) {
24 | // throw new ArgumentException("InvalidDistributionParameters");
25 | //}
26 |
27 | return Math.Exp(-lambda + (k * Math.Log(lambda)) - SpecialFunctions.FactorialLn(k));
28 | }
29 |
30 | ///
31 | /// Computes the cumulative distribution (CDF) of the distribution at x, i.e. P(X ≤ x).
32 | ///
33 | /// the cumulative distribution at location
36 | ///// data, final double tau,
8 | final QuantileDefinition definition) throws Exception {
9 | double[] array = new double[data.size()];
10 | for (int i = 0; i < data.size(); i++) {
11 | array[i]=data.get(i);
12 | }
13 | return ArrayStatistics.QuantileCustomInplace(array, tau, definition);
14 | }
15 | public static double QuantileCustom(final double[] data, final double tau, final QuantileDefinition definition) throws Exception {
16 | return ArrayStatistics.QuantileCustomInplace(data, tau, definition);
17 | }
18 | public static double QuantileRank(final double[] data, final double x) {
19 | List dt= new ArrayList();
20 | for (int i = 0; i < data.length; i++) {
21 | dt.add(data[i]);
22 | }
23 | return QuantileRank(dt, x);
24 | }
25 |
26 | public static double QuantileRank(final List data, final double x) {
27 | List dt=ShellSort(data);
28 | double[] array = new double[dt.size()];
29 | for (int i = 0; i < dt.size(); i++) {
30 | array[i]=dt.get(i);
31 | }
32 | return SortedArrayStatistics.QuantileRank(array, x);
33 | }
34 |
35 | private static List ShellSort(List array) {
36 | int len = array.size();
37 | double temp;
38 | int gap = len / 2;
39 | while (gap > 0) {
40 | for (int i = gap; i < len; i++) {
41 | temp = array.get(i);
42 | int preIndex = i - gap;
43 | while (preIndex >= 0 && array.get(preIndex) > temp) {
44 | array.set(preIndex + gap, array.get(preIndex));
45 | // array[preIndex + gap] = array[preIndex];
46 | preIndex -= gap;
47 | }
48 | array.set(preIndex + gap, temp);
49 | // array[preIndex + gap] = temp;
50 | }
51 | gap /= 2;
52 | }
53 | return array;
54 | }
55 | }
--------------------------------------------------------------------------------
/tools/Antlr4Helper.sln:
--------------------------------------------------------------------------------
1 |
2 | Microsoft Visual Studio Solution File, Format Version 12.00
3 | # Visual Studio Version 16
4 | VisualStudioVersion = 16.0.30225.117
5 | MinimumVisualStudioVersion = 10.0.40219.1
6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Antlr4Helper.CSharpHelper", "Antlr4Helper.CSharpHelper\Antlr4Helper.CSharpHelper.csproj", "{39AC0C68-6CDB-4D4A-81F6-26BE0EAA1340}"
7 | EndProject
8 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Antlr4Helper.JavaScriptHelper", "Antlr4Helper.JavaScriptHelper\Antlr4Helper.JavaScriptHelper.csproj", "{F1B70AE9-51ED-4D4E-8E3B-F7C85F0CA316}"
9 | EndProject
10 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Antlr4Helper.JavaHelper", "Antlr4Helper.JavaHelper\Antlr4Helper.JavaHelper.csproj", "{C495CEF6-C191-4BBB-B95F-072F6248E86B}"
11 | EndProject
12 | Global
13 | GlobalSection(SolutionConfigurationPlatforms) = preSolution
14 | Debug|Any CPU = Debug|Any CPU
15 | Release|Any CPU = Release|Any CPU
16 | EndGlobalSection
17 | GlobalSection(ProjectConfigurationPlatforms) = postSolution
18 | {39AC0C68-6CDB-4D4A-81F6-26BE0EAA1340}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
19 | {39AC0C68-6CDB-4D4A-81F6-26BE0EAA1340}.Debug|Any CPU.Build.0 = Debug|Any CPU
20 | {39AC0C68-6CDB-4D4A-81F6-26BE0EAA1340}.Release|Any CPU.ActiveCfg = Release|Any CPU
21 | {39AC0C68-6CDB-4D4A-81F6-26BE0EAA1340}.Release|Any CPU.Build.0 = Release|Any CPU
22 | {F1B70AE9-51ED-4D4E-8E3B-F7C85F0CA316}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
23 | {F1B70AE9-51ED-4D4E-8E3B-F7C85F0CA316}.Debug|Any CPU.Build.0 = Debug|Any CPU
24 | {F1B70AE9-51ED-4D4E-8E3B-F7C85F0CA316}.Release|Any CPU.ActiveCfg = Release|Any CPU
25 | {F1B70AE9-51ED-4D4E-8E3B-F7C85F0CA316}.Release|Any CPU.Build.0 = Release|Any CPU
26 | {C495CEF6-C191-4BBB-B95F-072F6248E86B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
27 | {C495CEF6-C191-4BBB-B95F-072F6248E86B}.Debug|Any CPU.Build.0 = Debug|Any CPU
28 | {C495CEF6-C191-4BBB-B95F-072F6248E86B}.Release|Any CPU.ActiveCfg = Release|Any CPU
29 | {C495CEF6-C191-4BBB-B95F-072F6248E86B}.Release|Any CPU.Build.0 = Release|Any CPU
30 | EndGlobalSection
31 | GlobalSection(SolutionProperties) = preSolution
32 | HideSolutionNode = FALSE
33 | EndGlobalSection
34 | GlobalSection(ExtensibilityGlobals) = postSolution
35 | SolutionGuid = {28AF7A87-4382-4D6D-96C9-6287D909DF59}
36 | EndGlobalSection
37 | EndGlobal
38 |
--------------------------------------------------------------------------------
/csharp/ToolGood.Algorithm/MathNet/ExcelFunctions.ext.cs:
--------------------------------------------------------------------------------
1 | using ToolGood.Algorithm.MathNet.Numerics.Distributions;
2 |
3 | namespace ToolGood.Algorithm.MathNet.Numerics
4 | {
5 | internal static partial class ExcelFunctions
6 | {
7 | public static double GAMMALN(double z)
8 | {
9 | return SpecialFunctions.GammaLn(z);
10 | }
11 |
12 | //public static double ChiDist(double x, double freedom)
13 | //{
14 | // return Chi.PDF(x, freedom);//Is Error
15 | //}
16 |
17 | public static double ExponDist(double x, double rate, bool state)
18 | {
19 | if (state) {
20 | return Exponential.CDF(rate, x);
21 | }
22 | return Exponential.PDF(rate, x);
23 | }
24 |
25 | public static double HypgeomDist(int k, int draws, int success, int population)
26 | {
27 | return Hypergeometric.PMF(population, success, draws, k);
28 | }
29 |
30 | public static double NegbinomDist(int k, double r, double p)
31 | {
32 | return NegativeBinomial.PMF(r, p, k);
33 | }
34 |
35 | public static double LognormDist(double x, double mu, double sigma)
36 | {
37 | return LogNormal.CDF(mu, sigma, x);
38 | }
39 |
40 | public static double LogInv(double p, double mu, double sigma)
41 | {
42 | return LogNormal.InvCDF(mu, sigma, p);
43 | }
44 |
45 | public static double BinomDist(int k, int n, double p, bool state)
46 | {
47 | if (state == false) {
48 | return Binomial.PMF(p, n, k);
49 | }
50 | return Binomial.CDF(p, n, k);
51 | }
52 |
53 | public static double Poisson(int k, double lambda, bool state)
54 | {
55 | if (state == false) {
56 | return Distributions.Poisson.PMF(lambda, k);
57 | }
58 | return Distributions.Poisson.CDF(lambda, k);
59 | }
60 |
61 | public static double Weibull(double x, double shape, double scale, bool state)
62 | {
63 | if (state == false) {
64 | return Distributions.Weibull.PDF(shape, scale, x);
65 | }
66 | return Distributions.Weibull.CDF(shape, scale, x);
67 | }
68 | }
69 | }
--------------------------------------------------------------------------------