private string GeAveragesMessage()
{
if (_bloomConfig.MigrationStatistics && _averages != null)
{
_builder.Clear();
_builder.Append("Average bloom saturation: ");
for (int index = 0; index < _averages.Length; index++)
{
Average average = _averages[index];
_builder.Append((average.Value / Bloom.BitLength).ToString("P2"));
decimal count = 0;
decimal length = 0;
decimal safeBitCount = Bloom.BitLength * 0.6m;
foreach (KeyValuePair <uint, uint> bucket in average.Buckets)
{
if (bucket.Key > safeBitCount)
{
count += bucket.Value;
length += (bucket.Key - safeBitCount) * bucket.Value;
}
}
if (count > 0)
{
_builder.Append($"(W:{count}, {count / average.Count:P}, L:{length / count:F0})");
}
_builder.Append('|');
}
return(_builder.ToString());
}
return(String.Empty);
}
/// <summary>
///
/// </summary>
/// <param name="type">MIN,MAX,AVERAGE</param>
/// <returns></returns>
public static IAggregation CreateSimpleAggregation(AggregationType type)
{
IAggregation aggregation = null;
switch (type)
{
case AggregationType.MIN:
{
aggregation = new Min();
break;
}
case AggregationType.MAX:
{
aggregation = new Max();
break;
}
case AggregationType.AVERAGE:
{
aggregation = new Average();
break;
}
default:
{
throw new NotImplementedException("Not supported yet.");
}
}
return(aggregation);
}
public void Apply_When11thIs110And21thIs120_MonthAverageIs115()
{
// Arrange
var ts = new Timeseries
{
new Tvq(
new DateTime(2015, 03, 11, 0, 0, 0, 0),
110,
Quality.Ok),
new Tvq(
new DateTime(2015, 03, 21, 0, 0, 0, 0),
120,
Quality.Ok)
};
// Act
var t0 = new DateTime(2015, 03, 01, 0, 0, 0, 0);
var t1 = new DateTime(2015, 03, 30, 23, 59, 59, 999);
var result = new Average().Apply(t0, t1, ts);
// Assert
var area1 = 110 * (ts[0].Time - t0).TotalSeconds;
var area2 = 115 * (ts[1].Time - ts[0].Time).TotalSeconds;
var area3 = 120 * (t1 - ts[1].Time).TotalSeconds;
var expected = (area1 + area2 + area3) / (t1 - t0).TotalSeconds;
Assert.Equal(expected, result.V, 4);
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
Random rnd = new Random();
Color[,] color = null;
if (algorithm == AlgorithmEnum.ditheringAverage)
{
color = Average.ComputeAlgorithm(currentImage, Kr, Kg, Kb, backgroundWorker1);
}
else if (algorithm == AlgorithmEnum.ditheringOrderedVersion1)
{
color = Ordered.ComputeAlgorithmVersion1(currentImage, Kr, Kg, Kb, rnd, backgroundWorker1);
}
else if (algorithm == AlgorithmEnum.ditheringOrderedVersion2)
{
color = Ordered.ComputeAlgorithmVersion2(currentImage, Kr, Kg, Kb, rnd, backgroundWorker1);
}
else if (algorithm == AlgorithmEnum.ditheringFloydSteinberg)
{
color = ErrorDiffusion.FloydSteinberg(currentImage, Kr, Kg, Kb, backgroundWorker1);
}
else if (algorithm == AlgorithmEnum.ditheringBurkes)
{
color = ErrorDiffusion.Burkes(currentImage, Kr, Kg, Kb, backgroundWorker1);
}
else if (algorithm == AlgorithmEnum.ditheringStucky)
{
color = ErrorDiffusion.Stucky(currentImage, Kr, Kg, Kb, backgroundWorker1);
}
else if (algorithm == AlgorithmEnum.popularityAlgorythm)
{
color = Popularity.ComputeAlgorithm(currentImage, K, backgroundWorker1);
}
e.Result = color;
}
public void Apply_WhenFirstValueIsInsidePeriod_AssumesStepwise()
{
// Arrange
var tvq1 = new Tvq(
new DateTime(2015, 01, 10, 0, 0, 0, 0),
110,
Quality.Ok);
var tvq2 = new Tvq(
new DateTime(2015, 01, 20, 0, 0, 0, 0),
120,
Quality.Ok);
var ts = new Timeseries {
tvq1, tvq2
};
// Act
var t0 = new DateTime(2015, 01, 01, 0, 0, 0, 0);
var t1 = new DateTime(2015, 01, 31, 23, 59, 59, 999);
var result = new Average().Apply(t0, t1, ts);
// Assert
var area1 = tvq1.V * (tvq1.Time - t0).TotalSeconds;
var area2 = (tvq2.Time - tvq1.Time).TotalSeconds * (tvq1.V + tvq2.V) / 2;
var area3 = (t1 - tvq2.Time).TotalSeconds * tvq2.V;
var expected = (area1 + area2 + area3) / (t1 - t0).TotalSeconds;
Assert.Equal(expected, result.V);
}
public static CommonOutputs.AnomalyDetectionOutput CreateAnomalyPipelineEnsemble(IHostEnvironment env, PipelineAnomalyInput input)
{
Contracts.CheckValue(env, nameof(env));
var host = env.Register("CombineModels");
host.CheckValue(input, nameof(input));
host.CheckNonEmpty(input.Models, nameof(input.Models));
IRegressionOutputCombiner combiner;
switch (input.ModelCombiner)
{
case ScoreCombiner.Median:
combiner = new Median(host);
break;
case ScoreCombiner.Average:
combiner = new Average(host);
break;
default:
throw host.Except("Unknown combiner kind");
}
var ensemble = SchemaBindablePipelineEnsembleBase.Create(host, input.Models, combiner, MetadataUtils.Const.ScoreColumnKind.AnomalyDetection);
return(CreatePipelineEnsemble <CommonOutputs.AnomalyDetectionOutput>(host, input.Models, ensemble));
}
/// <summary>
/// Displays first name, last name, major and average.
/// </summary>
/// <returns></returns>
public override string ToString()
{
return
(FirstName + " " + LastName
+ " Major: " + Major
+ " Average: " + Average.ToString("f2"));
}
public void Refresh()
{
++counter_0;
if (counter_0 == (1000 / Properties.Settings.Default.Simulation_ComputeInterval))
{
counter_0 = 0;
for (int i = 0; i < Roads.Count; ++i)
{
MySerial.Write("#VC" + i.ToString() + "<" + Roads.ElementAt(i).Refresh().ToString() + ">");
}
MySerial.Write(";");
}
else
{
Parallel.For(0, Roads.Count, i =>
{
Roads.ElementAt(i).Refresh();
});
}
UpdateSerialRead();
for (int i = 0; i < 4; ++i)
{
AverageWaitTime += Roads.ElementAt(i).AverageWaitTime;
Roads.ElementAt(i).AverageWaitTime.Reset();
log.Add("avgwt= " + AverageWaitTime.AverageValue + "s");
}
}
public void statisticallyBestTest()
{
var m = Hash.myChar;
var o = Hash.otherChar;
var p = Board.Piece.X;
var root = Node.root;
root.children.AddRange(new Node[]
{
new Node(new Hash(p, $"{m}........"), 0, 6, 6), // 50% win
new Node(new Hash(p, $".{m}......."), 1, 9, 3) // 75% win
});
root.children[0].children.AddRange(new Node[] // Adding to the 50% node
{
new Node(new Hash(p, $"{m}.{m}......"), 2, 6, 6), // 50% win (path average of 50%)
new Node(new Hash(p, $"{m}..{m}....."), 3, 3, 9), // 25% win (path average of 62.5%)
});
root.children[1].children.AddRange(new Node[] // Adding to the 75% node
{
new Node(new Hash(p, $"{m}{m}......."), 0, 9, 3) // 75% win (path average of 75%)
});
var best = Average.statisticallyBest(root);
Assert.IsTrue(best.averageWinPercent == 75.0f);
Assert.IsTrue(best.path.Count == 2);
Assert.IsTrue(best.path[0].hash.ToString() == $".{m}......."); // It should've chosen the 75% -> 75% path.
Assert.IsTrue(best.path[1].hash.ToString() == $"{m}{m}.......");
}
static void Main(string[] args)
{
Random number = new Random();
RandomNumber randomNumber = delegate()
{
int result = number.Next(1, 101);
Console.WriteLine($"random number: {result}");
return(result);
};
Average myDelegate = delegate(RandomNumber[] arrayNumber)
{
int sum = 0;
for (int i = 0; i < arrayNumber.Length; i++)
{
sum += arrayNumber[i].Invoke();
}
return((double)sum / arrayNumber.Length);
};
RandomNumber[] array = new RandomNumber[] { randomNumber, randomNumber, randomNumber, randomNumber };
Console.WriteLine($"Average: {myDelegate.Invoke(array)} ");
Console.ReadKey();
}
public List <Average> GetSubjectAverages()
{
JArray arr = JObject.Parse(Request("/Grades/Averages"))["Averages"].ToObject <JArray>();
List <Average> result = new List <Average>();
try
{
for (int i = 0; i < arr.Count; i++)
{
JObject averageObject = arr[i].ToObject <JObject>();
string subjectId = averageObject.SelectToken("Subject").ToObject <JObject>().GetValue("Id").ToString();
string firstSemester = averageObject.GetValue("Semester1").ToString();
string secondSemester = averageObject.GetValue("Semester2").ToString();
string final = averageObject.GetValue("FullYear").ToString();
Average sa = new Average(subjectId, firstSemester, secondSemester, final);
result.Add(sa);
}
subjectAverages = result;
return(result);
}
catch (Exception ex)
{
Log("failed to parse response (averages)");
Log(ex.Message);
throw ex;
}
}
internal void CalculateResults(ReadOnlyCollection <double> selectedTrackSamples, double selectedTrackTemperature)
{
double pointTyreDegradation;
double sumOfAllPointDegradationValues = 0;
double?biggestValue = null;
double?smallestValue = null;
var modeTally = new Dictionary <int, int>();
foreach (var trackDegradationPoint in selectedTrackSamples)
{
pointTyreDegradation = CalculatePointTyreDegradation(trackDegradationPoint, SelectedTyre.TyreCoefficient, selectedTrackTemperature);
sumOfAllPointDegradationValues += pointTyreDegradation;
modeTally[(int)pointTyreDegradation] = modeTally.Keys.Contains((int)pointTyreDegradation)
? modeTally[(int)pointTyreDegradation] + 1
: 1;
biggestValue = biggestValue == null
? pointTyreDegradation
: Math.Max((double)biggestValue, pointTyreDegradation);
smallestValue = smallestValue == null
? pointTyreDegradation
: Math.Min((double)smallestValue, pointTyreDegradation);
}
var average = sumOfAllPointDegradationValues / selectedTrackSamples.Count;
Average.UpdateStateValue((int)average);
Mode.UpdateStateValue(modeTally.First(m => m.Value == modeTally.Values.Max()).Key);
if (biggestValue.HasValue)
{
Range.UpdateStateValue((int)(biggestValue - smallestValue));
}
}
private void button1_Click(object sender, EventArgs e)
{ //宣告
int A, B;
int Total;
float Average;
//輸入及轉換
A = int.Parse(textBox1.Text); //將textBox1文字方塊的內容轉成數字指定給A變數
B = int.Parse(textBox2.Text); //將textBox2文字方塊的內容轉成數字指定給B變數
//處理及輸出
Total = A + B; //將A與B的值相加後，再指定給Total變數
textBox3.Text = Total.ToString(); //最後將Total變數的內容，再指定給textBox3文字方塊
Average = Total / 2;
textBox4.Text = Average.ToString();
if (Average >= 90)
{
textBox5.Text = "甲等";
}
else if (Average >= 80 & Average < 90)
{
textBox5.Text = "乙等";
}
else if (Average >= 70 & Average < 80)
{
textBox5.Text = "丙等";
}
else if (Average >= 60 & Average < 70)
{
textBox5.Text = "丁等";
}
else
{
textBox5.Text = "戊等";
}
}
/// <summary>
/// Returns a list of string element contained within the temptwo overall data.
/// </summary>
/// <returns>Returns the list of string values contained within temptwo of overall data. returns null if an error occured and must be handled.</returns>
public List <string> GetData()
{
List <string> results = null;
try
{
List <string> temp = new List <string>();
// Add the template elements to tempory storage and return it.
temp.Add(Average.ToString());
temp.Add(LessThanMinusThree.ToString());
temp.Add(GreaterThanEqualMinusThree.ToString());
temp.Add(GreaterThanEqualMinusTwo.ToString());
temp.Add(GreaterThanEqualMinusOne.ToString());
temp.Add(ZeroWeeks.ToString());
temp.Add(LessThanEqualOneWeek.ToString());
temp.Add(LessThanEqualTwoWeeks.ToString());
temp.Add(LessThanEqualThreeWeeks.ToString());
temp.Add(GreaterThanThreeWeeks.ToString());
temp.Add(Total.ToString());
temp.Add(PercentFavorable.ToString());
results = new List <string>(temp);
temp.Clear();
temp = null;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return(results);
}
/// <summary>
/// Масштабирует число из одного числового диапазона в другой.
/// </summary>
/// <param name="val"> Начальный параметр. </param>
/// <param name="range1minVal"> Нижняя граница изначального диапазона. </param>
/// <param name="range1maxVal"> Верхняя граница изначального диапазона. </param>
/// <param name="range2minVal"> Нижняя граница целевого диапазона. </param>
/// <param name="range2maxVal"> Верхняя граница целевого диапазона. </param>
/// <returns></returns>
public static double Rescale(this double val, double range1minVal, double range1maxVal, double range2minVal, double range2maxVal)
{
double result = default;
double range1gap = range1maxVal - range1minVal;
double range2gap = range2maxVal - range2minVal;
if (range1gap == 0)
{
result = Average.GetAverage(range2minVal, range2maxVal);
goto final;
}
if (range2gap == 0)
{
result = range2minVal;
goto final;
}
double rangeRatio = range2gap / range1gap;
if (range1minVal < range1maxVal)
{
result = Math.Abs(val.NotBelow(range1minVal).NotAbove(range1maxVal) - range1minVal) * rangeRatio + range2minVal;
}
else
{
result = Math.Abs(val.NotBelow(range1maxVal).NotAbove(range1minVal) - range1maxVal) * rangeRatio + range2maxVal;
}
final : return(result);
}
static void Main(string[] args)
{
Math math = new Math();
Operation s = math.Sum;
int res = s(4, 5);
Console.WriteLine(res);
Operation r = math.Raz;
int res2 = r(5, 2);
Console.WriteLine(res2);
Say hello = math.SayHello;
hello();
Say buy = math.SayBuy;
buy();
Average aver = math.Av;
List <double> l = new List <double> {
1.0, 5.0, 2.0
};
Console.WriteLine(aver(l));
}
public void CalculateAdditionTestStrong(double firstValue, double secondValue, double expected)
{
ITwoArgumentsCalculator calculator = new Average();
double result = calculator.Calculate(26, 2);
Assert.AreEqual(14, result);
}
public void AverageTest(double firstValue, double secondValue, double expected)
{
var calculator = new Average();
var actualResult = calculator.Calculate(firstValue, secondValue);
Assert.AreEqual(expected, actualResult);
}
static void Main(string[] args)
{
SomeDel[] arr = new SomeDel[3];
arr[0] += GetRnd;
arr[1] += GetRnd;
arr[2] += GetRnd;
Average average = delegate(SomeDel[] arr)
{
int sum = 0;
foreach (var var in arr)
{
int num = var.Invoke();
sum += num;
Console.WriteLine(num);
}
return((double)sum / arr.Length);
};
Console.WriteLine($"average = {average (arr)}");
int GetRnd()
{
Random rnd = new Random();
return(rnd.Next(20));
}
}
public static void Main()
{
double[][] data;
data = Kadai.Sample.GetData();
Average A = new Average();
//----------------kadai.dllの内容を表示-------------------
Console.WriteLine("---------宿題１－１---------");
A.Show();
//----------------移動平均を求める------------------------
Console.WriteLine("---------宿題１－２---------");
double[] a = A.Ave(5);
for (int i = 0; i < a.Length; i++)
{
Console.WriteLine(a[i]);
}
//-----------------信頼区間を超えるデータを除く-------------------
Console.WriteLine("---------宿題１－３---------");
var test = A.Filter(data);
for (int i = 0; i < test.Length; i++)
{
Console.WriteLine(test[i][1]);
}
}
/// <summary>Return the average value of this coin across the given exchanges</summary>
public static Unit <decimal> AverageValue(this CoinData cd, IEnumerable <Exchange> source_exchanges)
{
// Find the average price on the available exchanges
var value = new Average <decimal>();
foreach (var exch in source_exchanges)
{
// If the exchange doesn't have this coin, skip it
var coin = exch.Coins[cd.Symbol];
if (coin == null)
{
continue;
}
// If the exchange doesn't know the value of this coin yet, skip it
var val = coin.ValueOf(1m);
if (val == 0)
{
continue;
}
// Add the value to the average
value.Add(val);
}
// Return the average value
return(value.Count != 0
? value.Mean._(SettingsData.Settings.ValuationCurrency)
: cd.AssignedValue._(SettingsData.Settings.ValuationCurrency));
}
static void Main(string[] args)
{
//////////////// Day 1 ////////////
Average av = new Average();
DisplayNumber dn = new DisplayNumber();
MultiplicationTable mt = new MultiplicationTable();
StringSwap ss = new StringSwap();
Temperature tt = new Temperature();
LongWord lw = new LongWord();
//av.FindAverage();
//dn.GetNumber();
//mt.FindMultiplication();
//ss.SwapString();
//lw.FindLongWord();
//tt.TemperatureConversion();
///////////Day 2///////////////
CubeNumber cn = new CubeNumber();
Fibonacci fs = new Fibonacci();
//cn.FindCubic();
//fs.DisplayFibonacci();
fs.DisplayFibonacciByRecursion();
}
internal static void TestMotor()
{
BBBPinManager.AddMappingPWM(BBBPin.P9_14);
BBBPinManager.ApplyPinSettings(RoverMain.ApplyDevTree);
IPWMOutput MotorOut = PWMBBB.PWMDevice1.OutputA;
IFilter <float> MotorFilter = new Average <float>(5);
TalonMC Motor = new TalonMC(MotorOut, 1F, MotorFilter);
Log.SetSingleOutputLevel(Log.Source.MOTORS, Log.Severity.DEBUG);
Motor.SetSpeed(0.2f);
/*while (true)
* {
* Log.Output(Log.Severity.DEBUG, Log.Source.MOTORS, "Outputs: " + Motor.TargetSpeed + ", " + ((PWMOutputBBB)MotorOut).GetOutput() + ", " + ((PWMOutputBBB)MotorOut).GetFrequency());
* //Motor.UpdateState();
* Thread.Sleep(100);
* }*/
int Cycle = 0;
while (true)
{
Motor.SetSpeed(((Cycle / 10) % 2 == 0) ? 1 : -1);
Thread.Sleep(25);
Cycle += 1;
}
}
public void CalculateTest(double arOne, double arTwo, double expected)
{
var calculator = new Average();
var actualResult = calculator.Calculate(arOne, arTwo);
Assert.AreEqual(expected, actualResult);
}
// GET: HighScore
/*
* The HighScoreController Index method access's the Database and uses linq to get the specfic information.
* This information is then passed over to the view where it is then displayed inside a table.
* The information gotten is from the current month and then it calculates the average score for each player from that month.
*/
public ActionResult Index()
{
QuizDBDataContext db = new QuizDBDataContext(); //Creates a instance of the DB
DateTime now = DateTime.Now; //The current DateTime
var Scores = from Re in db.tblResults //The anonyomous datatype returned from the DB which is all Results from the current month.
join Pl in db.tblPlayers
on Re.PlayerID equals Pl.PlayerID
where Re.ResultDateTime.Month == now.Month
select new { Pl.PlayerName, Re.Score, Re.ResultDateTime };
var nwScores = Scores.GroupBy(S => S.PlayerName) //The anonyomous datatype which is the PlayerName, the average score for that player from this month and the GamesPlayed.
.Select(a => new { PlayerName = a.Key, Avg = a.Average(av => av.Score), Count = a.Count() })
.OrderByDescending(c => c.Avg); //Orders the data by the Players average Score.
List <Average> PlayerAverages = new List <Average>();
foreach (var group in nwScores) //Loops through the variable nwScores
{
Average nwAvg = new Average(group.PlayerName, group.Avg, group.Count); //Sets each playerName, AverageScore and Games PLayed to a Average object.
PlayerAverages.Add(nwAvg); //Adds that current Average object to the PlayerAverages list.
}
ViewBag.Now = DateTime.Now.ToString("MMMM");
ViewBag.AVG = PlayerAverages; //Passes the PlayerAverages List to the ViewBag so it can be quickly accessed from the view.
return(View());
}
public void REPORT_FAILURE(string greekName, Average.Type averageType,
double runningAccumulator, int pastFixings,
List<Date> fixingDates, StrikedTypePayoff payoff,
Exercise exercise, double s, double q, double r,
Date today, double v, double expected,
double calculated, double tolerance)
{
Assert.Fail(exercise + " "
+ exercise
+ " Asian option with "
+ averageType + " and "
+ payoff + " payoff:\n"
+ " running variable: "
+ runningAccumulator + "\n"
+ " past fixings: "
+ pastFixings + "\n"
+ " future fixings: " + fixingDates.Count() + "\n"
+ " underlying value: " + s + "\n"
+ " strike: " + payoff.strike() + "\n"
+ " dividend yield: " + q + "\n"
+ " risk-free rate: " + r + "\n"
+ " reference date: " + today + "\n"
+ " maturity: " + exercise.lastDate() + "\n"
+ " volatility: " + v + "\n\n"
+ " expected " + greekName + ": " + expected + "\n"
+ " calculated " + greekName + ": " + calculated + "\n"
+ " error: " + Math.Abs(expected - calculated)
+ "\n"
+ " tolerance: " + tolerance);
}
/// <summary>
/// Returns a list of string element contained within the tempFour overall data.
/// </summary>
/// <returns>Returns the list of string values contained within temptFour of overall data. returns null if an error occured and must be handled.</returns>
public List <string> GetData()
{
List <string> results = null;
try
{
List <string> temp = new List <string>();
// Add the template elements to tempory storage and return it.
temp.Add(Average.ToString());
temp.Add(LessThanZero.ToString());
temp.Add(One_Three.ToString());
temp.Add(Four_Seven.ToString());
temp.Add(Eight_Fourteen.ToString());
temp.Add(Fifteen_TwentyOne.ToString());
temp.Add(TwentyTwo_TwentyEight.ToString());
temp.Add(TwentyNine_ThirtyFive.ToString());
temp.Add(ThirtySix_FourtyTwo.ToString());
temp.Add(FourtyThree_FourtyNine.ToString());
temp.Add(Fifty_FiftySix.ToString());
temp.Add(GreaterThanEqualFiftySeven.ToString());
temp.Add(Total.ToString());
temp.Add(PercentUnconf.ToString());
results = new List <string>(temp);
temp.Clear();
temp = null;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return(results);
}
public void calculateTestEmptystringArray()
{
Average value = new Average();
string[] values = new string[10];
Assert.AreEqual(0, value.calculate(values, 2));
}
/*
* характеризує якість вибірки, відображає відносну варіабельність даних у частках відносно середнього та дозволяє порівнювати варіабельність наборів даних, наведених у різних одиницях виміру. Якщо W <1, вибірка вважається якісною, тобто величина розсіювання відповідає середньому арифметичному; поміж двох вибірок кращою вважається та, для якої значення коефіцієнта W менше, тобто менша варіабельність
*/
public static double GetValue(List <double> data)
{
var standartDeviation = StandartDeviationNotSkew.GetValue(data);
double average = Average.GetAverage(data);
return(standartDeviation / average);
}
public static WordList ReorderWords(WordList original_word_list)
{
Average inter_word_gap_average = new Average();
Average word_length_average = new Average();
double last_happy_rightmost_text = Double.MaxValue;
WordList words_ordered = new WordList();
WordList words_still_to_process = new WordList();
WordList words_deferred_till_next_time = new WordList();
words_still_to_process.AddRange(original_word_list);
while (words_still_to_process.Count > 0)
{
inter_word_gap_average.Reset();
last_happy_rightmost_text = Double.MaxValue;
foreach (Word word in words_still_to_process)
{
if (word.Text.Length < 20)
{
word_length_average.Add(word.Width);
}
if (inter_word_gap_average.Count > 3 && word.Left > last_happy_rightmost_text + 3 * inter_word_gap_average.Current)
{
words_deferred_till_next_time.Add(word);
}
else if (word_length_average.Count > 1 && word.Left > last_happy_rightmost_text + 2 * word_length_average.Current)
{
words_deferred_till_next_time.Add(word);
}
else
{
words_ordered.Add(word);
if (word.Left < last_happy_rightmost_text)
{
inter_word_gap_average.Reset();
}
else
{
inter_word_gap_average.Add(word.Left - last_happy_rightmost_text);
}
last_happy_rightmost_text = word.Left + word.Width;
}
}
words_still_to_process.Clear();
Swap <WordList> .swap(ref words_still_to_process, ref words_deferred_till_next_time);
if (words_still_to_process.Count > 0)
{
Logging.Debug特("We have a multiple column situation with {0} words outstanding", words_still_to_process.Count);
}
}
return(words_ordered);
}
public void calculateTestEmptyList()
{
Average value = new Average();
List <double> list_values = new List <double>();
Assert.AreEqual(0, value.calculate(list_values));
}
public string averageTypeToString(Average.Type averageType)
{
if (averageType == Average.Type.Geometric)
return "Geometric Averaging";
else if (averageType == Average.Type.Arithmetic)
return "Arithmetic Averaging";
else
throw new ApplicationException("unknown averaging");
}
public Average[] BuildAverageArray(Student[] fullClass)
{
Average[] students = new Average[fullClass.Length];
for (int i = 0; i < fullClass.Length; i++)
{
students[i].name = fullClass[i].name;
students[i].average = CalculateGeneralAveragePerStudent(fullClass[i]);
}
return students;
}
void Start()
{
_instance = this;
numberSpriteNames = new string[]
{
"seg_34px_g_00", // 0
"seg_34px_g_01", // 1
"seg_34px_g_02", // 2
"seg_34px_g_03", // 3
"seg_34px_g_04", // 4
"seg_34px_g_05", // 5
"seg_34px_g_06", // 6
"seg_34px_g_07", // 7
"seg_34px_g_08", // 8
"seg_34px_g_09", // 9
};
}
public ContinuousAveragingAsianOption(Average.Type averageType, Payoff payoff, Exercise exercise) : this(NQuantLibcPINVOKE.new_ContinuousAveragingAsianOption((int)averageType, Payoff.getCPtr(payoff), Exercise.getCPtr(exercise)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Average obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
public Average Column(ColInfo c)
{
var a = new Average();
var q = from w in Weeks
from m in w.Meetings
where c.Times.Contains(m.date.TimeOfDay)
group m by w.Sunday into g
select g.Sum(mm => mm.Present);
if (q.Count() == 0)
a.avg = 0;
else
a.avg = q.Average();
a.totalpeople = q.Sum();
a.totalmeetings = q.Count();
return a;
}
public Average Total()
{
var a = new Average();
var q = from w in Weeks
from m in w.Meetings
group m by w.Sunday into g
select g.Sum(mm => mm.Present);
if (q.Count() == 0)
a.avg = 0;
else
a.avg = q.Average();
a.totalmeetings = q.Count();
a.totalpeople = q.Sum();
return a;
}
static void SwapForAverage(ref Average a, ref Average b)
{
Average temp = a;
a = b;
b = temp;
}
public static bool WriteCommand(SerialPort port, ACommands command, Average average)
{
try
{
byte[] snddata = new byte[4];
snddata[0] = (byte)command;
snddata[1] = (byte)average;
byte[] CRC = GetCRC(snddata);
snddata[2] = CRC[0];
snddata[3] = CRC[1];
if (Write(port, snddata))
return true;
else
return false;
}
catch (Exception ex)
{
FileWorker.WriteEventFile(DateTime.Now, "ASubDriver", "WriteCommand", ex.Message);
return false;
}
}
public Average Total()
{
var a = new Average();
var q = (from w in Weeks
from m in w.Meetings
group m by w.Sunday
into g
select g.Sum(mm => mm.Present)).ToList();
a.Avg = q.Any() ? q.Average() : 0;
a.TotalMeetings = q.Count;
a.TotalPeople = q.Sum();
return a;
}
public Average Column(ColInfo c)
{
var a = new Average();
var q = (from w in Weeks
from m in w.Meetings
where c.Times.Contains(m.Date.TimeOfDay)
group m by w.Sunday
into g
select g.Sum(mm => mm.Present)).ToList();
a.Avg = q.Any() ? q.Average() : 0;
a.TotalPeople = q.Sum();
a.TotalMeetings = q.Count();
return a;
}
public DiscreteAveragingAsianOption(Average.Type averageType, double runningAccumulator, uint pastFixings, DateVector fixingDates, Payoff payoff, Exercise exercise) : this(NQuantLibcPINVOKE.new_DiscreteAveragingAsianOption((int)averageType, runningAccumulator, pastFixings, DateVector.getCPtr(fixingDates), Payoff.getCPtr(payoff), Exercise.getCPtr(exercise)), true) {
if (NQuantLibcPINVOKE.SWIGPendingException.Pending) throw NQuantLibcPINVOKE.SWIGPendingException.Retrieve();
}
private static byte[] ProcessMergerClient(byte[] bytes)
{
try
{
// 1.获取合并包
var client = Serializer.DeserializeFromBytes<MergePacket>(bytes);
// 2.处理消息
if (client.Type == MergePacket.MergeType.Sum)
{
Sum sum = new Sum(client.TimeStamp, client.AppName);
double result = sum.Compute(Serializer.DeserializeFromBytes<double>(client.Data));
string flag = "sum_" + client.TimeStamp + "_" + client.AppName;
Logger.Info(flag + ",result is " + result);
sum.Remove(flag);
return Serializer.SerializeToBytes(result);
}
if (client.Type == MergePacket.MergeType.Average)
{
Average average = new Average(client.TimeStamp, client.AppName);
double result = average.Compute(Serializer.DeserializeFromBytes<double>(client.Data));
string flag = "average_" + client.TimeStamp + "_" + client.AppName;
Logger.Info(flag + ",result is " + result);
average.Remove(flag);
return Serializer.SerializeToBytes(result);
}
if (client.Type == MergePacket.MergeType.Distinct)
{
Distinct distinct = new Distinct(client.TimeStamp, client.AppName);
List<object> objects = distinct.Compute(Serializer.DeserializeFromBytes<List<object>>(client.Data));
string flag = "distinct_" + client.TimeStamp + "_" + client.AppName;
Logger.Info(flag + ", result count is " + objects.Count);
return Serializer.SerializeToBytes(objects);
}
if (client.Type == MergePacket.MergeType.CombineTable)
{
CombineTable combineTable = new CombineTable(client.TimeStamp, client.AppName);
string flag = "combine_table_" + client.TimeStamp + "_" + client.AppName;
Logger.Info(flag + ", combine table.");
Hashtable objects = combineTable.Compute(Serializer.DeserializeFromBytes<Hashtable>(client.Data));
return Serializer.SerializeToBytes(objects);
}
if (client.Type == MergePacket.MergeType.CombineList)
{
CombineList combineList = new CombineList(client.TimeStamp, client.AppName);
string flag = "combine_list_" + client.TimeStamp + "_" + client.AppName;
Logger.Info(flag + ", combine list.");
List<object> objects = combineList.Compute(Serializer.DeserializeFromBytes<List<object>>(client.Data));
return Serializer.SerializeToBytes(objects);
}
if (client.Type == MergePacket.MergeType.CombineSort)
{
try
{
CombineSort combineSort = new CombineSort(client.TimeStamp, client.AppName);
string flag = "combine_sort_" + client.TimeStamp + "_" + client.AppName;
Logger.Info(flag + ", combine sort.");
object[] objects = combineSort.ArrayCompute(Serializer.DeserializeFromBytes(client.Data));
if (objects == null)
{
Logger.Warn("Result is null.");
}
else
{
Logger.Info("Result count is " + objects.Count());
}
return Serializer.SerializeToBytes(objects);
}
catch (Exception exception)
{
Logger.Error(exception);
}
object[] errorObjects = { -1 };
return Serializer.SerializeToBytes(errorObjects);
}
}
catch (Exception exception)
{
Logger.Error(exception);
}
return Serializer.SerializeToBytes(-1);
}
public static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(MyMediaLite.Util.Handlers.UnhandledExceptionHandler);
Console.CancelKeyPress += new ConsoleCancelEventHandler(AbortHandler);
// recommender arguments
string method = null;
string recommender_options = string.Empty;
// help/version
bool show_help = false;
bool show_version = false;
// variables for iteration search
int max_iter = 500;
double cutoff = 0;
double epsilon = 0;
string measure = "AUC";
compute_fit = false;
// other parameters
test_ratio = 0;
num_test_users = -1;
repeat_eval = false;
var p = new OptionSet() {
// string-valued options
{ "training-file=", v => training_file = v },
{ "test-file=", v => test_file = v },
{ "recommender=", v => method = v },
{ "group-recommender=", v => group_method = v },
{ "recommender-options=", v => recommender_options += " " + v },
{ "data-dir=", v => data_dir = v },
{ "user-attributes=", v => user_attributes_file = v },
{ "item-attributes=", v => item_attributes_file = v },
{ "user-relations=", v => user_relations_file = v },
{ "item-relations=", v => item_relations_file = v },
{ "save-model=", v => save_model_file = v },
{ "load-model=", v => load_model_file = v },
{ "save-user-mapping=", v => save_user_mapping_file = v },
{ "save-item-mapping=", v => save_item_mapping_file = v },
{ "load-user-mapping=", v => load_user_mapping_file = v },
{ "load-item-mapping=", v => load_item_mapping_file = v },
{ "prediction-file=", v => prediction_file = v },
{ "test-users=", v => test_users_file = v },
{ "candidate-items=", v => candidate_items_file = v },
{ "user-groups=", v => user_groups_file = v },
{ "measure=", v => measure = v },
// integer-valued options
{ "find-iter=", (int v) => find_iter = v },
{ "max-iter=", (int v) => max_iter = v },
{ "random-seed=", (int v) => random_seed = v },
{ "predict-items-number=", (int v) => predict_items_number = v },
{ "num-test-users=", (int v) => num_test_users = v },
{ "cross-validation=", (uint v) => cross_validation = v },
// floating point options
{ "epsilon=", (double v) => epsilon = v },
{ "cutoff=", (double v) => cutoff = v },
{ "test-ratio=", (double v) => test_ratio = v },
{ "rating-threshold=", (float v) => rating_threshold = v },
// enum options
{ "file-format=", (ItemDataFileFormat v) => file_format = v },
// boolean options
{ "user-prediction", v => user_prediction = v != null },
{ "compute-fit", v => compute_fit = v != null },
{ "online-evaluation", v => online_eval = v != null },
{ "repeat-evaluation", v => repeat_eval = v != null },
{ "no-id-mapping", v => no_id_mapping = v != null },
{ "overlap-items", v => overlap_items = v != null },
{ "all-items", v => all_items = v != null },
{ "in-training-items", v => in_training_items = v != null },
{ "in-test-items", v => in_test_items = v != null },
{ "help", v => show_help = v != null },
{ "version", v => show_version = v != null },
};
IList<string> extra_args = p.Parse(args);
bool no_eval = true;
if (test_ratio > 0 || test_file != null)
no_eval = false;
if (show_version)
ShowVersion();
if (show_help)
Usage(0);
if (random_seed != -1)
MyMediaLite.Util.Random.Seed = random_seed;
// set up recommender
if (load_model_file != null)
recommender = Model.Load(load_model_file);
else if (method != null)
recommender = Recommender.CreateItemRecommender(method);
else
recommender = Recommender.CreateItemRecommender("MostPopular");
// in case something went wrong ...
if (recommender == null && method != null)
Usage(string.Format("Unknown recommendation method: '{0}'", method));
if (recommender == null && load_model_file != null)
Abort(string.Format("Could not load model from file {0}.", load_model_file));
CheckParameters(extra_args);
recommender.Configure(recommender_options, (string m) => { Console.Error.WriteLine(m); Environment.Exit(-1); });
if (no_id_mapping)
{
user_mapping = new IdentityMapping();
item_mapping = new IdentityMapping();
}
if (load_user_mapping_file != null)
user_mapping = EntityMappingExtensions.LoadMapping(load_user_mapping_file);
if (load_item_mapping_file != null)
item_mapping = EntityMappingExtensions.LoadMapping(load_item_mapping_file);
// load all the data
LoadData();
Console.Write(training_data.Statistics(test_data, user_attributes, item_attributes));
// if requested, save ID mappings
if (save_user_mapping_file != null)
user_mapping.SaveMapping(save_user_mapping_file);
if (save_item_mapping_file != null)
item_mapping.SaveMapping(save_item_mapping_file);
TimeSpan time_span;
if (find_iter != 0)
{
if ( !(recommender is IIterativeModel) )
Abort("Only iterative recommenders (interface IIterativeModel) support --find-iter=N.");
var iterative_recommender = (IIterativeModel) recommender;
Console.WriteLine(recommender);
var eval_stats = new List<double>();
if (cross_validation > 1)
{
recommender.DoIterativeCrossValidation(cross_validation, test_users, candidate_items, eval_item_mode, repeat_eval, max_iter, find_iter);
}
else
{
if (load_model_file == null)
recommender.Train();
if (compute_fit)
Console.WriteLine("fit: {0} iteration {1} ", ComputeFit(), iterative_recommender.NumIter);
var results = Evaluate();
Console.WriteLine("{0} iteration {1}", results, iterative_recommender.NumIter);
for (int it = (int) iterative_recommender.NumIter + 1; it <= max_iter; it++)
{
TimeSpan t = Wrap.MeasureTime(delegate() {
iterative_recommender.Iterate();
});
training_time_stats.Add(t.TotalSeconds);
if (it % find_iter == 0)
{
if (compute_fit)
{
t = Wrap.MeasureTime(delegate() {
Console.WriteLine("fit: {0} iteration {1} ", ComputeFit(), it);
});
fit_time_stats.Add(t.TotalSeconds);
}
t = Wrap.MeasureTime(delegate() { results = Evaluate(); });
eval_time_stats.Add(t.TotalSeconds);
eval_stats.Add(results[measure]);
Console.WriteLine("{0} iteration {1}", results, it);
Model.Save(recommender, save_model_file, it);
Predict(prediction_file, test_users_file, it);
if (epsilon > 0.0 && eval_stats.Max() - results[measure] > epsilon)
{
Console.Error.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0} >> {1}", results["RMSE"], eval_stats.Min()));
Console.Error.WriteLine("Reached convergence on training/validation data after {0} iterations.", it);
break;
}
if (results[measure] < cutoff)
{
Console.Error.WriteLine("Reached cutoff after {0} iterations.", it);
Console.Error.WriteLine("DONE");
break;
}
}
} // for
}
}
else
{
Console.WriteLine(recommender + " ");
if (load_model_file == null)
{
if (cross_validation > 1)
{
var results = recommender.DoCrossValidation(cross_validation, test_users, candidate_items, eval_item_mode, compute_fit, true);
Console.Write(results);
no_eval = true;
}
else
{
time_span = Wrap.MeasureTime( delegate() { recommender.Train(); } );
Console.Write("training_time " + time_span + " ");
}
}
if (prediction_file != null)
{
Predict(prediction_file, test_users_file);
}
else if (!no_eval)
{
if (compute_fit)
Console.WriteLine("fit: {0}", ComputeFit());
if (online_eval)
time_span = Wrap.MeasureTime( delegate() {
var results = recommender.EvaluateOnline(test_data, training_data, test_users, candidate_items, eval_item_mode);
Console.Write(results);
});
else if (group_method != null)
{
GroupRecommender group_recommender = null;
Console.Write("group recommendation strategy: {0} ", group_method);
// TODO GroupUtils.CreateGroupRecommender(group_method, recommender);
if (group_method == "Average")
group_recommender = new Average(recommender);
else if (group_method == "Minimum")
group_recommender = new Minimum(recommender);
else if (group_method == "Maximum")
group_recommender = new Maximum(recommender);
else
Usage("Unknown group recommendation strategy in --group-recommender=METHOD");
time_span = Wrap.MeasureTime( delegate() {
var result = group_recommender.Evaluate(test_data, training_data, group_to_user, candidate_items);
Console.Write(result);
});
}
else
time_span = Wrap.MeasureTime( delegate() { Console.Write(Evaluate()); });
Console.Write(" testing_time " + time_span);
}
Console.WriteLine();
}
Model.Save(recommender, save_model_file);
DisplayStats();
}
public List<Average> movingAverage(IList<StockIntervalData> intervals, int N)
{
List<Average> result = new List<Average>();
for (int i = 0; i < intervals.Count; ++i)
{
decimal c = (intervals[i].open + intervals[i].close) / 2;
Average res = new Average { date = intervals[i].date , valueAverage = c };
result.Add(res);
}
for (int i =result.Count-1;i >=0; --i ){
if (( i+1)<N) {
Average a= result[i] ;
a.valueAverage=calculateAveage(result,0,i);
result[i]=a;
}
else {
Average a = result[i];
a.valueAverage=calculateAveage(result,i-N+1,i);
result[i] = a;
}
}
return result;
}
