private void OneIter(object o)
{
if (EnemyP.Count == 0)
{
var i = N;
while (--i >= 0)
{
var j = M;
while (--j >= 0)
{
if (_p[i, j].ColE() != 0)
{
EnemyP.Add(i * 100 + j);
}
}
}
if (EnemyP.Count == 0)
{
BVis = true;
Iter.Change(-1, 0);
return;
}
}
Game(null);
}
public Iter(int length, Iter child = null)
{
this.child = child;
this.length = length;
step = 1f / length;
best = defaultBest;
}
public Day4(string path) : base(4)
{
passports = new Iter <Passport>();
FileParser parser = new FileParser(path);
StringBuilder builder = new StringBuilder();
foreach (var line in parser.Lines)
{
if (line.Length == 0)
{
if (builder.Length > 1)
{
passports.Add(Passport.FromString(builder.ToString()));
}
builder = new StringBuilder();
}
builder.Append(line.Trim() + " ");
}
if (builder.Length > 1)
{
passports.Add(Passport.FromString(builder.ToString()));
}
}
protected internal override void TraverseIter(Iter iter)
{
_writer.Write("foreach (var {0} in ", iter.Element);
Traverse(iter.Seq);
_writer.WriteLine(")");
Traverse(iter.Body);
}
public IterEnum(Iter iter)
{
if (iter == null)
{
throw new ArgumentNullException("iter");
}
_iter = iter;
}
public override void Next()
{
iter1.Next();
if (iter1.Done())
{
iter1 = iter2;
iter2 = null;
}
}
public void ResetFs()
{
i6 = new Iter(length);
i5 = new Iter(length, i6);
i4 = new Iter(length, i5);
i3 = new Iter(length, i4);
i2 = new Iter(length, i3);
i1 = new Iter(length, i2);
}
private static IEnumerator TestEveryS_E()
{
long last = 0;
for (int k = 0; k < 20; k++)
{
Iter.EverySeconds(ref last, 3, TestEveryS_C);
yield return(new WaitForSeconds(1));
}
}
internal override Node Bind(Binder b)
{
b.OpenScope();
b.Bind(ref Expr);
Expr.RequireGetAccess();
if (Expr.Datatype.IsArray && Expr.Datatype.ArrayRank == 1)
{
var array = b.Cache(ref Expr);
var iter = b.AddLocal(Compilation.Get(NativeType.Int32));
IterDecl = VarDecl.Bound(iter, LiteralExpr.Bound(Constant.Create(b.Options.ArrayBase)), b.Options.Binding);
WhileExpr = BinaryExpr.Bound(IdExpr.Bound(iter), Token,
MethodCallExpr.Bound(array, Compilation.Get(WellKnownMembers.System_Array_get_Length), array, ArgList.Empty),
b.Options.ArrayZero ? BinaryOperatorKind.LessThan : BinaryOperatorKind.LessThanOrEqual, b.Options.Binding);
IncrExpr = AssignOpExpr.Bound(IdExpr.Bound(iter), LiteralExpr.Bound(Constant.Create(1)), BinaryOperatorKind.Addition, b);
ForDecl.Initializer = ArrayAccessExpr.Bound(array, new ArgList(new List <Arg>(1)
{
new Arg(IdExpr.Bound(iter))
}), b);
}
else
{
if (Expr.Datatype.IsUsualOrObject() && b.Options.Binding.HasFlag(BindOptions.AllowDynamic))
{
b.Convert(ref Expr, Compilation.Get(NativeType.Array));
}
Expr e = b.Cache(ref Expr);
var getIterSym = e.Datatype.GetEnumeratorGetter() ?? throw Error(ErrorCode.NoSuitableEnumerator);
var getIter = MethodCallExpr.Bound(e, getIterSym, e, ArgList.Empty);
var iter = b.AddLocal(getIter.Datatype);
IterDecl = VarDecl.Bound(iter, getIter, b.Options.Binding);
WhileExpr = MethodCallExpr.Bound(b, IdExpr.Bound(iter), SystemNames.MoveNext, ArgList.Empty);
b.Convert(ref WhileExpr, Compilation.Get(NativeType.Boolean));
ForDecl.Initializer = MethodCallExpr.Bound(b, IdExpr.Bound(iter), SystemNames.CurrentGetter, ArgList.Empty);
Dispose = Compilation.Get(WellKnownTypes.System_IDisposable).IsAssignableFrom(getIter.Datatype);
if (Dispose)
{
RequireExceptionHandling = true;
}
}
b.Bind(ref ForDecl);
InnerDecl = ForDecl;
Expr Iter;
Iter = (ForDecl.Initializer as AssignExpr).Left;
Iter.RequireGetAccess();
b.Bind(ref Stmt);
b.CloseScope();
return(null);
}
public Day2(string path) : base(2)
{
FileParser parser = new FileParser(path);
input = new Iter <string[]>();
foreach (var res in parser.SplitLinesByRegex(regex))
{
input.Add(res);
}
}
public bool isEqualTo(Iter <T> other)
{
if (other.GetType() == typeof(ArrayIter <T>))
{
try {
ArrayIter <T> _other = (ArrayIter <T>)other;
return(theList == _other.theList && index == _other.index);
} catch (InvalidCastException) { return(false); }
}
else
{
return(false);
}
}
private bool CheckRule(Rule rule, List <string> input, Iter iter, Tree tree, int depth = 0)
{
var origIter = iter.val;
var prefix = new StringBuilder();
for (int i = 0; i < depth; i++)
{
prefix.Append("\t");
}
foreach (var right in rule.Right)
{
if (iter.val == input.Count)
{
return(true);
}
var child = new Tree()
{
Data = right
};
tree.Children.AddLast(child);
if (Grammar.NonTerminals.Contains(right))
{
if (!CheckRulesForNonTerminal(right, input, iter, child, depth))
{
iter.val = origIter;
tree.Children.Clear();
return(false);
}
}
else if (right.Equals(input[iter.val]))
{
Console.WriteLine($"{prefix} Обработан символ {iter.val} : {input[iter.val]}");
iter.Inc();
}
else
{
Console.WriteLine($"{prefix} Обнаружена ошибка {iter.val} : {input[iter.val]}");
Console.WriteLine($"{prefix} Правило {rule}");
iter.val = origIter;
tree.Children.Clear();
return(false);
}
}
Console.WriteLine($"{prefix} Подходит {rule}");
return(true);
}
private Expression NumberExpressionRule()
{
Expect(TokenType.Number);
var start = double.Parse(token.Value);
if (!TryExpect(TokenType.Range))
{
return(Expression.Constant(new Number(start), typeof(Any)));
}
Expect(TokenType.Number);
var end = double.Parse(token.Value);
return(Expression.Constant(Iter.Range(start, end), typeof(Any)));
}
public bool ProcessText(string text)
{
string[] separatingChars = { " ", "\n", "\t" };
var input = text.Split(separatingChars, StringSplitOptions.RemoveEmptyEntries).ToList();
var iter = new Iter();
_tree = new Tree()
{
Data = Grammar.Start
};
var check = CheckRulesForNonTerminal(Grammar.Start, input, iter, _tree);
var checkI = iter.val == input.Count;
return(check && checkI);
}
public SOR(Iter, x, NormaRel)
{
n = length(A);
for (i = 1; i < nr; i++) {
nr = 1 / A[i, i];
for (j = 1; j < n; j++) {
if ((i = j) && A[i, j] = A(i, j)∗r);
}
}
b[i] = b[i]∗r;
x[i] = b[i];
Iter = 0;
NormaRel = 1000;
while (NormaRel > Toler && Iter < IterMax){
Iter = Iter + 1;
for (i=1; i<namespace; i++){
public void CloseExcelControl(ref Excel.Worksheet ws, ref Excel.Workbook wb, ref Excel.Application app, ref List<Process> processes)
{
if (ws != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(ws);
}
if (wb != null)
{
g_Util.DebugPrint("I'm saving Excel File...");
if (wb.ReadOnly == false)
{
wb.Save();
}
wb.Close();
System.Runtime.InteropServices.Marshal.ReleaseComObject(wb);
wb = null;
}
if (app != null)
{
g_Util.DebugPrint("I'm closing Excel File...");
app.Quit();
System.Runtime.InteropServices.Marshal.ReleaseComObject(app);
app = null;
}
if (processes != null && processes.Count > 0)
{
g_Util.DebugPrint("I'm killing Excel processes...");
foreach (Process Iter in processes)
{
if (Iter.ProcessName == "EXCEL")
{
try
{
Process.GetProcessById(Iter.Id);
Iter.Kill();
}
catch
{
continue;
}
}
}
}
}
private bool CheckRulesForNonTerminal(string nonTerm, List <string> input, Iter iter, Tree tree, int depth = 0)
{
foreach (var rule1 in Grammar.Rules.Where(rule => rule.Left.Equals(nonTerm)))
{
var prefix = new StringBuilder();
for (int i = 0; i < depth; i++)
{
prefix.Append("\t");
}
Console.WriteLine($"{prefix} Проверка {rule1}");
if (CheckRule(rule1, input, iter, tree, depth + 1))
{
return(true);
}
}
return(false);
}
private void Temp()
{
if (EnemyP.Count == 0)
{
var i = N;
while (--i >= 0)
{
var j = M;
while (--j >= 0)
{
if (_p[i, j].ColE() != 0)
{
EnemyP.Add(i * 100 + j);
}
}
}
if (EnemyP.Count == 0)
{
BVis = true;
Iter.Change(-1, 0);
return;
}
}
if (!_bvis && _shag)
{
Iter.Change(1000, 3000);
}
else
{
Iter.Change(-1, 0);
if (_shag)
{
return;
}
var k = 0;
while (EnemyP.Count != 0)
{
Game(null); k++;
}
BVis = true;
_shag = true;
}
}
public override IEnumerator _Next(EntityPlayer player)
{
/* Over should keep some memory (position), and regenerate toward player
*/
long start_time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
Emplacement placeBase = new Emplacement(player, opt);
placeBase.direction = Vectors.Float.Randomize(this.rand, 1f); // useless for peak
Printer.Log(46, "MultiEffect._Next() placeBase", player, placeBase.position, placeBase.direction);
foreach (int p in Cycler.Over())
{
if (Cycler.dt >= 0 && DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() - start_time > (long)(Cycler.dt * 1000))
{
yield break;
}
Printer.Log(41, "_Next iterating Over");
Vector3 maybeFollowing = (this.isFollowing) ? player.GetPosition() : placeBase.position;
int q = -1;
foreach (Emplacement place in Iter.On(Placer.Get(maybeFollowing)))
{
q = q + 1;
if (q >= Repeater.n)
{
break;
}
if (place.valid)
{
Printer.Log(40, "MultiEffect._Next iterating Clones", place); // last before null (firestorm)
// float state = ((float) q) / Repeater.copies;
OptionEffect rdm = Randomize();
Printer.Log(40, "_Next Randomized", p, q, opt);
Printer.Log(40, "_Next Place", p, q, place);
this.Effect1(player, place, rdm);
}
else
{
Printer.Log(40, "Invalid place:", q, place, place.valid_msg);
}
yield return(Repeater.Yield);
}
yield return(Cycler.Yield);
}
}
/*
* 6 7 8
* 3 4 5
* 0 1 2
*/
public bool MoveToNext()
{
if (countX == extra * 2)
{
Iter.MoveFor(Vector2D.Left, countX);
Iter.MoveFor(Vector2D.Up, 1);
countX = 0;
++countY;
if (countY == extra * 2 + 1)
{
return(false);
}
return(true);
}
Iter.MoveFor(Vector2D.Right, 1);
++countX;
return(true);
}
public override IEnumerator _Next(EntityPlayer player)
{
Vector3 ppos = player.GetPosition();
// if (entities.Count == 0) {
// Printer.Print("AtEntities empty at ", bounds, player);
// yield break;
// }
foreach (int p in Repeater.Over())
{
Bounds bounds = BoundToPosition(ppos, Placer.Bounds(ppos));
Iter.EverySeconds(ref last_entities_update, updateEvery, this.UpdateEntities, bounds);
// Printer.Print("AtEntities_Next Over");
// for (int draw=0; draw< Repeater.n; draw++) {
// Downscale only if all entities can't be treated at once. Don't upscale above.
int nUpdates = Math.Min(entities.Count, (int)Math.Ceiling(rate * entities.Count));
for (int draw = 0; draw < nUpdates; draw++)
{
// EntityAlive target = entities[this.NextIndex()] as EntityAlive;
// Printer.Print("AtEntities_Next Clones", draw, target); // last before null (firestorm)
EntityAlive target = SdtdUtils.Cycling.Next(entities, ref _indexEnt) as EntityAlive;
if (target != null)
{
OptionEffect rdm = Randomize();
Printer.Log(40, "AtEntities_Next Randomized", draw, target, opt);
yield return(this.Apply(player, target, rdm));
}
else
{
Printer.Log(40, "AtEntities_Next null Entity", draw);
}
yield return(Repeater.Yield);
}
yield return(Cycler.Yield); // a single cycle
}
}
private void CloseAll()
{
if (g_ExcelTool != null)
{
g_ExcelTool.CloseExcelControl(ref processes);
}
if (processes != null)
{
foreach (Process Iter in processes)
{
System.Diagnostics.Debug.WriteLine("Kill " + Iter.ProcessName);
try
{
Process.GetProcessById(Iter.Id);
Iter.Kill();
}
catch
{
continue;
}
}
}
}
protected internal virtual Node TransformIter(Iter iter)
{
return(iter.AcceptTransformer(this, true));
}
public override String ToString()
{
return ("DoVarDef(\n" + Name + ",\n" + Init.ToString() + ",\n" + Iter.ToString() + ")\n");
}
protected internal override void TraverseIter(Iter iter)
{
Traverse(iter.Seq);
Traverse(iter.Body);
Types.Add(iter, null);
}
public Iter GetIter()
{
return(Iter.NewIter(column, count));
}
protected internal override Node TransformIter(Iter iter)
{
return(Dispatch(iter));
}
protected internal override T ReduceIter(Iter iter)
{
return(Dispatch(iter));
}
private void WriteNumber(StringBuilder number)
{
StringBuilder phrase = new StringBuilder("");
StringBuilder alternative = new StringBuilder("");
digits.Insert(0, number);
for (int i = 0; i < number.Length; i++)
{
Iter++;
ParamThousands++;
if (ParamMillions.Length < Iter)
{
ParamMillions.Append("0");
}
if (!phrase.Equals(new StringBuilder("")) &&
!number[i].ToString().Equals("0"))
{
phrase.Append(" e ");
}
if (!alternative.Equals(new StringBuilder("")) &&
!number[i].ToString().Equals("0"))
{
alternative.Append(" e ");
}
if ((number.Length - 1 - i) > 1)
{
if (applyMultiplicativeTerm.Equals(true) && Iter.Equals(1) &&
multiplicative.ContainsKey(number.ToString()))
{
Vezes = false;
phrase.Append(multiplicative[number.ToString()]);
i = i + 2;
}
else
{
if (number[i].ToString().Equals("1") &&
(!number[i + 1].ToString().Equals("0") || !number[i + 2].ToString().Equals("0")))
{
phrase.Append("cento");
alternative.Append("cento");
}
else
{
if (hundreds.ContainsKey(number[i].ToString() + "00"))
{
phrase.Append(hundreds[number[i].ToString() + "00"]);
alternative.Append(hundreds[number[i].ToString() + "00"]);
}
}
}
}
else if ((number.Length - 1 - i) == 1)
{
if (applyMultiplicativeTerm.Equals(true) && Iter.Equals(1) &&
multiplicative.ContainsKey(number.ToString()))
{
Vezes = false;
phrase.Append(multiplicative[number.ToString()]);
i++;
}
else
{
if (number[i].ToString().Equals("1"))
{
if (number[i + 1].ToString().Equals("0"))
{
phrase.Append(tens[number[i].ToString() + number[i + 1].ToString()]);
alternative.Append(tens[number[i].ToString() + number[i + 1].ToString()]);
}
else
{
if (number[i + 1].ToString().Equals("4"))
{
alternative.Append(alternativeSpecials[number[i].ToString() + number[i + 1].ToString()]);
}
else
{
alternative.Append(specials[number[i].ToString() + number[i + 1].ToString()]);
}
phrase.Append(specials[number[i].ToString() + number[i + 1].ToString()]);
}
i++;
Iter++;
ParamThousands++;
if (ParamMillions.Length < Iter)
{
ParamMillions.Append("0");
}
}
else
{
if (tens.ContainsKey(number[i].ToString() + "0"))
{
phrase.Append(tens[number[i].ToString() + "0"]);
alternative.Append(tens[number[i].ToString() + "0"]);
}
}
}
}
else
{
if (applyMultiplicativeTerm.Equals(true) && Iter.Equals(1) &&
multiplicative.ContainsKey(number.ToString()))
{
Vezes = false;
phrase.Append(multiplicative[number.ToString()]);
if (alternativeMultiplicative.ContainsKey(number.ToString()))
{
alternative.Append(alternativeMultiplicative[number.ToString()]);
}
}
else
{
if (units.ContainsKey(number[i].ToString()))
{
phrase.Append(units[number[i].ToString()]);
alternative.Append(units[number[i].ToString()]);
}
}
}
}
phrase = CheckTextThousands(phrase);
alternative = CheckTextThousands(alternative);
CheckTextMillons(phrase);
ResetParameters();
InsertSentence(sentence, phrase.ToString());
InsertSentence(alternativeSentence, alternative.ToString());
}
public void Dispose()
{
_iter = null;
_current = null;
}
