public void StandardDeviationTest()
{
double expected = 5.6325338695100524156e-01;
double actual = Circular.StandardDeviation(angles);
Assert.AreEqual(expected, actual, 1e-15);
}
/// <summary>
/// Fits the underlying distribution to a given set of observations.
/// </summary>
///
/// <param name="observations">The array of observations to fit the model against. The array
/// elements can be either of type double (for univariate data) or
/// type double[] (for multivariate data).</param>
///
/// <param name="weights">The weight vector containing the weight for each of the samples.</param>
/// <param name="options">Optional arguments which may be used during fitting, such
/// as regularization constants and additional parameters.</param>
///
/// <remarks>
/// Although both double[] and double[][] arrays are supported,
/// providing a double[] for a multivariate distribution or a
/// double[][] for a univariate distribution may have a negative
/// impact in performance.
/// </remarks>
///
public void Fit(double[] observations, double[] weights, VonMisesOptions options)
{
double m, k;
if (weights != null)
{
m = Circular.WeightedMean(observations, weights);
k = Circular.WeightedConcentration(observations, weights, m);
}
else
{
m = Circular.Mean(observations);
k = Circular.Concentration(observations, m);
}
if (options != null)
{
// Parse optional estimation options
if (options.UseBiasCorrection)
{
double N = observations.Length;
if (k < 2)
{
k = System.Math.Max(k - 1.0 / (2.0 * (N * k)), 0);
}
else
{
double Nm1 = N - 1;
k = (Nm1 * Nm1 * Nm1 * k) / (N * N * N + N);
}
}
}
initialize(m, k);
}
public void VarianceTest()
{
double expected = 0.1466856;
double actual = Circular.Variance(angles);
Assert.AreEqual(expected, actual, 1e-6);
}
public void SkewnessTest()
{
double expected = 1.4938580058598621703e-01;
double actual = Circular.Skewness(angles);
Assert.AreEqual(expected, actual, 1e-15);
}
private void computeSums()
{
cos = new double[variables];
sin = new double[variables];
for (int i = 0; i < angles.Length; i++)
Circular.Sum(angles[i], out cos[i], out sin[i]);
}
public List <Circular> getAllCirculars()
{
string query = "SELECT * FROM `circular`"
+ " INNER JOIN `user` "
+ " ON `created_by`=`user_id` "
+ " ORDER BY `created_at` DESC";
MySqlCommand mySqlCommand = new MySqlCommand(query, this.mySQLConnector.MySqlConnection);
MySqlDataReader mySqlDataReader = mySqlCommand.ExecuteReader();
List <Circular> circulars = new List <Circular>();
while (mySqlDataReader.Read())
{
Circular circular = new Circular(
mySqlDataReader.GetInt32("circular_id"),
mySqlDataReader.GetString("title"),
mySqlDataReader.GetString("body"),
mySqlDataReader.GetDateTime("created_at"),
new User(
mySqlDataReader.GetInt32("user_id"),
mySqlDataReader.GetString("email"),
mySqlDataReader.GetString("password"),
mySqlDataReader.GetString("fullname")
)
);
circulars.Add(circular);
}
mySqlDataReader.Close();
return(circulars);
}
public override void InitWithGeometry(Geometry geometry)
{
units = new VertexUnit[] { };
if (geometry is ResolvedBody)
{
resolvedBody = (ResolvedBody)geometry;
}
GeoVertex[] geoVertices = geometry.GeoVertices();
int[] ids = new int[geoVertices.Length];
for (int i = 0; i < geoVertices.Length; i++)
{
ids[i] = geoVertices[i].VertexUnit().id;
}
face = new FaceRefer(ids);
elements = new GeoElement[] { };
dependencies.AddRange(units);
GeoCircular[] geoCirculars = geometry.GeoCirculars();
if (geoCirculars.Length != 0)
{
GeoCircular geoCircular = geoCirculars[0];
circular = geoCircular.Circular();
}
}
public bool createCircular(Circular circular)
{
string query = "";
if (getCircularById(circular.CircularId) != null)
{
query = "UPDATE `circular` SET "
+ " `title`='" + circular.Title + "', "
+ " `body`='" + circular.Body + "' WHERE "
+ " `circular_id`='" + circular.CircularId + "';";
}
else
{
query = "INSERT INTO `circular` "
+ " (`circular_id`, `title`, `body`, `created_at`, `created_by`) VALUES "
+ "('NULL', '"
+ circular.Title + "', '"
+ circular.Body + "', '"
+ circular.CreatedAt.ToString("yyyy-MM-dd H:mm:ss") + "', '"
+ circular.CreatedBy.UserId + "')";
}
MySqlCommand mySqlCommand = new MySqlCommand(query, this.mySQLConnector.MySqlConnection);
MySqlDataReader mySqlDataReader = mySqlCommand.ExecuteReader();
mySqlDataReader.Close();
return(true);
}
public void CirtularDeviationTest()
{
double expected = 5.4163747152893815251e-01;
double actual = Circular.AngularDeviation(angles);
Assert.AreEqual(expected, actual, 1e-15);
}
public static Geometry <EntityVertex> Arrow()
{
return(Circular <EntityVertex> .Circle(10f, 10f.Radians())
.Stretch(new Mat4[] { Mat.Scaling <Mat4> (0.01f, 0.01f) * Mat.Translation <Mat4> (0f, 0f, -30f) }, false, false)
.Smoothen(0.9f)
.Center());
}
public IActionResult Add([FromBody] Circular model)
{
try
{
if (model == null)
{
return(BadRequest());
}
using (var db = new AllInOneContext.AllInOneContext())
{
db.Circular.Add(model);
db.SaveChanges();
// 下发通报至下级
PushCircular(model);
//
return(Created("", "OK"));
}
}
catch (DbUpdateException dbEx)
{
return(BadRequest(new ApplicationException {
ErrorCode = "DBUpdate", ErrorMessage = "数据保存异常:" + dbEx.Message
}));
}
catch (System.Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void MeanTest()
{
double expected = 0.2051961;
double actual = Circular.Mean(angles);
Assert.AreEqual(expected, actual, 1e-6);
}
public void KurtosisTest()
{
double expected = 6.4794232277921437468e-01;
double actual = Circular.Kurtosis(angles);
Assert.AreEqual(expected, actual, 1e-15);
}
public void KappaTest1()
{
double expected = 3.721646;
double actual = Circular.Concentration(angles);
Assert.AreEqual(expected, actual, 1e-6);
}
public void ClockTest2()
{
double[] hours =
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
};
double mean = Circular.Mean(hours, 24);
double stdDev = Circular.StandardDeviation(hours, 24);
double var = Circular.Variance(hours, 24);
double med = Circular.Median(hours, 24);
DoubleRange quartiles;
double median = Circular.Quartiles(hours, 24, out quartiles);
double d1 = Circular.Distance(23, 0, 24);
double d2 = Circular.Distance(0, 23, 24);
Assert.AreEqual(6, mean, 1e-15);
Assert.AreEqual(3.9598525326427247, stdDev, 1e-14);
Assert.AreEqual(6.0653308429985406, var, 1e-14);
Assert.AreEqual(6, med);
Assert.AreEqual(6, median);
Assert.AreEqual(2.5, quartiles.Min);
Assert.AreEqual(9.5, quartiles.Max);
Assert.AreEqual(-1, d1, 1e-15);
Assert.AreEqual(+1, d2, 1e-15);
}
public void WeightedKappaTest()
{
DataTable table = new DataTable();
// Add multiple columns at once:
table.Columns.Add("columnName1", "columnName2");
double[] angles = { 0.1242, 1.2425, 0.6712 };
double[] weights = { 3, 1, 1 };
weights = weights.Divide(weights.Sum());
double expectedMean = 0.4436528;
double expectedKappa = 5.497313;
double actualMean = Circular.WeightedMean(angles, weights);
Assert.AreEqual(expectedMean, actualMean, 1e-6);
double actualKappa = Circular.WeightedConcentration(angles, weights);
Assert.AreEqual(expectedKappa, actualKappa, 1e-6);
actualKappa = Circular.WeightedConcentration(angles, weights, actualMean);
Assert.AreEqual(expectedKappa, actualKappa, 1e-6);
}
/// <summary>
/// Circular refernces Test
/// </summary>
/// <param name="objectToBeCloned">Desire object to cloned</param>
/// <param name="settings"></param>
/// <returns></returns>
public void CloneCircularReferences()
{
var item = new Circular();
var cloned = FastDeepCloner.DeepCloner.Clone(item);
var s = cloned;
}
public void ClockTest()
{
double[] hours =
{
1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23
};
double mean = Circular.Mean(hours, 24);
double stdDev = Circular.StandardDeviation(hours, 24);
double var = Circular.Variance(hours, 24);
double med = Circular.Median(hours, 24);
DoubleRange quartiles;
double median = Circular.Quartiles(hours, 24, out quartiles);
double d = Circular.Distance(1, 23, 24);
Assert.AreEqual(0, mean);
Assert.AreEqual(1.0058013608769885, stdDev, 1e-11);
Assert.AreEqual(0.4971507281317768, var, 1e-11);
Assert.AreEqual(0, med);
Assert.AreEqual(0, median);
Assert.AreEqual(23, quartiles.Min, 1e-13);
Assert.AreEqual(1, quartiles.Max, 1e-13);
Assert.AreEqual(2, d, 1e-15);
}
public void MedianTest()
{
double expected = 3.1378076599999993324e-01;
double actual = Circular.Median(angles);
Assert.AreEqual(expected, actual, 1e-15);
}
public void MedianTest_Odd()
{
double expected = 3.1613437449999998163e-01;
double actual = Circular.Median(angles.RemoveAt(0));
Assert.AreEqual(expected, actual, 1e-15);
}
public void PushTest2()
{
double[] values = { 0.24, 1.61, 2.22, 5.82 };
int windowSize = values.Length;
var target = new MovingCircularStatistics(windowSize);
target.Push(0.29);
target.Push(1.11);
for (int i = 0; i < values.Length; i++)
{
target.Push(values[i]);
}
double actualMean = target.Mean;
double expectedMean = Circular.Mean(values);
Assert.AreEqual(expectedMean, actualMean, 1e-10);
double actualVariance = target.Variance;
double expectedVariance = Circular.Variance(values);
Assert.AreEqual(expectedVariance, actualVariance, 1e-10);
}
public static Geometry <EntityVertex> Tube()
{
return(Circular <EntityVertex> .Circle(10f)
.Stretch(TubeTransforms(), true, true)
.Smoothen(0.9f)
.Center());
}
public ActionResult attachCircular(CircularsPath circularsPath)
{
foreach (var file in circularsPath.circularFileName)
{
if (file != null)
{
Random random = new Random();
FileInfo fi = new FileInfo(file.FileName);
DateTime d = DateTime.Now;
var InputFileName = fi.Name;
var ServerSavePath = System.IO.Path.Combine(Server.MapPath("~/Content"), InputFileName + fi.Extension);
//Save file to server folder
file.SaveAs(ServerSavePath);
circularsPath.fileName = InputFileName;
}
}
Circular circular = new Circular()
{
fileName = circularsPath.fileName,
fileDate = DateTime.Today,
factoryId = int.Parse(circularsPath.factId),
download = false
};
context.Circulars.Add(circular);
context.SaveChanges();
return(RedirectToAction("Home", "Home", new { id = 1 }));
}
public void VarianceTest()
{
double expected = 1.4668557528213066465e-01;
double actual = Circular.Variance(angles);
Assert.AreEqual(expected, actual, 1e-15);
}
public void ClearTest()
{
double[] values = { 0.5, -1.2, 0.7, 0.2, 1.1 };
var target = new RunningCircularStatistics();
for (int i = 0; i < values.Length; i++)
{
target.Push(values[i]);
}
target.Clear();
double[] values2 = { 1.5, -5.2, 0.7, 1.2, 9.1 };
for (int i = 0; i < values.Length; i++)
{
target.Push(values2[i]);
}
Assert.AreEqual(Circular.Mean(values2), target.Mean, 1e-10);
Assert.AreEqual(Circular.Variance(values2), target.Variance, 1e-10);
Assert.AreEqual(Circular.StandardDeviation(values2), target.StandardDeviation, 1e-10);
Assert.AreEqual(values2.Length, target.Count);
}
public void MeanTest()
{
double expected = 2.0519609734450655614e-01;
double actual = Circular.Mean(angles);
Assert.AreEqual(expected, actual, 1e-15);
}
public void QuartilesTest()
{
DoubleRange range;
double median = Circular.Quartiles(angles, out range);
Assert.AreEqual(6.2828279010000001, range.Min);
Assert.AreEqual(0.60122884799999998, range.Max);
}
public int GetCircularId(string filename)
{
using (ContextClass contextClass = new ContextClass())
{
Circular circular = contextClass.Circulars.Where(x => x.FilePath == filename).SingleOrDefault();
return(circular.CircularId);
}
}
public ActionResult showCricularFiles(Circular circular)
{
var cir = context.Circulars.Where(c => c.id == circular.id).FirstOrDefault();
cir.download = true;
context.SaveChanges();
return(RedirectToAction("Home", "Home", new { id = 1 }));
}
public void AddCircular(Circular circular)
{
using (ContextClass contextClass = new ContextClass())
{
contextClass.Circulars.Add(circular);
contextClass.SaveChanges();
}
}
public void WritingCircularDependentDataThrowsException()
{
var last = new Circular();
var first = new Circular() {Next = new Circular() {Next = new Circular(){Next = last}}};
last.Next = first;
Assert.Throws<JsonSerializationException>(() => JsonConvert.Write(first));
}
public void ShouldSerializeWithCircularReferences()
{
// arrange
var obj = new Circular();
obj.Parent = obj;
// act
var result = _serializer.Serialize(obj);
// assert
result.ShouldEqual(
@"{
""$id"": ""1"",
""Parent"": {
""$ref"": ""1""
}
}");
}
public Circular()
{
Myself = this;
Foo = "bar";
}
public void CircularClassReference()
{
lock (testLock)
{
// Copy resource file to the run-time directory
string inputFilePath = GetInputFilePath("CircularClassReference.xsd", Resources.CircularClassReference);
var generatorParams = new GeneratorParams
{
InputFilePath = inputFilePath,
TargetFramework = TargetFramework.Net20,
AutomaticProperties = true,
IncludeSerializeMethod = false,
UseGenericBaseClass = false,
OutputFilePath = GetOutputFilePath(inputFilePath)
};
var xsdGen = new GeneratorFacade(generatorParams);
var result = xsdGen.Generate();
Assert.IsTrue(result.Success, result.Messages.ToString());
try
{
var cs = new Circular();
#pragma warning disable 168
int count = cs.circular.count;
#pragma warning restore 168
var compileResult = CompileCSFile(generatorParams.OutputFilePath);
Assert.IsTrue(compileResult.Success, compileResult.Messages.ToString());
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
}
