public Numbers <int> indexesOfObject(T _string)
{
Numbers <int> list_ = new Numbers <int>();
int size_ = size();
if (_string == null)
{
for (int i = FIRST_INDEX; i < size_; i++)
{
if (get(i) == null)
{
list_.Add(i);
}
}
}
else
{
for (int i = FIRST_INDEX; i < size_; i++)
{
if (get(i) == null)
{
continue;
}
if (get(i).Equals(_string))
{
list_.Add(i);
}
}
}
return(list_);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
int num = int.Parse(txtNumberToAdd.Text);
Numbers.Add(num);
txtNumberToAdd.Text = (num + 1).ToString();
}
private void AddRandomNumber(object obj)
{
Random random = new Random();
int rNumber = random.Next(0, 20);
Numbers.Add(rNumber);
}
private void fillArray(int min, int max)
{
for (int i = min; i <= max; i++)
{
Numbers.Add(i);
}
}
public override object Evaluate(IContext context)
{
object leftvalue;
object rightvalue;
leftvalue = this.Left.Evaluate(context);
rightvalue = this.Right.Evaluate(context);
switch (this.@operator)
{
case BinaryOperator.Add:
return(Numbers.Add(leftvalue, rightvalue));
case BinaryOperator.Subtract:
return(Numbers.Subtract(leftvalue, rightvalue));
case BinaryOperator.Multiply:
if (Strings.IsString(leftvalue))
{
return(Strings.Multiply(leftvalue, rightvalue));
}
return(Numbers.Multiply(leftvalue, rightvalue));
case BinaryOperator.Divide:
return(Numbers.Divide(leftvalue, rightvalue));
case BinaryOperator.Power:
return(System.Convert.ToInt32(System.Math.Pow((int)leftvalue, (int)rightvalue)));
}
throw new System.InvalidOperationException();
}
public override void CreateNumbers(int quantityOfNumsToCreate)
{
// First Prime number! Had issues with the rest of logic considering I'm skipping all even numbers when counting since they obviously cannot be prime.
if (quantityOfNumsToCreate >= 1)
{
Numbers.Add(2);
}
//Starting with the number 3, as long as Numbers list has less items in it than the user wants to display, and then skipping even numbers when we look for the next number to test.
for (int i = 3; Numbers.Count != quantityOfNumsToCreate; i = i + 2)
{
bool numberIsPrime = true;
// starting again with 3, as long as each number is less than or equal to the square root of our dividend(i), incrementing divisor until this is true
for (int newDivisor = 3; newDivisor <= Math.Sqrt(i); newDivisor++)
{
// basically if the number is evenly divisible by anything other than its square root, the number is not prime.
if (i % newDivisor == 0)
{
numberIsPrime = false;
}
}
// if the number didn't fail the test in the nested conditional statement, it is prime.
if (numberIsPrime)
{
Numbers.Add(i);
}
}
}
void ForceChunk()
{
if (this._chunk != null)
{
return;
}
var arr = new object[Constants.CHUNK_SIZE];
int n = 0;
var val = this._start;
while (n < Constants.CHUNK_SIZE)
{
arr[n++] = val;
val = Numbers.Add(val, this._step);
if (this._boundsCheck.ExceededBounds(val))
{
this._chunk = new ArrayChunked(arr, 0, n); // funclib.Core.Partial( last chunk
return;
}
}
// full last chunk
if (this._boundsCheck.ExceededBounds(val))
{
this._chunk = new ArrayChunked(arr, 0, Constants.CHUNK_SIZE);
return;
}
// full intermediate chunk
this._chunk = new ArrayChunked(arr, 0, Constants.CHUNK_SIZE);
this._chunkNext = new Range(val, this._end, this._step, this._boundsCheck);
}
public void Add(int num)
{
if (num >= 0 && num <= 100)
{
Numbers.Add(num);
}
}
public override void Generate()
{
bool draw = false;
for (int t = 0; t <= 6;)
{
while (!draw)
{
int number = rng.Next(1, 48 + 1);
if (!Numbers.Contains(number))
{
Numbers.Add(number);
t++;
}
if (t == 6)
{
draw = true;
}
}
if (draw)
{
t++;
}
}
}
/// <summary>
/// Load pre-generated data from file(s).
/// Assumes files contain every element in the sequence in the file's range.
/// </summary>
private void Load(string loadFromFolder = null)
{
if (loadFromFolder == null)
{
loadFromFolder = GetSaveToFolder();
}
string path = Path.Combine(Settings.SaveToDirectory, loadFromFolder);
if (!Directory.Exists(path))
{
return;
}
string[] filenames = Directory.GetFiles(path).Where(f => Path.GetExtension(f) == Settings.IntegerFileExtension).Select(f => Path.GetFileName(f)).ToArray();
Array.Sort(filenames, new StartsWithNumberComparer());
foreach (string filename in filenames)
{
using (BinaryReader reader = new BinaryReader(File.Open(Path.Combine(path, filename), FileMode.Open)))
{
while (reader.BaseStream.Position != reader.BaseStream.Length)
{
int number = reader.ReadInt32();
if (number > Max)
{
loadReachedMax = true;
break;
}
Numbers.Add(number);
}
}
if (Extensions.GetEndingNumber(Path.GetFileNameWithoutExtension(filename)) >= Max)
{
loadReachedMax = true;
}
}
}
public override object Evaluate(IExpression[] parameters, Context context)
{
this.ValidateParameterCount(parameters, -1, 1);
object result = 0;
foreach (var value in parameters)
{
object evaluatedValue = value.Evaluate(Variables);
IEnumerable enumerable = evaluatedValue as IEnumerable;
if (enumerable != null)
{
object enumerableSum = 0;
foreach (var item in enumerable)
{
// When summing we don't want to bail out early with a null value.
enumerableSum = Numbers.Add(enumerableSum ?? 0, item ?? 0);
}
evaluatedValue = enumerableSum;
}
// When summing we don't want to bail out early with a null value.
result = Numbers.Add(result ?? 0, evaluatedValue ?? 0);
}
return(result);
}
public override object Evaluate(IExpression[] parameters, Context context)
{
this.ValidateParameterCount(parameters, -1, 1);
int count = 0;
object result = 0;
foreach (var value in parameters)
{
int increment = 1;
object evaluatedValue = value.Evaluate(Variables);
IEnumerable enumerable = evaluatedValue as IEnumerable;
if (enumerable != null)
{
int enumerableCount = 0;
object enumerableSum = 0;
foreach (var item in enumerable)
{
enumerableCount++;
enumerableSum = Numbers.Add(enumerableSum, item);
}
increment = enumerableCount;
evaluatedValue = enumerableSum;
}
result = Numbers.Add(result, evaluatedValue);
count += increment;
}
return(Convert.ToDouble(result) / count);
}
public Cell(byte index)
{
WrapPanel wrapPanel = new WrapPanel()
{
Width = 45,
Height = 45
};
for (byte i = 0; i < 9; i++)
{
Numbers.Add(new Number(i));
wrapPanel.Children.Add(Numbers[i].Visual);
}
Border border = new Border()
{
Name = $"Cell_{index}",
Width = 45,
Height = 45,
BorderThickness = new Thickness(1),
BorderBrush = Brushes.DarkGray,
HorizontalAlignment = HorizontalAlignment.Stretch,
VerticalAlignment = VerticalAlignment.Stretch,
Child = wrapPanel,
};
CellVisual.Children.Add(border);
Type = CellTypes.Open;
}
public object Evaluate(IDictionary <string, object> variables)
{
switch (_expressionType)
{
case UnaryExpressionType.Minus:
return(Numbers.Subtract(0, _expression.Evaluate(variables)));
case UnaryExpressionType.Not:
var value = _expression.Evaluate(variables);
if (value != null)
{
var valueType = Type.GetTypeCode(value.GetType());
if (value is bool)
{
return(!(bool)value);
}
return(!Convert.ToBoolean(value));
}
break;
case UnaryExpressionType.Plus:
return(Numbers.Add(0, _expression.Evaluate(variables)));
}
return(null);
}
public void UpdateNumbers(string name)
{
if (!string.IsNullOrEmpty(name))
{
Numbers.Add(name);
}
}
public override void CreateNumbers(int quantityOfNumsToGenerate)
{
//Create integers to add to Numbers List
for (int i = 0; i != quantityOfNumsToGenerate; i++)
{
Numbers.Add(i);
}
}
public void AddNumber(string key, APLValue <int?> resource)
{
if (Numbers == null)
{
Numbers = new Dictionary <string, APLValue <int?> >();
}
Numbers.Add(key, resource);
}
public Response(Random rnd, Config config)
{
Config = config;
for (var i = 0; i < config.NextNumbers; i++)
{
Numbers.Add(rnd.Next());
}
}
public void Add()
{
Assert.AreEqual(7, Numbers.Add(5, 2));
Assert.AreEqual(5.3 - 2.1, Numbers.Add(5.3, -2.1));
Assert.AreEqual(RationalNumber.Create(1, 2), Numbers.Add(RationalNumber.Create(3, 2), -1));
Assert.AreEqual(RationalNumber.Create(-1, 6), Numbers.Add(RationalNumber.Create(4, 3), RationalNumber.Create(-3, 2)));
Assert.AreEqual(0.5, Numbers.Add(RationalNumber.Create(3, 2), -1.0));
Assert.AreEqual(-0.5, Numbers.Add(1.0, RationalNumber.Create(-3, 2)));
}
public void ShouldAddDecimalAndDouble()
{
const Decimal a = (Decimal)10;
const Double b = (Double)5;
var actual = Numbers.Add(a, b);
Assert.AreEqual(typeof(Decimal), actual.GetType());
Assert.AreEqual(15, (Decimal)actual);
}
public void ShouldAddSingleAndDecimal()
{
const Single a = (Single)10;
const Decimal b = (Decimal)5;
var actual = Numbers.Add(a, b);
Assert.AreEqual(typeof(Decimal), actual.GetType());
Assert.AreEqual(15, (Decimal)actual);
}
public override void CreateNumbers(int quantityOfNumsToCreate)
{
for (var i = 0; Numbers.Count != quantityOfNumsToCreate; i++)
{
if (i % 2 == 0)
{
Numbers.Add(i);
}
}
}
public CardLine(string line, HashSet <int> numbersToCheck)
{
var lineNumbers = line.Split(',');
foreach (var number in lineNumbers)
{
Numbers.Add(int.Parse(number), numbersToCheck.Contains(int.Parse(number)));
}
Bingo = Numbers.All(number => number.Value);
}
public override IEnumerator GetEnumerator()
{
object next = this._start;
while (!this._boundsCheck.ExceededBounds(next))
{
yield return(next);
next = Numbers.Add(next, this._step);
}
}
public ButtonsViewModel()
{
Data = new ObservableCollection <ButtonViewModel>
{
new("1", new ActionCommand(() => { Numbers.Add(new Number(1)); })),
new("2", ReactiveCommand.Create(() => { Numbers.Add(new Number(2)); })),
new("3", ReactiveCommand.Create(() => { Numbers.Add(new Number(3)); })),
};
Command = new ActionCommand(() => { MessageBox.Show("Event To Command"); });
}
public WaterfallCollectionSource(WaterfallCollectionView collectionView)
{
// Initialize
CollectionView = collectionView;
// Init numbers collection
for (int n = 0; n < 100; ++n)
{
Numbers.Add(n);
Heights.Add(rnd.Next(0, 100) + 40f);
}
}
private void AddNumber(int number, int prevPrevTerm, int prevTerm)
{
if (number > Max)
{
return;
}
if (number == prevPrevTerm || number == prevTerm)
{
return;
}
Numbers.Add(number);
}
protected override void Generate()
{
Sequence primes = new SieveOfEratosthenes(Max * 10); //going order of magnitude higher than prime because rotating prime could end up with a higher number; ex: 17 => 71
foreach (int prime in primes.InRange(LastNumber, Max))
{
if (IsCircularPrime(prime, primes))
{
Numbers.Add(prime);
}
}
}
protected override void Generate()
{
Sequence primes = new SieveOfEratosthenes(Max);
foreach (int prime in primes.InRange(LastNumber, Max))
{
int sumOfDigits = prime.SumOfDigits();
if (primes.Contains(sumOfDigits)) //sum of digits is guaranteed to be equal or lesser number, so its in the prime collection
{
Numbers.Add(prime);
}
}
}
public override object Execute(List arguments, ValueEnvironment environment)
{
object result = 0;
while (!Predicates.IsNil(arguments))
{
object argument = arguments.First;
arguments = arguments.Next;
result = Numbers.Add(result, argument);
}
return(result);
}
