public void SetMinMax(IList<Point> points)
{
if (_isMaxMinSet)
{
var minX = points.Min(point => point.X);
MinX = minX < MinX ? minX : MinX;
var maxX = points.Max(point => point.X);
MaxX = maxX > MaxX ? maxX : MaxX;
var minY = points.Min(point => point.Y);
MinY = minY < MinY ? minY : MinY;
var maxY = points.Max(point => point.Y);
MaxY = maxY > MaxY ? maxY : MaxY;
}
else
{
MinX = points.Min(point => point.X);
MaxX = points.Max(point => point.X);
MinY = points.Min(point => point.Y);
MaxY = points.Max(point => point.Y);
_isMaxMinSet = true;
}
SetOriginPoint(GetDelta());
}
public SeasonWeek AddWeekToSeason(int seasonId, IList<RealWorldFixture> fixtures)
{
var season = LoadSeason(seasonId);
var currentFinalWeek = season.Weeks.Any() ? season.Weeks.Max(w => w.WeekNumber) : 0;
if (currentFinalWeek == season.NumberOfWeeks)
throw new InvalidOperationException("Season has full complement of weeks already");
var predsCutoffDate = fixtures.Min(f => f.KickOff).AddHours(-1);
var addedWeek = new SeasonWeek
{
WeekNumber = currentFinalWeek + 1,
RealWorldFixtures = fixtures,
PredsCutOffDate = predsCutoffDate,
Season = season,
};
foreach (var fixture in fixtures)
{
fixture.SeasonWeek = addedWeek;
}
season.Weeks.Add(addedWeek);
_seasonRepository.Save(season);
return addedWeek;
}
/// <summary>
/// Generates intervals based on type, numberOfClasses and values.
/// </summary>
/// <param name="values"></param>
/// <param name="type"></param>
/// <param name="numberOfClasses"></param>
/// <returns></returns>
public static IList<Interval> GetIntervalsForNumberOfClasses(IList<Single> values, QuantityThemeIntervalType type, int numberOfClasses)
{
int index = 0;
var intervals = new List<Interval>();
var lowValue = values.Min();
var highValue = values.Max();
if (type == QuantityThemeIntervalType.NaturalBreaks)
{
ArrayList.Adapter((IList)values).Sort(); // performance, works 20% faster than layerAttribute.AttributeValues.Sort();
}
for (int i = 0; i < numberOfClasses; i++)
{
float intervalMin;
float intervalMax;
if (type == QuantityThemeIntervalType.EqualIntervals)
{
intervalMin = lowValue + i * ((highValue - lowValue) / numberOfClasses);
intervalMax = lowValue + (i + 1) * ((highValue - lowValue) / numberOfClasses);
}
else
{
intervalMin = Convert.ToSingle(values[index]);
index = (int)Math.Ceiling((double)(i + 1) / numberOfClasses * (values.Count - 1));
intervalMax = Convert.ToSingle(values[index]);
}
var interval = new Interval(intervalMin, intervalMax);
intervals.Add(interval);
}
return intervals;
}
public List<Point> ConvexHull(IList<Point> points)
{
if (points.Count < 3)
{
throw new ArgumentException("At least 3 points reqired", "points");
}
List<Point> hull = new List<Point>();
// get leftmost point
Point vPointOnHull = points.Where(p => p.X == points.Min(min => min.X)).First();
Point vEndpoint;
do
{
hull.Add(vPointOnHull);
vEndpoint = points[0];
for (int i = 1; i < points.Count; i++)
{
if ((vPointOnHull.IsTheSame(vEndpoint)) || (Orientation(vPointOnHull, vEndpoint, points[i]) == -1))
{
vEndpoint = points[i];
}
}
vPointOnHull = vEndpoint;
}
while (!vEndpoint.IsTheSame(hull[0]));
return hull;
}
/// <summary>
/// I feel like this way is a little bit more optimized since it saves space
/// there is still the possibility of empty space beetwen min,max
/// but atleast it gets rid of the space from 0 to min
///
/// This will also work with negative numbers.
/// </summary>
public static int[] Sort(IList<int> data, int min, int max)
{
Contract.Ensures(data != null, "data cannot be a null pointer");
Contract.Ensures(min == data.Min(), "wrong min submitted");
Contract.Ensures(max == data.Max(), "wrong max submitted");
int[] count = new int[(max - min) + 1];
int[] sorted = new int[data.Count];
// Add the elements in reverse order big --> small
// NOTE: Could do key - min instead for order small --> big
foreach (int key in data)
{
count[max - key] += 1;
}
// Transfer the temp array to the sorted array from small --> big
int sortedIndex = data.Count - 1;
for (int i = 0; i < count.Length; i++)
{
// How often did we have this number in the input?
int number = max - i;
for (int j = 0; j < count[i]; j++)
{
sorted[sortedIndex--] = number;
}
}
return sorted;
}
static void DisplayStats(IList<Response> responses)
{
if (!responses.Any())
{
return;
}
var average = responses.Average(x => (x.EndUtc - x.StartUtc).TotalMilliseconds);
ClearLine();
Console.WriteLine("Average time: {0} ms", Convert.ToInt32(average));
var min = responses.Min(x => x.StartUtc);
var max = responses.Max(x => x.EndUtc);
var count = responses.Count;
var timespan = Convert.ToInt32((max - min).TotalMilliseconds);
timespan = timespan == 0 ? 0 : timespan / 1000;
var rps = timespan == 0 ? 0 : count / timespan;
ClearLine();
Console.WriteLine("Performance: {0} rps ({1} reqs in {2})", Convert.ToInt32(rps), responses.Count, timespan);
ClearLine();
Console.WriteLine("Threads: {0}", responses.Select(x => x.TaskId).Distinct().Count());
ClearLine();
Console.WriteLine("Errors: {0}", responses.Count(x => !x.Success));
}
public int CalculateDeceitfulWar(IList<double> first, IList<double> second)
{
if (first.Count == 0)
return 0;
double min1 = first.Min();
double min2 = second.Min();
bool win = false;
double play1;
double play2;
if (min1 < min2)
{
play1 = min1;
play2 = second.Max();
}
else
{
play1 = min1;
play2 = min2;
win = true;
}
var newfirst = first.Where(n => n != play1).ToList();
var newsecond = second.Where(n => n != play2).ToList();
return CalculateDeceitfulWar(newfirst, newsecond) + (win ? 1 : 0);
}
private static int ResolveNormal(IList<int> pancakes)
{
int maxvalue = pancakes.Max();
int minvalue = pancakes.Min();
if (minvalue == maxvalue)
return maxvalue;
int secondmaxvalue = pancakes.Where(n => n != maxvalue).Max();
IList<int> newpancakes = new List<int>();
int steps = maxvalue - secondmaxvalue;
foreach (int value in pancakes)
{
if (value == maxvalue)
newpancakes.Add(secondmaxvalue);
else if (value > steps)
newpancakes.Add(value - steps);
}
if (newpancakes.Count == 0)
return 1;
return Resolve(newpancakes) + steps;
}
/// <summary>
/// Convert numbers to spark chart strings.
/// </summary>
/// <param name="data">List or Array of numbers</param>
/// <returns>empty string if <paramref name="data"/>is <code>null</code> or empty.</returns>
public static String Render(IList<double> data)
{
var ticks = TickProvider.Ticks;
if (data == null || data.Count == 0)
return string.Empty;
char[] res = new char[data.Count()];
double min = data.Min();
double max = data.Max();
double step = (max - min) / (ticks.Length - 1);
if (step.Equals(0d)) step = 1;
for (var i = 0; i < data.Count(); i++)
{
var val = data[i];
double d = (val - min)/step;
// if it's 10^-10 close to its rounded, round; floor otherwise
int tick = (int) ((Math.Abs(Math.Round(d) - d) < 1e-10) ? Math.Round(d) : Math.Floor((val - min) / step));
res[i] = ticks[tick];
}
return new string(res);
}
public override void Draw(
IList<Point> points,
double thickness,
int miterLimit,
ILogicalToScreenMapper logicalToScreenMapper)
{
var pointsCount = points.Count;
var firstPoint = points[0];
var lastPoint = points[pointsCount - 1];
var highestValue = _useHighest ? points.Max(it => it.Y) : 0;
var lowestValue = _useLowest ? points.Min(it => it.Y) : 0;
double baselineValue;
// Auf gleiche Höhe bringen
if (_useBaseline)
baselineValue = logicalToScreenMapper.MapY(_baselineValue);
else if (_useHighest)
baselineValue = highestValue;
else if (_useLowest)
baselineValue = lowestValue;
else
{
baselineValue = firstPoint.Y > lastPoint.Y
? lastPoint.Y
: firstPoint.Y;
}
using (var dc = RenderOpen())
{
for (var i = 1; i < points.Count; i++)
{
var previousPoint = points[i - 1];
var currentPoint = points[i];
var previousY = previousPoint.Y;
// -1 weil: 1 Pixel nach links verschieben bewirkt, dass die Löcher zwischen den Rechtecken nicht mehr auftauchen
// nicht mehr nach 1 verschieben, weil der Fall bei Kriko (kleine Löcher in den Kurven) sowieso nicht vorkommt
// var previousX = previousPoint.X - 1;
var previousX = previousPoint.X;
// Rect kann mit negativen Höhen nicht umgehen, deshalb die komischen Expressions
var height = previousY > baselineValue ? previousY - baselineValue : baselineValue - previousY;
var y = previousY > baselineValue ? baselineValue : previousY;
var rectangle = new Rect(
previousX,
height == 0 ? y - 1 : y, // Linie um 1 nach oben verschieben, damit die Linien nicht optisch nach unten versetzt sind
currentPoint.X - previousX,
height == 0d ? 1 : height);
dc.DrawRectangle(
Brushes.White,
new Pen(
Brushes.White,
0)
// brauchen wir nicht mehr (siehe oben - height == 0): thickness == 1 ? 0.25 : thickness)
{
MiterLimit = miterLimit
},
rectangle);
}
}
}
public AggregationOperationResult Do(IList<double> input)
{
if (input == null)
throw new ArgumentNullException("input");
if (!input.Any())
throw new InvalidOperationException("No elements to aggregate");
return new AggregationOperationResult(AggregationType.Min,input.Min());
}
private static Department FindDepartmentWithMinSortOrder(IList<Department> departments)
{
int firstSortOrder = departments.Min(d => d.SortOrder);
return (from d in departments
where d.SortOrder == firstSortOrder
select d).First();
}
public AggregationOperationResult Do(IList<UniversalValue> input)
{
if (input == null)
throw new ArgumentNullException("input");
AggregationOperationResult result = new AggregationOperationResult();
result.Add("min", input.Min());
return result;
}
public IList<WordIntPair> GetFontSizes(IList<WordIntPair> wordsAndFreqs, InputOptions options)
{
int minCount = wordsAndFreqs.Min(t => t.Number);
int maxCount = wordsAndFreqs.Max(t => t.Number);
return wordsAndFreqs.Select(tuple => new WordIntPair(
tuple.Word,
CountFont(tuple.Number, options.MaxFont, options.MinFont, minCount, maxCount)))
.ToList();
}
private int GetTheta(int current, IList<int> sortedCardinalities)
{
var result = sortedCardinalities.Count(i => i >= current);
if (current != sortedCardinalities.Min())
{
result = result + 1;
}
return result;
}
public RelatorioJogosDisponiveisModel(IList<Jogo> jogosDisponiveis)
{
this.Jogos = new List<JogoDisponivelModel>();
if(jogosDisponiveis != null && jogosDisponiveis.Count > 0)
{
foreach (Jogo jogo in jogosDisponiveis)
{
var jogoModel = new JogoDisponivelModel(jogo);
this.Jogos.Add(jogoModel);
}
this.QuantidadeTotalDeJogos = jogosDisponiveis.Count;
this.ValorMedio = jogosDisponiveis.Average(j => j.Preco);
decimal maiorPreco = jogosDisponiveis.Max(j => j.Preco);
decimal menorPreco = jogosDisponiveis.Min(j => j.Preco);
this.JogoMaisCaro = this.Jogos.First(j => j.Preco == maiorPreco);
this.JogoMaisBarato = this.Jogos.First(j => j.Preco == menorPreco);
}
}
/// <summary>
/// I feel like this way is a little bit more optimized since it saves space
/// there is still the possibility of empty space beetwen min,max
/// but atleast it gets rid of the space from 0 to min
///
/// This will also work with negative numbers.
/// </summary>
public static int[] Sort(IList <int> data, int min, int max)
{
Contract.Ensures(data != null, "data cannot be a null pointer");
Contract.Ensures(min == data.Min(), "wrong min submitted");
Contract.Ensures(max == data.Max(), "wrong max submitted");
int[] count = new int[(max - min) + 1];
int[] sorted = new int[data.Count];
// Add the elements in reverse order big --> small
// NOTE: Could do key - min instead for order small --> big
foreach (int key in data)
{
count[max - key] += 1;
}
// Transfer the temp array to the sorted array from small --> big
int sortedIndex = data.Count - 1;
for (int i = 0; i < count.Length; i++)
{
// How often did we have this number in the input?
int number = max - i;
for (int j = 0; j < count[i]; j++)
{
sorted[sortedIndex--] = number;
}
}
return(sorted);
}
public override IEnumerable <WeightedTop> CalculateRule(Top agent, Top previousTarget, IList <Top> others)
{
// FIXME: use spin here instead of float
float minSpin = others.Min(t => (float)t.CurrentSpin);
return(others.Select(t => new WeightedTop(t, t.CurrentSpin == minSpin ? 1 : 0)));
}
public AND(SemanticContext a, SemanticContext b)
{
HashSet <SemanticContext> operands = new HashSet <SemanticContext>();
if (a is SemanticContext.AND)
{
operands.UnionWith(((AND)a).opnds);
}
else
{
operands.Add(a);
}
if (b is SemanticContext.AND)
{
operands.UnionWith(((AND)b).opnds);
}
else
{
operands.Add(b);
}
IList <SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates(operands);
if (precedencePredicates.Count > 0)
{
// interested in the transition with the lowest precedence
SemanticContext.PrecedencePredicate reduced = precedencePredicates.Min();
operands.Add(reduced);
}
opnds = operands.ToArray();
}
/// <summary>
/// Sets the values for this segment. This method is not
/// intended to be called explicitly outside the Chart but it can be overriden by
/// any derived class.
/// </summary>
/// <param name="x1Values"></param>
/// <param name="y1Values"></param>
/// <param name="x2Values"></param>
/// <param name="y2Values"></param>
public override void SetData(IList <double> x1Values, IList <double> y1Values, IList <double> x2Values, IList <double> y2Values)
{
this.x1ChartVals = x1Values;
this.y1ChartVals = y1Values;
this.x2ChartVals = x2Values;
this.y2ChartVals = y2Values;
double X_MAX = x2Values.Max();
double Y_MAX = y1Values.Max();
double X_MIN = x1Values.Min();
double _Min = y1ChartVals.Min();
double Y_MIN;
if (double.IsNaN(_Min))
{
var yVal = y1ChartVals.Where(e => !double.IsNaN(e));
Y_MIN = (!yVal.Any()) ? 0 : yVal.Min();
}
else
{
Y_MIN = _Min;
}
double Y2_Min = y2ChartVals.Min();
XRange = new DoubleRange(X_MIN, X_MAX);
YRange = new DoubleRange((Y_MIN <Y2_Min && Y_MAX> Y2_Min) ? Y_MIN : Y2_Min, Y2_Min < Y_MAX ? Y_MAX : Y_MIN);
}
/// <summary>
/// 获取从头开始的最大公共子串
/// </summary>
/// <returns></returns>
public static XPath GetMaxCompareXPath(IList <XPath> items)
{
int minlen = items.Min(d => d.Count);
string c = null;
int i = 0;
for (i = 0; i < minlen; i++)
{
for (int index = 0; index < items.Count; index++)
{
XPath path = items[index];
if (index == 0)
{
c = path[i];
}
else
{
if (c != path[i])
{
goto OVER;
}
}
}
}
OVER:
XPath first = items.First().SubXPath(i + 1);
first.RemoveFinalNum();
return(first);
}
public void Min_ArrEmpty_Exc()
{
IList list = ConvertToListType(TestContext.DataRow["List Type"].ToString());
list.Init(new int[] { });
list.Min();
}
private void DrawDebugInformation(GameTime time)
{
_fps.Add(1 / time.ElapsedGameTime.TotalSeconds);
_gbfps.Add(GameBoy.Cpu.FramesPerSecond);
var difference = time.TotalGameTime - _last;
if (difference.TotalSeconds > 1)
{
_minGbFps = _gbfps.Min();
_averageGbFps = _gbfps.Average();
_maxGbFps = _gbfps.Max();
_minFps = _fps.Min();
_averageFps = _fps.Average();
_maxFps = _fps.Max();
_speedFactor = _averageGbFps / 60f;
_last = time.TotalGameTime;
_gbfps.Clear();
_fps.Clear();
}
string info = $"GameBoy FPS: {_averageGbFps:0.00} (Min: {_minGbFps:0.00}, Max: {_maxGbFps:0.00})\n" +
$"Clock FPS: {_averageFps:0.00} (Min: {_minFps:0.00}, Max: {_maxFps:0.00})\n" +
$"Speed Factor: {_speedFactor:0.00}\n" +
$"GBC Mode: {(GameBoy.Cpu.DoubleSpeed ? "Double speed" : "Normal speed")}\n" +
$"LY: {GameBoy.Gpu.LY}\n" +
$"LYC: {GameBoy.Gpu.LYC}\n";
_spriteBatch.DrawString(_font, info, new Vector2(1, 1), Color.Black);
_spriteBatch.DrawString(_font, info, new Vector2(0, 0), Color.Cyan);
}
public Axis InferYAxis(IList <Tuple <StandardUnit, double> > dataRanges)
{
double highest = dataRanges.Any() ? dataRanges.Max(x => x.Item2) : 0d;
double lowest = dataRanges.Any() ? dataRanges.Min(x => x.Item2) : 0d;
var yAxis = new LinearAxis
{
Position = AxisPosition.Left,
Minimum = lowest,
IntervalLength = 30,
Maximum = highest,
TicklineColor = OxyColor.FromArgb(0, 0, 0, 0),
MajorGridlineStyle = LineStyle.Solid,
MajorGridlineColor = OxyColor.FromRgb(230, 230, 230),
MinorGridlineStyle = LineStyle.Solid,
MinorGridlineColor = OxyColor.FromRgb(244, 244, 244)
};
if (!dataRanges.Any())
{
return(yAxis);
}
StandardUnit unit = dataRanges.First().Item1;
// Only apply formatting for specific unit
// if all data points are using the same
if (dataRanges.All(x => x.Item1 == unit))
{
yAxis.LabelFormatter = unit.GetLabelFormatter();
}
return(yAxis);
}
private IEnumerable <Tuple <ShipType, CellPosition, bool> > GenerateContinuesForDamagedShip(
IList <CellPosition> damagedShipCells, IGameFieldBuilder builder, bool vertical, ShipType ship)
{
if (builder.ShipsLeft[ship] == 0)
{
yield break;
}
var topLeftCell = damagedShipCells.Min();
var delta = vertical ? CellPosition.DeltaDown : CellPosition.DeltaRight;
var start = vertical
? new CellPosition(0, topLeftCell.Column)
: new CellPosition(topLeftCell.Row, 0);
for (; builder.Contains(start); start += delta)
{
if (!builder.CanBeAddedSafely(ship, start, vertical, x => OpponentFieldKnowledge[x] != false))
{
continue;
}
var newShipCells = Enumerable.Range(0, ship.GetLength()).Select(x => start + delta * x).ToList();
if (damagedShipCells.Any(x => !newShipCells.Contains(x)))
{
continue;
}
yield return(Tuple.Create(ship, start, vertical));
}
}
private LeagueResult FindWinningTeam(IList <LeagueResult> leagueResults)
{
var minDiffBetweenForAndAgainst = leagueResults.Min(league => Math.Abs(league.GoalsFor - league.GoalsAgainst));
var winningTeam = leagueResults.First(league => minDiffBetweenForAndAgainst == Math.Abs(league.GoalsFor - league.GoalsAgainst));
return(winningTeam);
}
private static StageSummary Summarize(IList <RequestSummary> requests)
{
var durations = requests.Select(x => x.DurationMs).OrderBy(_ => _).ToArray();
var statusCodes = requests
.GroupBy(x => x.RoundStatusCode())
.ToDictionary(x => x.Key, x => x.ToList().Count);
return(new StageSummary
{
Stage = requests.First().Stage,
Url = requests.First().Url,
Http2xx = statusCodes.TryGetValue(200, out var count2xx) ? count2xx : 0,
Http3xx = statusCodes.TryGetValue(300, out var count3xx) ? count3xx : 0,
Http4xx = statusCodes.TryGetValue(400, out var count4xx) ? count4xx : 0,
Http5xx = statusCodes.TryGetValue(500, out var count5xx) ? count5xx : 0,
Average = Math.Round(requests.Average(x => x.DurationMs), 2),
Minimum = requests.Min(x => x.DurationMs),
Maximum = requests.Max(x => x.DurationMs),
StdDev = durations.CalculateStandardDeviation(),
Percentile50 = durations.CalculatePercentile(0.5),
Percentile66 = durations.CalculatePercentile(0.66),
Percentile75 = durations.CalculatePercentile(0.75),
Percentile80 = durations.CalculatePercentile(0.8),
Percentile90 = durations.CalculatePercentile(0.9),
Percentile95 = durations.CalculatePercentile(0.95),
Percentile98 = durations.CalculatePercentile(0.98),
Percentile99 = durations.CalculatePercentile(0.99)
});
/// <summary>
/// Adds the value for selected characters.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="item">The item.</param>
/// <param name="labels">The labels.</param>
/// <param name="values">The values.</param>
private void AddValueForSelectedCharacters <T>(ListViewItem item, IList <string> labels, IList <T> values)
{
T min = values.Any() ? values.Min() : default(T);
T max = values.Any() ? values.Max() : default(T);
bool allEqual = !values.Any() || values.All(value => value.Equals(min));
// Add the value for every selected item
for (int index = 0; index < m_selectedCharacters.Count(); index++)
{
// Create the subitem and choose its forecolor
var subItem = new ListViewItem.ListViewSubItem(item, labels[index]);
if (!allEqual)
{
if (values[index].Equals(max))
{
subItem.ForeColor = Color.DarkGreen;
}
else if (values[index].Equals(min))
{
subItem.ForeColor = Color.DarkRed;
}
item.UseItemStyleForSubItems = false;
}
else if (m_selectedCharacters.Count() > 1)
{
subItem.ForeColor = Color.DarkGray;
item.UseItemStyleForSubItems = false;
}
item.SubItems.Add(subItem);
}
}
private TransitionResult SwitchState(IList <CashinState> expectedStates, CashinState nextState)
{
if (expectedStates.Contains(State))
{
State = nextState;
return(TransitionResult.Switched);
}
if (State < expectedStates.Max())
{
// Throws to retry and wait until aggregate will be in the required state
throw new InvalidAggregateStateException(State, expectedStates, nextState);
}
if (State > expectedStates.Min())
{
// Aggregate already in the next state, so this event can be just ignored
return(State == nextState
? TransitionResult.AlreadyInTargetState
: TransitionResult.AlreadyInFutureState);
}
throw new InvalidOperationException("This shouldn't be happened");
}
/// <summary>
/// Public API: Sorts ascending
/// </summary>
public static void BucketSortAscending(this IList <int> collection)
{
int maxValue = collection.Max();
int minValue = collection.Min();
List <int>[] bucket = new List <int> [maxValue - minValue + 1];
for (int i = 0; i < bucket.Length; i++)
{
bucket[i] = new List <int>();
}
foreach (int i in collection)
{
bucket[i - minValue].Add(i);
}
int k = 0;
foreach (List <int> i in bucket)
{
if (i.Count > 0)
{
foreach (int j in i)
{
collection[k] = j;
k++;
}
}
}
}
public int GetNextBusIdMultipliedByWaitTime()
{
int nextDepartureTimestamp = _buses.Min(b => b.NextDepartureTimestamp);
Bus nextBus = _buses.SingleOrDefault(b => b.NextDepartureTimestamp == nextDepartureTimestamp);
return(nextBus.Id * (nextDepartureTimestamp - _timestamp));
}
public static DateTime getEarliestDeliverByDate(IList <Delivery> deliveries)
{
var earliestDate = deliveries
.Min(r => r.DeliverBy);
return(earliestDate.Value);
}
private double[] GetWeightingFactor(IList <DeconvolutedPeak> peakSet)
{
var maxCharge = peakSet.Max(p => p.Charge);
var minCharge = peakSet.Min(p => p.Charge);
var weights = new double[peakSet.Count];
if (maxCharge == minCharge)
{
for (var i = 0; i < peakSet.Count; i++)
{
weights[i] = 1;
}
return(weights);
}
for (var i = 0; i < peakSet.Count; i++)
{
var iPeak = peakSet[i];
for (var j = 0; j < peakSet.Count; j++)
{
var jPeak = peakSet[j];
if (iPeak.Charge == jPeak.Charge)
{
continue;
}
var denominator = (double)iPeak.Charge / jPeak.Charge;
var numerator = Math.Abs(denominator - jPeak.MzWithoutAdductIonMass / iPeak.MzWithoutAdductIonMass);
weights[i] += Math.Pow(numerator / denominator, WeightingIndex);
}
weights[i] *= (maxCharge - minCharge);
}
return(weights);
}
// wypisanie parametrow na konsole
private static void SaveResults(Configuration config, Bitmap bitmap, IDictionary <int, IList <TimeSpan> > results, string implIdentifier)
{
string resultPath = $"{config.InputPath}_{implIdentifier}.txt";
//tworzenie wyniku
StringBuilder builder = new StringBuilder();
builder.AppendLine($"File: {config.InputPath}, size: {bitmap.Width}x{bitmap.Height} (width x height).");
builder.AppendLine($"Iterations: {config.IterationCount}, sigma: {config.Sigma}.");
builder.AppendLine();
builder.AppendLine("Threads;Min [ms];Max [ms];Average [ms]; StDev [ms]");
for (int i = 1; i <= config.MaxThreadsCount; i++)
{
IList <TimeSpan> timeSpans = results[i];
TimeSpan min = timeSpans.Min();
TimeSpan max = timeSpans.Max();
TimeSpan average = new TimeSpan((long)timeSpans.Average(t => t.Ticks));
TimeSpan standardDeviation = CalculateStandardDeviation(timeSpans);
builder.AppendLine($"{i};{min.TotalMilliseconds};{max.TotalMilliseconds};{average.TotalMilliseconds};{standardDeviation.TotalMilliseconds}");
}
File.WriteAllText(resultPath, builder.ToString());
}
public PointPairList getDensityCurve(IList <double> data, double bandwidth)
{
int intervals = 1000;
var result = new PointPairList {
Capacity = intervals
};
//generate a base line
var statistics = new DescriptiveStatistics(data);
double minValue = data.Min() - (2 * statistics.StandardDeviation);
double maxValue = data.Max() + (2 * statistics.StandardDeviation);
double interval = (maxValue - minValue) / intervals * 1.0;
for (int i = 0; i < intervals; i++)
{
result.Add(minValue + i * interval, 0);
}
if (bandwidth == 0)
{
bandwidth = 1.06 * statistics.StandardDeviation * Math.Pow(data.Count, -1.0 / 5);
}
var orderedData = data.OrderBy(o => o);
foreach (var value in orderedData)
{
Normal nD = new Normal(0, 1);
for (int q = 0; q < intervals; q++)
{
result[q].Y += (1 / (data.Count * bandwidth)) * nD.Density((value - result[q].X) / bandwidth);
}
}
return(result);
}
/// <summary>
/// Generates intervals based on type, numberOfClasses and values.
/// </summary>
/// <param name="values"></param>
/// <param name="type"></param>
/// <param name="numberOfClasses"></param>
/// <returns></returns>
public static IList <Interval> GetIntervalsForNumberOfClasses(IList <Single> values, QuantityThemeIntervalType type, int numberOfClasses)
{
int index = 0;
var intervals = new List <Interval>();
var lowValue = values.Min();
var highValue = values.Max();
if (type == QuantityThemeIntervalType.NaturalBreaks)
{
ArrayList.Adapter((IList)values).Sort(); // performance, works 20% faster than layerAttribute.AttributeValues.Sort();
}
for (int i = 0; i < numberOfClasses; i++)
{
float intervalMin;
float intervalMax;
if (type == QuantityThemeIntervalType.EqualIntervals)
{
intervalMin = lowValue + i * ((highValue - lowValue) / numberOfClasses);
intervalMax = lowValue + (i + 1) * ((highValue - lowValue) / numberOfClasses);
}
else
{
intervalMin = Convert.ToSingle(values[index]);
index = (int)Math.Ceiling((double)(i + 1) / numberOfClasses * (values.Count - 1));
intervalMax = Convert.ToSingle(values[index]);
}
var interval = new Interval(intervalMin, intervalMax);
intervals.Add(interval);
}
return(intervals);
}
public virtual IList <TKLineToday> GetStockClosePrices(IList <DateTime> queryDates, IList <string> stockFullCodes)
{
var result = new List <TKLineToday>();
if (queryDates == null || !queryDates.Any())
{
return(result);
}
string stockCodeConditionString = string.Empty;
string sql = @" SELECT [Id] , [StockCode] , [TradeDate] , [Close] FROM [dbo].[TKLineToday] WHERE [TradeDate] BETWEEN '{0}' AND '{1}' ";
if (stockFullCodes != null && stockFullCodes.Any())
{
sql += @" AND [StockCode] IN ({2}) ";
stockCodeConditionString = CommonHelper.ArrayListToSqlConditionString(stockFullCodes);
}
var commandText = stockFullCodes == null?string.Format(sql, queryDates.Min(), queryDates.Max()) : string.Format(sql, queryDates.Min(), queryDates.Max(), stockCodeConditionString);
var query = _dbContext.SqlQuery <TKLineToday>(commandText);
result.AddRange(query.ToList());
return(result);
}
/// <summary>
/// 获取最低水平线
/// </summary>
/// <returns></returns>
public IList <OutLine> getLowestOutline()
{
//最低水平线
float minY = outLineList.Min(m => m.Y);
return(new List <OutLine>(outLineList.Where(m => m.Y == minY)));
}
// Минимальное значение
public int MinValueIntegerToListInt(IList list)
{
IList <int> listInt = list.Cast <int>().
Select(r => Convert.ToInt32(r)).ToList();
return(listInt.Min());
}
private double choosePrice(IList <double> prices)
{
double median = this.getMedian(prices);
prices = prices.Where(price => median * 0.2 < price).ToList();
return(prices.Min());
}
private double CalculateOptimalBinWidth(IList <double> sequence)
{
double xMax = sequence.Max(), xMin = sequence.Min();
int minBins = 4, maxBins = 16;
double[] N = Enumerable.Range(minBins, maxBins - minBins)
.Select(v => (double)v).ToArray();
double[] D = N.Select(v => (xMax - xMin) / v).ToArray();
double[] C = new double[D.Length];
for (int i = 0; i < N.Length; i++)
{
double[] binIntervals = LinearSpace(xMin, xMax, (int)N[i] + 1);
int[] ki = Histogram(sequence, binIntervals);
ki = ki.Skip(1).Take(ki.Length - 2).ToArray();
double mean = ki.Average();
double variance = ki.Select(v => Math.Pow(v - mean, 2)).Sum() / N[i];
C[i] = (2 * mean - variance) / (Math.Pow(D[i], 2));
}
double minC = C.Min();
int index = C.Select((c, ix) => new { Value = c, Index = ix })
.Where(c => c.Value == minC).First().Index;
// optimal bin width
return(D[index]);
}
private static IList <Point> MakeHullNaive(IList <Point> points)
{
if (points.Count <= 1)
{
return(new List <Point>(points));
}
IList <Point> result = new List <Point>();
// Jarvis march / gift wrapping algorithm
Point point = points.Min();
do
{
result.Add(point);
Point next = points[0];
foreach (Point p in points)
{
double ax = next.x - point.x;
double ay = next.y - point.y;
double bx = p.x - point.x;
double by = p.y - point.y;
double cross = ax * by - ay * bx;
if (cross > 0 || cross == 0 && bx * bx + by * by > ax * ax + ay * ay)
{
next = p;
}
}
point = next;
} while (point.CompareTo(result[0]) != 0);
return(result);
}
/// <summary>
/// Generate the tag clound using a template provided by caller.
/// e.g. ( span id="weight${weight}" ${name} ${urlLink} ).
/// </summary>
/// <param name="tagData"></param>
/// <param name="template"></param>
/// <returns></returns>
public static string BuildTagCloud(IList <TagSummary> tagData, string template)
{
// Need to get min/max.
StringBuilder buffer = new StringBuilder();
if (tagData == null || tagData.Count == 0)
{
return(string.Empty);
}
double min = tagData.Min(t => t.Count);
double max = tagData.Max(t => t.Count);
foreach (var tag in tagData)
{
// Get ratio of 1 tag in relation to max
double ratio = ((double)tag.Count / max) * 100;
int size = 0;
if (ratio >= 98)
{
size = 1;
}
else if (ratio >= 80)
{
size = 2;
}
else if (ratio >= 60)
{
size = 3;
}
else if (ratio >= 40)
{
size = 4;
}
else if (ratio >= 20)
{
size = 5;
}
else if (ratio >= 5)
{
size = 6;
}
else
{
size = 0;
}
// Exclude very low weights.
if (size > 0)
{
string output = template.Replace("${size}", size.ToString());
string urltag = System.Web.HttpUtility.UrlEncode(tag.Name);
output = output.Replace("${urltagname}", urltag);
output = output.Replace("${tagname}", tag.Name);
buffer.Append(output);
}
}
return(buffer.ToString());
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
// build start/end year
IList <AnnualSalesData> rawData = GetAnnualSalesData();
int minYear = 1900;
int maxYear = LocaleHelper.LocalNow.Year;
if (rawData.Count > 0)
{
minYear = rawData.Min(x => x.SalesYear);
maxYear = rawData.Max(x => x.SalesYear);
}
// set up dropdown choices
for (int year = minYear; year <= maxYear; year++)
{
list_StartYear.Items.Add(new ListItem(year.ToString()));
list_EndYear.Items.Add(new ListItem(year.ToString()));
}
// default to most recent 3 years
int startYear = Math.Max(minYear, LocaleHelper.LocalNow.Year - 2);
list_StartYear.SelectedValue = startYear.ToString();
list_EndYear.SelectedValue = maxYear.ToString();
// bind report
ProcessButton_Click(null, null);
}
}
private void UpdateCandlesInfo(string assetPairId, IList <Candle> candles, List <MarketSlice> marketData)
{
var firstCandle = candles.First();
var lastCandle = candles.Last();
var marketSlice = new MarketSlice
{
AssetPairId = assetPairId,
VolumeBase = candles.Sum(c => c.TradingVolume).ToString(CultureInfo.InvariantCulture),
VolumeQuote = candles.Sum(c => c.TradingOppositeVolume).ToString(CultureInfo.InvariantCulture),
PriceChange = firstCandle.Open > 0
? ((lastCandle.Close - firstCandle.Open) / firstCandle.Open).ToString(CultureInfo.InvariantCulture)
: "0",
High = candles.Max(c => c.High).ToString(CultureInfo.InvariantCulture),
Low = candles.Min(c => c.Low).ToString(CultureInfo.InvariantCulture),
};
var existingRecord = marketData.FirstOrDefault(x => x.AssetPairId == assetPairId);
if (existingRecord != null)
{
existingRecord.VolumeBase = marketSlice.VolumeBase;
existingRecord.VolumeQuote = marketSlice.VolumeQuote;
existingRecord.PriceChange = marketSlice.PriceChange;
existingRecord.High = marketSlice.High;
existingRecord.Low = marketSlice.Low;
}
else
{
marketData.Add(marketSlice);
}
}
// The idea is to have a page dictionary in memory that holds SinceId and MaxId for every page
// and use them as page borders so we can tell the twitter API
// form which to which Id to load the tweets for the specific page
private void SetPageTweetBorders(int pageIndex, IList <TweetDto> tweetsResult)
{
var pages = new Dictionary <int, PageTweetBorders>();
string pagesKey = $"tweet-pages";
if (TempData.ContainsKey(pagesKey))
{
pages =
JsonConvert.DeserializeObject <Dictionary <int, PageTweetBorders> >(TempData[pagesKey].ToString());
}
if (!pages.ContainsKey(pageIndex))
{
pages.Add(pageIndex, new PageTweetBorders()
{
Page = pageIndex,
MaxId = tweetsResult?.Max(tweet => tweet.Id) ?? 0,
SinceId = tweetsResult?.Min(tweet => tweet.Id) ?? 0
});
}
string pagesJson = JsonConvert.SerializeObject(pages);
if (TempData.ContainsKey(pagesKey))
{
TempData[pagesKey] = pagesJson;
}
else
{
TempData.Add(pagesKey, pagesJson);
}
}
public CarCalculatorSummary(IList<FuelEntryModel> fuelEntries)
{
HasData = fuelEntries != null && fuelEntries.Any();
if (!HasData) return;
MinAmountOf100Km = fuelEntries.Min(i => i.AmountOfFuelPer100Km);
MaxAmountOf100Km = fuelEntries.Max(i => i.AmountOfFuelPer100Km);
MinCost1Km = fuelEntries.Min(i => i.CostOf1Km);
MaxCost1Km = fuelEntries.Max(i => i.CostOf1Km);
SumDistance = fuelEntries.Sum(i => i.CurrentDistance);
SumAmountOfFuel = fuelEntries.Sum(i => i.AmountOfFuel);
SumTotalCost = fuelEntries.Sum(i => i.GasPrice * i.AmountOfFuel);
var minDate = fuelEntries.Min(i => i.Date);
var maxDate = fuelEntries.Max(i => i.Date);
AverageFuel = (decimal)((maxDate - minDate).TotalDays/fuelEntries.Count);
}
private static void CalculatePickList(IList<Product> allProducts,
int columnSize, bool[,] pickList)
{
var valueList = new int[columnSize];
var minVolumeIdx = allProducts.Min(x => x.Dimension.Volume) - 1;
for (var idx = 0; idx < allProducts.Count; idx++)
{
var product = allProducts[idx];
var tempValueList = new int[columnSize];
for (var volIdx = minVolumeIdx; volIdx < columnSize; volIdx++)
{
var chosenVal = 0;
var keep = false;
var isWithin = product.Dimension.Volume <= volIdx;
var valueOfCellAbove = valueList[volIdx];
if (isWithin)
{
var remainingSpace = volIdx - product.Dimension.Volume;
var otherPossibleVal = valueList[remainingSpace];
var finalPossibleVal = product.Price + otherPossibleVal;
if (valueOfCellAbove <= finalPossibleVal)
{
chosenVal = finalPossibleVal;
keep = true;
}
else
{
chosenVal = valueOfCellAbove;
keep = false;
}
}
else
{
chosenVal = valueOfCellAbove;
keep = false;
}
pickList[idx, volIdx] = keep;
tempValueList[volIdx] = chosenVal;
}
for (var i = 0; i < columnSize; i++)
{
valueList[i] = tempValueList[i];
}
}
}
private void ExecuteIndexingInternal(IList<IndexToWorkOn> indexesToWorkOn, Action<IEnumerable<Tuple<IndexToWorkOn, IEnumerable<JsonDocument>>>> indexingOp)
{
var lastIndexedGuidForAllIndexes = indexesToWorkOn.Min(x => new ComparableByteArray(x.LastIndexedEtag.ToByteArray())).ToGuid();
JsonDocument[] jsonDocs = null;
try
{
transactionalStorage.Batch(actions =>
{
jsonDocs = actions.Documents.GetDocumentsAfter(lastIndexedGuidForAllIndexes)
.Where(x => x != null)
.Select(doc =>
{
DocumentRetriever.EnsureIdInMetadata(doc);
return doc;
})
.Take(context.Configuration.MaxNumberOfItemsToIndexInSingleBatch) // ensure that we won't go overboard with reading and blow up with OOM
.ToArray();
});
if (jsonDocs.Length > 0)
{
var result = FilterIndexes(indexesToWorkOn, jsonDocs).ToList();
indexesToWorkOn = result.Select(x => x.Item1).ToList();
indexingOp(result);
}
}
finally
{
if (jsonDocs != null && jsonDocs.Length > 0)
{
var last = jsonDocs.Last();
Debug.Assert(last.Etag != null);
Debug.Assert(last.LastModified != null);
var lastEtag = last.Etag.Value;
var lastModified = last.LastModified.Value;
var lastIndexedEtag = new ComparableByteArray(lastEtag.ToByteArray());
// whatever we succeeded in indexing or not, we have to update this
// because otherwise we keep trying to re-index failed documents
transactionalStorage.Batch(actions =>
{
foreach (var indexToWorkOn in indexesToWorkOn)
{
MarkIndexes(indexToWorkOn, lastIndexedEtag, actions, lastEtag, lastModified);
}
});
}
}
}
public static IList<Team> CalcSmallestDiff(IList<Team> teams)
{
// use LinQ to find the minimum difference
var smallest = teams.Min(team => team.Diff);
// Need to cater for multiple teams having the minimum diff
var smallestTeams = new List<Team>();
foreach (var team in teams)
{
if (team.Diff == smallest)
{
smallestTeams.Add(team);
team.SmallestDiff = true;
}
}
return smallestTeams;
}
public LineData(IList<double> x, IList<double> y)
{
m_x = x;
m_y = y;
Count = x.Count;
if (x.Count > 0)
{
MaxValueX = x.Max();
MinValueX = x.Min();
}
if (y.Count > 0)
{
MaxValueY = y.Max();
MinValueY = y.Min();
}
}
private int MinimalMoves(IList<Group> groups)
{
int result = Int32.MaxValue;
int minlength = groups.Min(gr => gr.Count);
int maxlength = groups.Max(gr => gr.Count);
for (int k = minlength; k <= maxlength; k++)
{
int moves = DistanceTo(groups, k);
if (moves < result)
result = moves;
}
return result;
}
protected override void ExecuteIndexingWork(IList<IndexToWorkOn> indexesToWorkOn)
{
indexesToWorkOn = context.Configuration.IndexingScheduler.FilterMapIndexes(indexesToWorkOn);
var lastIndexedGuidForAllIndexes = indexesToWorkOn.Min(x => new ComparableByteArray(x.LastIndexedEtag.ToByteArray())).ToGuid();
context.CancellationToken.ThrowIfCancellationRequested();
var operationCancelled = false;
TimeSpan indexingDuration = TimeSpan.Zero;
List<JsonDocument> jsonDocs = null;
var lastEtag = Guid.Empty;
try
{
jsonDocs = prefetchingBehavior.GetDocumentsBatchFrom(lastIndexedGuidForAllIndexes);
if (Log.IsDebugEnabled)
{
Log.Debug("Found a total of {0} documents that requires indexing since etag: {1}: ({2})",
jsonDocs.Count, lastIndexedGuidForAllIndexes, string.Join(", ", jsonDocs.Select(x => x.Key)));
}
context.ReportIndexingActualBatchSize(jsonDocs.Count);
context.CancellationToken.ThrowIfCancellationRequested();
if (jsonDocs.Count <= 0)
return;
var sw = Stopwatch.StartNew();
lastEtag = DoActualIndexing(indexesToWorkOn, jsonDocs);
indexingDuration = sw.Elapsed;
}
catch (OperationCanceledException)
{
operationCancelled = true;
}
finally
{
if (operationCancelled == false && jsonDocs != null && jsonDocs.Count > 0)
{
prefetchingBehavior.CleanupDocumentsToRemove(lastEtag);
UpdateAutoThrottler(jsonDocs, indexingDuration);
}
prefetchingBehavior.BatchProcessingComplete();
}
}
private ReportsViewModel BuildReportsModel(IList<UserReport> reports, int pageSize = int.MaxValue)
{
var model = new ReportsViewModel
{
Reports = reports
};
if (reports.Any())
{
model.FirstDate = (DateTime?)reports.Max(r => r.CreationDate);
model.LastDate = (DateTime?)reports.Min(r => r.CreationDate);
}
foreach (var report in reports)
{
InitUserReport(report);
}
return model;
}
//public static void CleanTitles(this Chart chart)
//{
// foreach (var series in chart.Data.Series)
// {
// series.Name = RemovePrefixes(series.Name);
// foreach (var value in series.Values)
// {
// value.Label = RemovePrefixes(value.Label);
// }
// }
//}
public static IList<int> ParseYears(string yearsConfig, IList<int> yearsFromDb)
{
var result = new List<int>();
var max = yearsFromDb.Max();
var min = yearsFromDb.Min();
var periods = yearsConfig.Split(new[] {','}, StringSplitOptions.RemoveEmptyEntries);
foreach (var period in periods)
{
int val;
// if value
if (Int32.TryParse(period, out val) && yearsFromDb.Contains(val))
{
result.Add(val);
}
else
{
// if actual period
if (period.Contains("-"))
{
var bounds = period.Split(new[] {'-'}, StringSplitOptions.RemoveEmptyEntries);
if (bounds.Length != 2)
{
throw new ApplicationException("Incorrect period " + period);
}
var start = ParseYearConstant(bounds[0], min, max, yearsFromDb);
var end = ParseYearConstant(bounds[1], min, max, yearsFromDb);
for (var i = start; i <= end; i++)
{
result.Add(i);
}
}
// if year constant
else
{
result.Add(ParseYearConstant(period, min, max, yearsFromDb));
}
}
}
return result;
}
private void ReadWellPoints()
{
_points = DataReader.ReadWells(@"Draw\B2-HO.txt");
_xMin = _points.Min(p => p.X);
_xMax = _points.Max(p => p.X);
_yMin = _points.Min(p => p.Y);
_yMax = _points.Max(p => p.Y);
foreach (var point in _points)
{
var ellipse = new Ellipse();
ellipse.Width = 10;
ellipse.Height = 10;
ellipse.Stroke = new SolidColorBrush(Colors.Black);
drawCanvas.Children.Add(ellipse);
_drawObjects.Add(point, new DrawObject()
{
Shape = ellipse
});
}
}
public int CalculateWar(IList<double> first, IList<double> second)
{
if (first.Count == 0)
return 0;
double play1 = first.Max();
double play2;
bool win = false;
var greater = second.Where(n => n > play1).ToList();
if (greater.Count > 0)
play2 = greater.Min();
else
{
play2 = second.Min();
win = true;
}
var newfirst = first.Where(n => n != play1).ToList();
var newsecond = second.Where(n => n != play2).ToList();
return CalculateWar(newfirst, newsecond) + (win ? 1 : 0);
}
private BinaryGeneration CreateNextGeneration(BinaryGeneration generation, IList<BinaryEntity> children)
{
if (children.Any())
{
var bestChild = children.First(x => Math.Abs(x.Value - children.Min(c => c.Value)) < 0.01);
bestChild.Function = EntityFunction.BestChild;
var nextGeneration = new List<Entity<BinaryGenom>>(generation.Winners());
nextGeneration.Add(bestChild);
return new BinaryGeneration(nextGeneration
.OfType<BinaryEntity>()
.Select(x => new BinaryEntity(x))
.OfType<Entity<BinaryGenom>>()
.ToList())
.MarkUpGenereation();
}
return generation;
}
private bool StraightInHand(IList<Card> cards)
{
// theres probably a better way to do this whole thing with linq... but I can't figure it out.
int maxSequenceLength = 1;
CardFigure minCard = cards.Min<Card, CardFigure>(key => key.Figure);
CardFigure maxCard = cards.Max<Card, CardFigure>(key => key.Figure);
CardFigure lastCard = minCard;
int totalCardFigures = 0;
// go through the cards except the lowest card - we've already handled it in variable assignment
foreach (Card card in cards.OrderBy<Card, CardFigure>(key => key.Figure).Skip<Card>(1))
{
// if this card is one higher than the last one was
maxSequenceLength += ((lastCard + 1) == card.Figure) ? 1 : 0;
lastCard = card.Figure;
// theres got to be a better way then summing all cards A,2,3,4,5 == 22
totalCardFigures += (int)card.Figure;
}
// Either you have to have 5 cards in a row
// or it is also valid to have 4 cards in a row, if your min card is a two and your max card is an ace
// this handles the problematic ace wraparound where an ace can be at either end of a straight
return (maxSequenceLength >= 5) ||
((maxSequenceLength == 4) && (maxCard == CardFigure.Ace) && (totalCardFigures == 22)); // A,2,3,4,5 == 22
}
private void ListTable(IList<ProductionPlanDet> productionPlanDetList)
{
if (productionPlanDetList == null || productionPlanDetList.Count == 0)
{
this.list.InnerHtml = "没有查到符合条件的记录";
return;
}
var minStartTime = productionPlanDetList.Min(s => s.StartTime).AddDays(13);
productionPlanDetList = productionPlanDetList.Where(s => s.StartTime <= minStartTime).ToList();
#region trace
List<ProductionPlanDetTrace> traceList = new List<ProductionPlanDetTrace>();
int len = 0;
int j = productionPlanDetList.Count % 2000 == 0 ? productionPlanDetList.Count / 2000 : productionPlanDetList.Count / 2000 + 1;
while (true)
{
var cList = this.TheGenericMgr.FindAllWithCustomQuery<ProductionPlanDetTrace>(string.Format(" select l from ProductionPlanDetTrace as l where l.Type='{0}' and l.UUID in ('{1}') ", this.rbType.SelectedValue, string.Join("','", productionPlanDetList.Skip(len * 2000).Take((len + 1) * 2000).Select(d => d.UUID).Distinct().ToArray())));
if (cList != null && cList.Count > 0) { traceList.AddRange(cList); }
len++;
if (len == j) break;
}
traceList = traceList == null ? new List<ProductionPlanDetTrace>() : traceList;
if (traceList != null && traceList.Count > 0)
{
foreach (var sd in productionPlanDetList)
{
var currentLogs = traceList.Where(d => d.UUID == sd.UUID).OrderBy(d => d.ReqDate).ToList();
var showText = string.Empty;
if (currentLogs != null && currentLogs.Count > 0)
{
showText = "<table><thead><tr><th>发运路线</th><th>物料</th><th>Bom</th><th>需求日期</th><th>需求数</th></tr></thead><tbody><tr>";
foreach (var c in currentLogs)
{
showText += "<td>" + c.Flow + "</td><td>" + c.Item + "</td><td>" + c.Bom + "</td><td>" + c.ReqDate.ToShortDateString() + "</td><td>" + c.ReqQty.ToString("0.##") + "</td></tr><tr>";
}
showText += " </tr></tbody></table> ";
}
sd.Logs = showText;
}
}
#endregion
#region orderQty
List<ProductionPlanOpenOrder> productionPlanOpenOrderList = new List<ProductionPlanOpenOrder>();
len = 0;
while (true)
{
var cList = this.TheGenericMgr.FindAllWithCustomQuery<ProductionPlanOpenOrder>(string.Format(" select l from ProductionPlanOpenOrder as l where l.Type='{0}' and l.UUID in ('{1}') ", this.rbType.SelectedValue, string.Join("','", productionPlanDetList.Skip(len * 2000).Take((len + 1) * 2000).Select(d => d.UUID).Distinct().ToArray())));
if (cList != null && cList.Count > 0) { productionPlanOpenOrderList.AddRange(cList); }
len++;
if (len == j) break;
}
// productionPlanOpenOrderList = this.TheGenericMgr.FindAllWithCustomQuery<ProductionPlanOpenOrder>(string.Format(" select l from ProductionPlanOpenOrder as l where l.Type='{0}' and l.UUID in ('{1}') ", this.rbType.SelectedValue, string.Join("','", productionPlanDetList.Select(d => d.UUID).Distinct().ToArray())));
productionPlanOpenOrderList = productionPlanOpenOrderList == null ? new List<ProductionPlanOpenOrder>() : productionPlanOpenOrderList;
if (productionPlanOpenOrderList != null && productionPlanOpenOrderList.Count > 0)
{
foreach (var sd in productionPlanDetList)
{
var currentOrders = productionPlanOpenOrderList.Where(d => d.UUID == sd.UUID).OrderBy(d=>d.WindowTime).ToList();
var showText = string.Empty;
if (currentOrders != null && currentOrders.Count > 0)
{
showText = "<table><thead><tr><th>路线</th><th>订单号</th><th>物料</th><th>订单数</th><th>收货数</th><th>开始时间</th><th>窗口时间</th></tr></thead><tbody><tr>";
foreach (var c in currentOrders)
{
showText += "<td>" + c.Flow + "</td><td>" + c.OrderNo + "</td><td>" + c.Item + "</td><td>" + c.OrderQty.ToString("0.##") + "</td><td>" + c.RecQty.ToString("0.##") + "</td><td>" + c.StartTime.ToShortDateString() + "</td><td>" + c.WindowTime.ToShortDateString() + "</td></tr><tr>";
}
showText += " </tr></tbody></table> ";
}
sd.OrderDets = showText;
}
}
#endregion
var planByDateIndexs = productionPlanDetList.GroupBy(p => p.StartTime).OrderBy(p => p.Key);
var planByItems = productionPlanDetList.GroupBy(p => p.Item);
StringBuilder str = new StringBuilder();
//str.Append(CopyString());
//head
string headStr = string.Empty;
str.Append("<thead><tr class='GVHeader'><th rowspan='2'>序号</th><th rowspan='2'>物料号</th><th rowspan='2'>物料描述</th><th rowspan='2'>客户零件号</th><th rowspan='2'>包装量</th><th rowspan='2'>经济批量</th><th rowspan='2'>安全库存</th><th rowspan='2'>最大库存</th><th rowspan='2'>期初库存</th><th rowspan='2'>报验</th><th rowspan='2'>库存倒数</th>");
int ii = 0;
foreach (var planByDateIndex in planByDateIndexs)
{
ii++;
str.Append("<th colspan='4'>");
//if (productionPlanDetList.First().Status == BusinessConstants.CODE_MASTER_STATUS_VALUE_SUBMIT && planByDateIndex.Key.Date == System.DateTime.Now.Date)
//{
// str.Append("<input type='checkbox' id='CheckAll' name='CheckAll' onclick='doCheckAllClick()' />");
//}
str.Append(planByDateIndex.Key.ToString("yyyy-MM-dd"));
str.Append("</th>");
}
str.Append("</tr><tr class='GVHeader'>");
foreach (var planByDateIndex in planByDateIndexs)
{
str.Append("<th >需求</th><th >订单数</th><th >计划数</th><th >期末</th>");
}
str.Append("</tr></thead>");
str.Append("<tbody>");
#region 通过长度控制table的宽度
string widths = "100%";
if (ii > 14)
{
widths = "260%";
}
else if (ii > 10)
{
widths = "210%";
}
else if (ii > 6)
{
widths = "160%";
}
else if (ii > 4)
{
widths = "120%";
}
headStr += string.Format("<table id='tt' runat='server' border='1' class='GV' style='width:{0};border-collapse:collapse;'>", widths);
#endregion
int l = 0;
int seq = 0;
foreach (var planByItem in planByItems)
{
var firstPlan = planByItem.First();
var planDic = planByItem.GroupBy(d => d.StartTime).ToDictionary(d => d.Key, d => d.Sum(q => q.Qty));
l++;
if (l % 2 == 0)
{
str.Append("<tr class='GVAlternatingRow'>");
}
else
{
str.Append("<tr class='GVRow'>");
}
str.Append("<td>");
str.Append(l);
str.Append("</td>");
str.Append("<td>");
str.Append(planByItem.Key);
str.Append("</td>");
str.Append("<td>");
str.Append(firstPlan.ItemDesc);
str.Append("</td>");
str.Append("<td>");
str.Append(firstPlan.RefItemCode);
str.Append("</td>");
str.Append("<td>");
str.Append(firstPlan.UnitCount.ToString("0.##"));
str.Append("</td>");
str.Append("<td>");
str.Append(firstPlan.MinLotSize.ToString("0.##"));
str.Append("</td>");
str.Append("<td>");
str.Append(firstPlan.SafeStock.ToString("0.##"));
str.Append("</td>");
str.Append("<td>");
str.Append(firstPlan.MaxStock.ToString("0.##"));
str.Append("</td>");
var InitStockQty = firstPlan.InitStock + firstPlan.InspectQty;
if (InitStockQty < firstPlan.SafeStock)
{
str.Append("<td style='background:red;color:white'>");
}
else if (InitStockQty >= firstPlan.SafeStock && InitStockQty <= firstPlan.MaxStock)
{
str.Append("<td style='background:green;color:white'>");
}
else if (InitStockQty > firstPlan.MaxStock)
{
str.Append("<td style='background:orange'>");
}
str.Append((firstPlan.InitStock).ToString("0.##"));
str.Append("</td>");
//str.Append("<td>");
//str.Append((firstPlan.InTransitQty).ToString("0.##"));
//str.Append("</td>");
if (InitStockQty < firstPlan.SafeStock)
{
str.Append("<td style='background:red;color:white'>");
}
else if (InitStockQty >= firstPlan.SafeStock && InitStockQty <= firstPlan.MaxStock)
{
str.Append("<td style='background:green;color:white'>");
}
else if (InitStockQty > firstPlan.MaxStock)
{
str.Append("<td style='background:orange'>");
}
str.Append((firstPlan.InspectQty).ToString("0.##"));
str.Append("</td>");
str.Append("<td>");
str.Append(firstPlan.InventoryCountDown.HasValue?firstPlan.InventoryCountDown.Value.ToString("0.##"):"");
str.Append("</td>");
foreach (var planByDateIndex in planByDateIndexs)
{
var curenPlan = planByItem.Where(p => p.StartTime == planByDateIndex.Key);
var pdPlan = curenPlan.Count() > 0 ? curenPlan.First() : new ProductionPlanDet();
str.Append(string.Format("<td tital='{0}' onclick='doTdClick(this)'>", pdPlan.Logs));
str.Append(pdPlan.ReqQty.ToString("0.##"));
str.Append("</td>");
str.Append(string.Format("<td tital='{0}' onclick='doShowDetsClick(this)'>", pdPlan.OrderDets));
str.Append(pdPlan.OrderQty.ToString("0.##"));
str.Append("</td>");
//str.Append("<td>");
//str.Append(pdPlan.Qty.ToString("0.##"));
//str.Append("</td>");
if (firstPlan.Status == BusinessConstants.CODE_MASTER_STATUS_VALUE_CREATE)
{
seq++;
str.Append("<td width='30px'>");
str.Append("<input type='text' item='" + firstPlan.Item + "' name='UpQty' id='" + pdPlan.Id + "'value='" + pdPlan.Qty.ToString("0.##") + "' releaseNo='" + firstPlan.ReleaseNo + "' dateFrom='" + planByDateIndex.Key + "' style='width:70px' onblur='doFocusClick(this)' seq='" + seq + "' />");
str.Append("</td>");
}
else
{
str.Append("<td>");
//if (planByDateIndex.Key.Date == System.DateTime.Now.Date)
//{
// str.Append("<input type='checkbox' id='CheckBoxGroup' name='CheckBoxGroup' value='" + pdPlan.Id + "' runat='' onclick='doCheckClick()' />");
//}
str.Append(pdPlan.Qty.ToString("0.##"));
str.Append("</td>");
}
InitStockQty = InitStockQty + pdPlan.Qty-pdPlan.ReqQty+pdPlan.OrderQty;
if (InitStockQty < firstPlan.SafeStock)
{
str.Append("<td style='background:red;color:white'>");
}
else if (InitStockQty >= firstPlan.SafeStock && InitStockQty <= firstPlan.MaxStock)
{
str.Append("<td style='background:green;color:white'>");
}
else if (InitStockQty > firstPlan.MaxStock)
{
str.Append("<td style='background:orange'>");
}
str.Append(InitStockQty.ToString("0.##"));
str.Append("</td>");
}
str.Append("</tr>");
}
str.Append("</tbody></table>");
this.list.InnerHtml = headStr + str.ToString();
}
