public static bool AllInOneTrend(this IEnumerable<Quote> list)
{
return
list.Skip(list.Count() > 1 ? 1 : 0).Select((q, i) => new { q, i }).All(x => x.q.Close > list.ElementAt(x.i).Close)
||
list.Skip(list.Count() > 1 ? 1 : 0).Select((q, i) => new { q, i }).All(x => x.q.Close < list.ElementAt(x.i).Close);
}
public static string CapitalizeWord(this string word)
{
char[] tempArray = word.ToCharArray();
// capitalize first char if not a number
// if number then probably a numbered book
int bookNumber;
if (int.TryParse(Convert.ToString(tempArray[0]), out bookNumber)) // first char is number
{
// assume spot 2 is what needs capitalized.
tempArray[2] = char.ToUpper(tempArray[2]);
for (int i = 3; i < word.Count(); i++)
{
tempArray[i] = char.ToLower(tempArray[i]);
}
}
else // first char is not number so capitalize it
{
tempArray[0] = char.ToUpper(tempArray[0]);
for (int i = 1; i < word.Count(); i++)
{
tempArray[i] = char.ToLower(tempArray[i]);
}
}
string tempString = "";
foreach (char i in tempArray)
{
tempString += i;
}
return tempString;
}
public static ViewPaymentInstallmentItems[] CreateInstallment(this IEnumerable<Installment> input)
{
string numberFormat = ConfigurationManager.Format.NUMBER_FORMAT;
var InstallmentItems = new ViewPaymentInstallmentItems[0];
if (input.Count() > 0)
{
InstallmentItems = new ViewPaymentInstallmentItems[input.Count()];
var installment = input.ToArray();
for (int i = 0; i < installment.Count(); i++)
{
InstallmentItems[i] = new ViewPaymentInstallmentItems
{
No = (i + 1).ToString(numberFormat),
InstallmentId = installment[i].Id.ToString("0000000000"),
InstalledDate = installment[i].InstallmentDate.ToString(ConfigurationManager.Format.Date_Format),
InstalledBy = installment[i].InstallmentBy,
Method = installment[i].Method,
Amount = installment[i].Amount.ToString(ConfigurationManager.Format.Decimal_Format),
};
}
}
return InstallmentItems;
}
public static bool IsEquivalentTo(this IEnumerable<int> first, IEnumerable<int> second)
{
if (first == null && second == null)
{
return true;
}
if (first == null || second == null)
{
return false;
}
if (first.Count() != second.Count())
{
return false;
}
for (var i = 0; i < first.Count(); i++)
{
if (first.ElementAt(i) != second.ElementAt(i))
{
return false;
}
}
return true;
}
/// <summary>
/// Add conjunctions, such as commas "," and "ands" to
/// concatenate the given phrases into a sentence.
/// </summary>
/// <param name="effectSpans">
/// The lists of lists of <see cref="EffectSpan"/> to
/// add conjunctions to. This cannot be null and no element
/// within hte list can be null.
/// </param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="effectSpans"/> cannot be null and no
/// element within it can be null.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="effectSpans"/> cannot be empty.
/// </exception>
public static IEnumerable<EffectSpan> AddConjunctions(this IList<List<EffectSpan>> effectSpans)
{
if (effectSpans == null)
{
throw new ArgumentNullException("effectSpans");
}
if (!effectSpans.Any())
{
throw new ArgumentException("Cannot be empty", "effectSpans");
}
if (effectSpans.Any(x => x == null))
{
throw new ArgumentNullException("effectSpans");
}
List<EffectSpan> result;
result = new List<EffectSpan>();
for (int i = 0; i < effectSpans.Count(); i++)
{
result.AddRange(effectSpans[i]);
if (i < effectSpans.Count() - 2)
{
result.Add(new EffectSpan(", "));
}
else if (i == effectSpans.Count() - 2)
{
result.Add(new EffectSpan(" and "));
}
}
return result;
}
/// <summary>
/// Returns IEnumerable of SMA(x). First (period-1) values returns null value
/// </summary>
public static IEnumerable<decimal?> SimpleMovingAverage(this IEnumerable<decimal> values, int period)
{
Contract.Requires(values != null);
Contract.Requires(period >0 && period <= values.Count());
var result = Enumerable.Range(1 - period, values.Count()).Select(c => values.Skip(c).Take(period).Sum()/period);
return Enumerable.Range(0, period - 1).Select(i => null as decimal?).Concat(result.Skip(period - 1).Cast<decimal?>());
}
public static bool TypeSequenceIsAssignableFrom(this IEnumerable<Type> source, IEnumerable<object> sequence)
{
var canCast = true;
if (source.Count() == sequence.Count())
{
if (source.Count() > 0)
{
var srcEnum = source.GetEnumerator();
var seqEnum = sequence.GetEnumerator();
do
{
if (seqEnum.Current == null)
{
continue;
}
canCast = srcEnum.Current.IsAssignableFrom(seqEnum.Current.GetType());
}
while (srcEnum.MoveNext() && seqEnum.MoveNext() && canCast);
}
}
else
{
canCast = false;
}
return canCast;
}
public static double Mean(this IEnumerable<double> source)
{
if (source.Count() < 1)
return 0.0;
double length = source.Count();
double sum = source.Sum();
return sum / length;
}
public static void BranchShort(this List<object> codeList, Code op, int label)
{
Debug.Assert((codeList.Count() - label) < SByte.MaxValue);
// +2, op code + address code, as backward jump start from first byte of the end of branch command with address
var address = (byte) -(codeList.Count() - label + 2);
codeList.Add(op);
codeList.Add(address);
}
public static bool ListEquals(this IEnumerable<Type> source, IEnumerable<Type> compare)
{
if (source.Count() != compare.Count())
return false;
for (var i = 0; i < source.Count(); i++)
if (source.ElementAt(i) != (compare.ElementAt(i)))
return false;
return true;
}
public static SbVec3f[] ToArrayOfVec3F(this List<Color> colors)
{
var vec = new SbVec3f[colors.Count()];
for (int i = 0; i < colors.Count(); i++)
{
vec[i] = colors[i].ConvertToVec3F();
}
return vec;
}
public static IServiceCollection AddContextAccessor(this IServiceCollection self)
{
if (self.Count(x => x.ServiceType == typeof(IHttpContextAccessor)) == 0)
self.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
if (self.Count(x => x.ServiceType == typeof(IActionContextAccessor)) == 0)
self.AddSingleton<IActionContextAccessor, ActionContextAccessor>();
return self;
}
public static string ToStringSeparatedWithAnd(this List<string> input)
{
if (input.Any())
{
if (input.Count() == 1)
return input.First();
var first = input.Count() == 2 ? input.First() : string.Join(", ", input.Take(input.Count() - 1));
return string.Format("{0} and {1}", first, input.Last());
}
return string.Empty;
}
/// <summary>
/// <paramref name="left"/>와 <paramref name="right"/> 시퀀스의 요소들이 모두 같은 지를 판단합니다.
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
public static bool AllItemsAreEqual(this IEnumerable<ITimePeriod> left, IEnumerable<ITimePeriod> right) {
if(left.Count() != right.Count())
return false;
var itemCount = left.Count();
for(var i = 0; i < itemCount; i++) {
if(Equals(left.ElementAt(i), right.ElementAt(i)) == false)
return false;
}
return true;
}
public static double StandardDeviation(this IEnumerable<double> values)
{
double ret = 0;
if (values.Count() > 0)
{
//Compute the Average
double avg = values.Average();
//Perform the Sum of (value-avg)_2_2
double sum = values.Sum(d => Math.Pow(d - avg, 2));
//Put it all together
ret = Math.Sqrt((sum) / (values.Count() - 1));
}
return ret;
}
/// <summary>
/// Calculates the sample standard deviation.
/// </summary>
public static double Stdev(this IEnumerable<int> data)
{
if (data.Count() < 2)
return 0;
double avg = data.Average();
double numerator = 0;
foreach (double d in data)
numerator += (d - avg) * (d - avg);
double variance = numerator / (double)(data.Count() - 1);
return Math.Sqrt((double)variance);
}
public static double Median(this IEnumerable<int> input)
{
if (input == null) throw new ArgumentNullException("input");
int midIndex = input.Count() / 2;
var sorted = input.OrderBy(x => x).ToList();
double median =
input.Count() % 2 == 0
? (sorted[midIndex] + sorted[midIndex - 1]) / 2
: sorted[midIndex];
return median;
}
public static string ToReadableOrList(this string[] strings)
{
if (!strings.Any()) return "";
string firstPart;
if (strings.Count() > 2)
{
firstPart = string.Join(", ", strings.Take(strings.Count() - 1));
}
else
{
firstPart = strings[0];
}
return firstPart + " or " + strings.Last();
}
internal static Affiliation ByUserNameAndEstablishmentId(this IQueryable<Affiliation> queryable,
string userName, int establishmentId)
{
if (queryable.Count(x => x.EstablishmentId == establishmentId && x.Person.User != null
&& x.Person.User.Name.Equals(userName, StringComparison.OrdinalIgnoreCase)) > 1)
{
return queryable.Count(x => x.EstablishmentId == establishmentId && x.Person.User != null
&& x.Person.User.Name.Equals(userName, StringComparison.OrdinalIgnoreCase) && x.IsDefault) == 1
? queryable.Single(x => x.EstablishmentId == establishmentId && x.Person.User != null
&& x.Person.User.Name.Equals(userName, StringComparison.OrdinalIgnoreCase) && x.IsDefault)
: queryable.FirstOrDefault(a => a.EstablishmentId == establishmentId && a.Person.User != null
&& a.Person.User.Name.Equals(userName, StringComparison.OrdinalIgnoreCase));
}
return queryable.SingleOrDefault(a => a.EstablishmentId == establishmentId && a.Person.User != null && a.Person.User.Name.Equals(userName, StringComparison.OrdinalIgnoreCase));
}
public static string ToLotNumber(this string lotId)
{
if (lotId.Count(c => c == '/') != 2)
throw new ArgumentException($"lotId {lotId} should be in format 'lots/2015/5'");
return lotId.Substring(lotId.IndexOf("/", StringComparison.Ordinal) + 1);
}
public static int CountLineBreaks(this string input)
{
if (input == null)
throw new ArgumentNullException("input");
return input.Count(n => n == '\n');
}
public static SqlExpr AND(this IEnumerable<SqlExpr> expl)
{
if(expl.Count() >1)
return SqlExpr.OPR(expl.First(), "AND", expl.Skip(1).ToArray());
else
return expl.First();
}
public static IEnumerable<Quotation> CleanFromInflation(this IEnumerable<Quotation> Quotations)
{
Contract.Requires(Quotations.Count() >= 1);
var firstCpi = Quotations.First().GetCpi();
Quotations.ForEach(d => SubInflation(d, d.GetCpi() / firstCpi - 1));
return Quotations;
}
public static void LogTo(this IEnumerable<Route> routes, TextWriter writer)
{
LogWriter.LogNumberOfRoutes(routes.Count(), writer);
foreach (var route in routes)
route.LogTo(writer);
}
public static string AsString(this IEnumerable<BookAuthorsDto> authors)
{
var list = String.Empty;
for (int i = 0; i < authors.Count(); i++)
{
list += authors.ElementAt(i).FullName;
if (i < authors.Count() - 1)
{
list += " and ";
}
}
return list;
}
public static void BackForEach(this IEnumerable<TransactionStep> steps, Action<TransactionStep> proc)
{
for (int i = steps.Count() - 1; i >= 0; i--)
{
proc(steps.ElementAt(i));
}
}
/// <summary>
/// チャート描画のパフォーマンスを改善するため、データの間引きを行います。
/// </summary>
/// <param name="log">資材の時系列データ</param>
/// <param name="period">描画対象期間</param>
/// <returns></returns>
public static IEnumerable<TimeMaterialsPair> ThinOut(this IEnumerable<TimeMaterialsPair> log, DisplayedPeriod period)
{
if (log.Count() == 0)
yield break;
TimeSpan minimumTimeStep = GetMinimumTimeStep(period);
double minimumMaterialRatio = GetMinimumMaterialRatio(period);
// 最初のデータは必ず返す
yield return log.First();
TimeMaterialsPair lastData = log.First();
foreach (var data in log.Skip(1))
{
// 前のデータから時刻あるいは資材量が十分離れているデータであれば値を返す
if (HasSeriouslyChanged(lastData, data, minimumTimeStep, minimumMaterialRatio))
{
yield return data;
lastData = data;
}
}
// 直近のデータは必ず返す
if (!lastData.Equals(log.Last()))
{
yield return log.Last();
}
}
public static string ArrayToCsv(this IEnumerable<string> csvData)
{
if (csvData == null || csvData.Count() == 0)
return string.Empty;
return string.Join(",", csvData);
}
public static bool Exists(this IEnumerable<ComplexType> types, string name, string conceptualNamespace = "")
{
if (types == null || String.IsNullOrEmpty(name)) return false;
name = String.IsNullOrEmpty(conceptualNamespace) ? name : name.Replace(String.Concat(conceptualNamespace, "."), "");
return types.Count(c => c.Name.Equals(name, StringComparison.OrdinalIgnoreCase)) > 0;
}
public static bool Exists(this IEnumerable<LinqToEdmx.Model.Storage.Function> functions, string name, string storageNamespace = "")
{
if (functions == null || String.IsNullOrEmpty(name)) return false;
name = String.IsNullOrEmpty(storageNamespace) ? name : name.Replace(String.Concat(storageNamespace, "."), "");
return functions.Count(f => f.Name.Equals(name, StringComparison.OrdinalIgnoreCase)) > 0;
}