static IEnumerable <HashAnalysisResult> BenchmarkSymmetricalCases()
{
var manuals = (
from a in MoreEnumerable.Generate(-5100, a => a + 5).TakeWhile(a => a < 5100)
from b0 in MoreEnumerable.Generate(int.MaxValue, c => (int)(c * 0.95)).TakeWhile(c => c > 0)
from sign in new[] { -1, 1 }
let b = sign * b0
from swap in new[] { true, false }
select new IntPairManual {
A = swap ? a : b,
B = swap ? b : a,
}
).Distinct().ToArray();
var valueObjects = manuals.Select(m => m.ToValueObject()).ToArray();
var tuples = manuals.Select(m => m.ToTuple()).ToArray();
var structs = manuals.Select(m => m.ToStruct()).ToArray();
var anonymous = manuals.Select(m =>
new {
m.A,
m.B,
}).ToArray();
yield return(ProcessList(manuals));
yield return(ProcessList(valueObjects));
yield return(ProcessList(tuples));
yield return(ProcessList(structs));
yield return(ProcessList(anonymous));
}
public void UnfoldIsLazy()
{
MoreEnumerable.Unfold(0, BreakingFunc.Of <int, (int, int)>(),
BreakingFunc.Of <(int, int), bool>(),
BreakingFunc.Of <(int, int), int>(),
BreakingFunc.Of <(int, int), int>());
}
public ProjectMapPopupViewData(Models.Project project, bool showDetailedInformation)
{
//Project = project;
DisplayNameAsUrlBlankTarget = project.DisplayNameAsUrlBlankTarget;
KeyPhoto = project.KeyPhoto;
Duration = project.Duration;
ProjectStage = project.ProjectStage;
ProjectType = project.ProjectType;
EstimatedTotalCost = project.EstimatedTotalCost.HasValue ? project.EstimatedTotalCost.ToStringCurrency() : "Unknown";
var leadImplementerOrg =
project.ProjectOrganizations.FirstOrDefault(po => po.RelationshipTypeID == 33);
LeadImplementerOrganizationName =
leadImplementerOrg != null?leadImplementerOrg.Organization.GetDisplayNameAsUrlBlankTarget() : new HtmlString(string.Empty);
var dict = new Dictionary <Models.ClassificationSystem, string>();
MoreEnumerable.ForEach(project.ProjectClassifications.Select(x => x.Classification.ClassificationSystem).Distinct(), x => dict.Add(x, string.Join(", ", project.ProjectClassifications.Select(y => y.Classification).Where(y => y.ClassificationSystem == x).Select(y => y.DisplayName).ToList())));
ClassificationsBySystem = dict;
ProjectDisplayName = project.DisplayName;
ProjectDetailUrl = project.GetDetailUrl();
FactSheetUrl = project.GetFactSheetUrl();
DetailLinkDescriptor = project.IsProposal() ? $"This {Models.FieldDefinition.Project.GetFieldDefinitionLabel()} is a proposal. For description and expected results, see the" : $"For {Models.FieldDefinition.Project.GetFieldDefinitionLabel()} information & results, see the";
InitializeDisplayNames();
TaxonomyLevel = MultiTenantHelpers.GetTaxonomyLevel();
ShowDetailedInformation = showDetailedInformation;
}
public void WithComparerReturnsMinimum()
{
using var strings = SampleData.Strings.AsTestingSequence();
var minima = strings.MinBy(s => s.Length, Comparable <int> .DescendingOrderComparer);
Assert.That(MoreEnumerable.First(minima), Is.EqualTo("hello"));
}
static IEnumerable <HashAnalysisResult> BenchmarkNastyNestedCases()
{
var manuals = (
from a in MoreEnumerable.Generate(-10000, a => a + 6).TakeWhile(a => a < 14100)
from b0 in MoreEnumerable.Generate(int.MaxValue, c => (int)(c * 0.95)).TakeWhile(c => c > 0)
from sign in new[] { -1, 1 }
let b = sign * b0
select new NastyNestedManual {
Nested = new NastyNestedManual {
A = b,
B = a,
},
A = a,
B = b,
}
).ToArray();
var valueObjects = manuals.Select(m => m.ToValueObject()).ToArray();
var tuples = manuals.Select(m => m.ToTuple()).ToArray();
var cs7tuples = manuals.Select(m => m.ToCs7Tuple()).ToArray();
yield return(ProcessList(manuals));
yield return(ProcessList(valueObjects));
yield return(ProcessList(tuples));
yield return(ProcessList(cs7tuples));
}
public void ReturnsMinimum()
{
using var strings = SampleData.Strings.AsTestingSequence();
var minima = strings.MinBy(s => s.Length);
Assert.That(MoreEnumerable.LastOrDefault(minima), Is.EqualTo("az"));
}
public void WithEmptySourceWithComparerReturnsDefault()
{
using var strings = Enumerable.Empty <string>().AsTestingSequence();
var minima = strings.MinBy(s => s.Length, Comparable <int> .DescendingOrderComparer);
Assert.That(MoreEnumerable.LastOrDefault(minima), Is.Null);
}
public void FillForwardWithFillSelectorButNullSequence()
{
var e = Assert.Throws <ArgumentNullException>(() =>
MoreEnumerable.FillForward <object>(null, _ => false, delegate { return(null); }));
Assert.That(e.ParamName, Is.EqualTo("source"));
}
private List <int> GetMarks(Vec center, int localityRadius)
{
var marks = new List <int>();
var mark = new Dictionary <Vec, int>();
var nextMark = 1;
var cuboid = new Cuboid(toFill.R).Intersect(new Cuboid(center, localityRadius));
foreach (var p in cuboid.AllPoints())
{
if (p == center || filled[p])
{
continue;
}
if (!mark.ContainsKey(p))
{
mark[p] = nextMark;
var component = MoreEnumerable.TraverseDepthFirst(p, cur => cur.GetMNeighbours().Where(next => cuboid.Contains(next) && !filled[next] && !mark.ContainsKey(next)));
foreach (var componentItem in component)
{
mark[componentItem] = nextMark;
}
nextMark++;
}
marks.Add(mark[p]);
}
return(marks);
}
public void TestNegativeMaxValueException()
{
const int maxValue = -10;
Assert.Less(maxValue, 0);
MoreEnumerable.Random(maxValue);
}
public static Capture Expression(IEnumerable <string> names, Func <PList, EType> signature, Func <PList, string> compiletime, Func <PList, string> runtime = null)
{
var nameList = names.ToList();
return(new Capture("Expressions", $"[ {string.Join(" ", nameList)} ]",
func => MoreEnumerable.ForEach(nameList, name => Expression(name, signature, compiletime, runtime).Interpret(func))));
}
public void TestNullGeneratorException2()
{
const int maxValue = 10;
Assert.Greater(maxValue, 0);
MoreEnumerable.Random(null, maxValue);
}
public object SolveGenerateByIndex()
{
// using MoreLinq GenerateByIndex
var sum = MoreEnumerable.GenerateByIndex(x => (x % 3 == 0) || (x % 5 == 0) ? x : 0).Take(1000).Sum();
return(sum);
}
static IEnumerable <HashAnalysisResult> BenchmarkIntPairCases()
{
var manuals = (
from a in MoreEnumerable.Generate(-8000, a => a + 4).TakeWhile(a => a < 8000)
from b0 in MoreEnumerable.Generate(int.MaxValue, c => (int)(c * 0.95)).TakeWhile(c => c > 0)
from sign in new[] { -1, 1 }
let b = sign * b0
select new IntPairManual {
A = a,
B = b,
}
).ToArray();
var valueObjects = manuals.Select(m => m.ToValueObject()).ToArray();
var tuples = manuals.Select(m => m.ToTuple()).ToArray();
var cs7tuples = manuals.Select(m => m.ToCs7Tuple()).ToArray();
var structs = manuals.Select(m => m.ToStruct()).ToArray();
var anonymous = manuals.Select(m =>
new {
m.A,
m.B,
}).ToArray();
yield return(ProcessList(manuals));
yield return(ProcessList(valueObjects));
yield return(ProcessList(tuples));
yield return(ProcessList(cs7tuples));
yield return(ProcessList(structs));
yield return(ProcessList(anonymous));
}
public IEnumerable <NeuralNetwork> BuildNetworks()
{
while (true)
{
var graph = new AdjacencyGraph <INeuron, Connection>();
var inputs = MoreEnumerable.GenerateByIndex(_ => new NeuronWithInput()).Take(_inputSize).ToArray();
var mid =
MoreEnumerable.GenerateByIndex(_ => new BasicNeuron(new ThFunction()))
.Take(_random.Next(_outputSize, _inputSize))
.ToArray();
var outputs =
MoreEnumerable.GenerateByIndex(_ => new BasicNeuron(new ThFunction())).Take(_outputSize).ToArray();
foreach (var i in inputs)
{
foreach (var m in mid)
{
var weight = _random.NextDouble();
graph.AddVerticesAndEdge(new Connection(i, m, weight));
}
}
foreach (var m in mid)
{
foreach (var o in outputs)
{
var weight = _random.NextDouble();
graph.AddVerticesAndEdge(new Connection(m, o, weight));
}
}
yield return(new NeuralNetwork(graph, inputs, outputs));
}
}
public WeeksViewModel(DateTimeOffset startDate, LocationHistory.Entry[] entries)
{
StartDate = startDate;
EndDate = startDate.AddDays(6);
var dayNames = CultureInfo.CurrentCulture.DateTimeFormat.AbbreviatedDayNames;
Entries = entries;
Chart = new BarChart
{
MaxValue = 24,
AnimationDuration = TimeSpan.FromMilliseconds(300),
ValueLabelOrientation = Orientation.Horizontal,
LabelOrientation = Orientation.Horizontal,
Entries = MoreEnumerable.Sequence(0, 6).Select(x =>
{
var day = StartDate.AddDays(x);
var entry = entries.FirstOrDefault(e => e.Day == day) ??
new LocationHistory.Entry()
{
Day = day
};
var dayOfWeek = (int)entry.DayOfWeek;
return(new Entry(entry.HoursAtHome)
{
ValueLabel = entry.HoursAtHome.ToString(),
Label = dayNames[dayOfWeek],
Color = SKColor.Parse("#2196F3"),
});
})
};
}
public void UnfoldIsLazy()
{
MoreEnumerable.Unfold(0, BreakingFunc.Of <int, Tuple <int, int> >(),
BreakingFunc.Of <Tuple <int, int>, bool>(),
BreakingFunc.Of <Tuple <int, int>, int>(),
BreakingFunc.Of <Tuple <int, int>, int>());
}
public void WithComparerReturnsMaximumPerComparer()
{
using var strings = SampleData.Strings.AsTestingSequence();
var maxima = strings.MaxBy(s => s.Length, Comparable <int> .DescendingOrderComparer);
Assert.That(MoreEnumerable.LastOrDefault(maxima), Is.EqualTo("az"));
}
public void WithEmptySourceReturnsDefault()
{
using var strings = Enumerable.Empty <string>().AsTestingSequence();
var minima = strings.MinBy(s => s.Length);
Assert.That(MoreEnumerable.LastOrDefault(minima), Is.Null);
}
public void ReturnsMaximum()
{
using var strings = SampleData.Strings.AsTestingSequence();
var maxima = strings.MaxBy(s => s.Length);
Assert.That(MoreEnumerable.First(maxima), Is.EqualTo("hello"));
}
public void ReturnsMinimum()
{
using var strings = SampleData.Strings.AsTestingSequence();
var minima = MoreEnumerable.First(strings.MinBy(s => s.Length));
Assert.That(minima, Is.EqualTo("ax"));
}
private void test()
{
DateTime startDate = DateTime.Now.AddDays(-29);
DateTime endDate = DateTime.Now.AddDays(1);
using (var dc = new DataContext())
{
//get database sales from 29 days ago at midnight to the end of today
var salesForPeriod = dc.Orders.Where(b => b.OrderDateTime > startDate.Date && b.OrderDateTime <= endDate.Date);
var allDays = MoreEnumerable.GenerateByIndex(i => startDate.AddDays(i)).Take(30);
var salesByDay = from s in salesForPeriod
group s by s.OrderDateTime.Date into g
select new {Day = g.Key, totalSales = g.Sum(x=>(decimal)x.OrderPrice};
var query = from d in allDays
join s in salesByDay on s.Day equals d
select new {Day = s.Day , totalSales = (s != null) ? s.totalSales : 0m;
foreach (var item in query)
{
Response.Write("Date: " +item.Day.ToString() " Sales: " + String.Format("{0:0.00}", item.totalSales) + "<br>");
}
}
}
}
public void SequenceWithDescendingRangeDescendigStep(int start, int stop, int step)
{
var result = MoreEnumerable.Sequence(start, stop, step);
var expectations = Enumerable.Range(stop, start - stop + 1).Reverse().TakeEvery(Math.Abs(step));
Assert.That(result, Is.EqualTo(expectations));
}
public void SequenceWithDescendingRangeAscendingStep(int start, int stop, int step)
{
var result = MoreEnumerable.Sequence(start, stop, step);
var expectations = Enumerable.Empty <int>();
Assert.That(result, Is.EqualTo(expectations));
}
public void Solve()
{
var salt = ReadLine();
void InitArrays()
{
_mpValToIndexRepeating5 = Enumerable.Repeat(-1, 16).ToList();
_nextCheck = 0;
_md5Cache = new List <byte[]>(23000);
}
InitArrays();
WriteLine(MoreEnumerable
.Generate(0, i => i + 1)
.Where(n => IsKey(salt, n, false))
.Take(64)
.Last());
InitArrays();
Write(MoreEnumerable
.Generate(0, i => i + 1)
.Where(n => IsKey(salt, n, true))
.Take(64)
.Last());
_md5Cache = null; // Free up this memory
}
public void SequenceWithAscendingRangeAscendingStep(int start, int stop, int step)
{
var result = MoreEnumerable.Sequence(start, stop, step);
var expectations = Enumerable.Range(start, stop - start + 1).TakeEvery(step);
Assert.That(result, Is.EqualTo(expectations));
}
public void SequenceWithStartEqualsStop(int start, int stop, int?step)
{
var result = step.HasValue ? MoreEnumerable.Sequence(start, stop, step.Value)
: MoreEnumerable.Sequence(start, stop);
Assert.That(start, Is.EqualTo(result.Single()));
}
public static void Main(string[] args)
{
//MoreLinq
Console.WriteLine(MoreEnumerable.Random().First());
//Newtonsoft
Console.WriteLine(JObject.Parse(@"{""foo"":42}"));
//Mathnet
var x = Expr.Symbol("x");
Console.WriteLine(Infix.Format(x + x));
//DynamicExpresso
Console.WriteLine(new Interpreter().Eval("2+2"));
//NDesk.Options
Console.WriteLine(new OptionSet {
{ "v", v => {} }
}.Parse(new[] { "-v", "foo" })[0]);
//System.Memory
Console.WriteLine(new Span <int>(new[] { 42 })[0]);
//System.Collections.Immutable
Console.WriteLine(new[] { 12 }.ToImmutableArray()[0]);
//Microsoft.Z3
try {
Console.WriteLine($"Z3: {Microsoft.Z3.Version.ToString()}");
} catch (DllNotFoundException) {
Console.WriteLine($"Warning, native Z3 library not detected");
}
}
public void FallbackIfEmptyWithNullSequence()
{
Assert.ThrowsArgumentNullException("source", () => MoreEnumerable.FallbackIfEmpty(null, 1));
Assert.ThrowsArgumentNullException("source", () => MoreEnumerable.FallbackIfEmpty(null, 1, 2));
Assert.ThrowsArgumentNullException("source", () => MoreEnumerable.FallbackIfEmpty(null, 1, 2, 3));
Assert.ThrowsArgumentNullException("source", () => MoreEnumerable.FallbackIfEmpty(null, 1, 2, 3, 4));
Assert.ThrowsArgumentNullException("source", () => MoreEnumerable.FallbackIfEmpty(null, 1, 2, 3, 4, 5));
}
public void ConcatWithNullHead()
{
var tail = new[] { "second", "third" };
string head = null;
var whole = MoreEnumerable.Concat(head, tail);
whole.AssertSequenceEqual(null, "second", "third");
}
