public override string ToString() { if (Operation == '=') { return(Operation + Op1.ToString()); } return(Op1.ToString() + Operation + Op2.ToString()); }
public Op2 <TKey, TValue, TOp, TCursor> Initialize() { var instance = new Op2 <TKey, TValue, TOp, TCursor> { _cursor = _cursor.Initialize(), }; return(instance); }
public Op2 <TKey, TValue, TOp, TCursor> Clone() { var instance = new Op2 <TKey, TValue, TOp, TCursor> { _cursor = _cursor.Clone(), }; return(instance); }
public override object GetValor(Entorno e, LinkedList <Salida> log, LinkedList <Error> errores) { object valOp1 = Op1.GetValor(e, log, errores); if (valOp1 != null) { if (valOp1 is Throw) { return(valOp1); } if (Op != Operador.NOT) { object valOp2 = Op2.GetValor(e, log, errores); if (valOp2 != null) { if (valOp2 is Throw) { return(valOp2); } Tipo = new Tipo(Type.BOOLEAN); if (Op1.Tipo.IsBoolean() && Op2.Tipo.IsBoolean()) { switch (Op) { case Operador.OR: return((bool)valOp1 || (bool)valOp2); case Operador.AND: return((bool)valOp1 && (bool)valOp2); case Operador.XOR: return((bool)valOp1 ^ (bool)valOp2); } } errores.AddLast(new Error("Semántico", "No se pudo realizar la operación lógica.", Linea, Columna)); } } else { Tipo = new Tipo(Type.BOOLEAN); if (Op1.Tipo.IsBoolean()) { return(!(bool)valOp1); } errores.AddLast(new Error("Semántico", "No se pudo realizar la operación lógica.", Linea, Columna)); } } return(null); }
// Use this for initialization void Start() { cubes = cubeContainer.GetComponentsInChildren <Cube>(); // Get the graphical numbers to use op1 = questionContainer.GetComponentInChildren <Op1>(); // Get access to the script of the 1st operand op2 = questionContainer.GetComponentInChildren <Op2>(); // Get access to the script of the 2nd operand op3 = questionContainer.GetComponentInChildren <Op3>(); // Get access to the script of the 3rd operand audio = GetComponent <AudioSource>(); // Get the audio component // Assign numbers to the variables and cubes for (int i = 0; i < 9; i++) { cubes[i].num = i + 1; cubes[i].numText.text = "" + (i + 1); cubes[i + 9].num = i + 1; cubes[i + 9].numText.text = "" + (i + 1); } // Store original positions of number graphics originalPosition = new Vector3[cubes.Length]; for (int i = 0; i < cubes.Length; i++) { originalPosition[i] = new Vector3(cubes[i].transform.position.x, cubes[i].transform.position.y, cubes[i].transform.position.z); } if (isMultiplicationGame) { ResetGameMult(); SetQuestionMult(); } else if (isAdditionGame) { LoadLevel(); } else if (is2OperatorGame) { level = 15.0f; LoadLevel(); } }
public override String ToString() { String str = ""; switch (CmdName) { case "park": str = "Парковать"; break; case "push": str = "Положить в ячейку " + Op2.ToString(); break; case "take": str = "Взять из ячейки " + Op1.ToString(); break; case "trans": str = "Переместить из ячейки " + Op1.ToString() + " в ячейку " + Op2.ToString(); break; } return(str); }
public override string ToString() { switch (OperationType) { case ArthmeticOperationType.Add: return($"({Op1.ToString()}) + ({Op2.ToString()})"); case ArthmeticOperationType.Div: return($"({Op1.ToString()}) / ({Op2.ToString()})"); case ArthmeticOperationType.Mod: return($"({Op1.ToString()}) % ({Op2.ToString()})"); case ArthmeticOperationType.Mult: return($"({Op1.ToString()}) * ({Op2.ToString()})"); case ArthmeticOperationType.Sub: return($"({Op1.ToString()}) - ({Op2.ToString()})"); default: throw new InvalidEnumArgumentException(nameof(OperationType)); } }
public override Expression Solve() { switch (OperationType) { case ArthmeticOperationType.Add: return(Op1.Solve() + Op2.Solve()); case ArthmeticOperationType.Div: return(Op1.Solve() / Op2.Solve()); case ArthmeticOperationType.Mod: return(Op1.Solve() % Op2.Solve()); case ArthmeticOperationType.Mult: return(Op1.Solve() * Op2.Solve()); case ArthmeticOperationType.Sub: return(Op1.Solve() - Op2.Solve()); default: throw new InvalidEnumArgumentException(nameof(OperationType)); } }
public override double Solve(IDictionary <Variable, Operation> values) { switch (OperationType) { case ArthmeticOperationType.Add: return(Op1.Solve(values) + Op2.Solve(values)); case ArthmeticOperationType.Div: return(Op1.Solve(values) / Op2.Solve(values)); case ArthmeticOperationType.Mod: return(Op1.Solve(values) % Op2.Solve(values)); case ArthmeticOperationType.Mult: return(Op1.Solve(values) * Op2.Solve(values)); case ArthmeticOperationType.Sub: return(Op1.Solve(values) - Op2.Solve(values)); default: throw new InvalidEnumArgumentException(nameof(OperationType)); } }
static void Main(string[] args) { //lambda statement Op1 fact = n => { int ans = 1; for (int i = 1; i <= n; i++) { ans = ans * i; } return(ans); }; //lambda expression Op2 even = n => n % 2 == 0; Console.WriteLine(fact(4)); if (even(6)) { Console.WriteLine("Number is even"); } Console.ReadKey(); }
private String CompositeToString() { return(Op1.ToString() + " " + ComparisonOperatorToString() + " " + Op2.ToString()); }
private String AssignmentToString() { return(Op1.ToString() + " = " + Op2.ToString()); }
private String AndToString() { return(Op1.ToString() + " & " + Op2.ToString()); }
private String AdditionToString() { return(Op1.ToString() + " + " + Op2.ToString()); }
public override Result GetC3D(Ent e, bool funcion, bool ciclo, bool isObjeto, LinkedList <Error> errores) { Result result = new Result(); if (Op1 is Relacional) { ((Relacional)Op1).Cortocircuito = true; } else if (Op1 is Logica) { ((Logica)Op1).Evaluar = true; } Result rsOp1 = Op1.GetC3D(e, funcion, ciclo, isObjeto, errores); if (Op2 != null) { if (Op2 is Relacional) { ((Relacional)Op2).Cortocircuito = true; } else if (Op2 is Logica) { ((Logica)Op2).Evaluar = true; } Result rsOp2 = Op2.GetC3D(e, funcion, ciclo, isObjeto, errores); TipoResultante(Op1.GetTipo(), Op2.GetTipo()); if (!Tipo.IsIndefinido()) { if (Tipo.IsBoolean()) /*Si los dos son booleanos*/ { if (Op1 is Literal) { rsOp1.EtiquetaV = NuevaEtiqueta(); rsOp1.EtiquetaF = NuevaEtiqueta(); rsOp1.Codigo += "ifFalse (" + rsOp1.Valor + " == 1) goto " + rsOp1.EtiquetaV + ";\n"; rsOp1.Codigo += "goto " + rsOp1.EtiquetaF + ";\n"; rsOp1.EtiquetaV += ":\n"; rsOp1.EtiquetaF += ":\n"; } if (Op2 is Literal) { rsOp2.EtiquetaV = NuevaEtiqueta(); rsOp2.EtiquetaF = NuevaEtiqueta(); rsOp2.Codigo += "ifFalse (" + rsOp2.Valor + " == 1) goto " + rsOp2.EtiquetaV + ";\n"; rsOp2.Codigo += "goto " + rsOp2.EtiquetaF + ";\n"; rsOp2.EtiquetaV += ":\n"; rsOp2.EtiquetaF += ":\n"; } if (Op == Operador.AND) { result.Codigo += rsOp1.Codigo; if (Op1 is Relacional || Op1 is Literal) { result.Codigo += rsOp1.EtiquetaF; rsOp1.EtiquetaF = rsOp1.EtiquetaV; rsOp1.EtiquetaV = null; } else if (Op1 is Logica) { result.Codigo += rsOp1.EtiquetaV; rsOp1.EtiquetaV = null; } result.Codigo += rsOp2.Codigo; if (Op2 is Relacional || Op2 is Literal) { string copy = rsOp2.EtiquetaV; rsOp2.EtiquetaV = rsOp2.EtiquetaF; rsOp2.EtiquetaF = copy; } /* * if(Op2 is Relacional) * result.Codigo += rsOp2.EtiquetaF;*/ if (!Evaluar) { result.Valor = NuevoTemporal(); string etiquetaS = NuevaEtiqueta(); if (rsOp1.EtiquetaV != null) { result.Codigo += rsOp1.EtiquetaV; } if (rsOp2.EtiquetaV != null) { result.Codigo += rsOp2.EtiquetaV; } result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; if (rsOp1.EtiquetaF != null) { result.Codigo += rsOp1.EtiquetaF; } if (rsOp2.EtiquetaF != null) { result.Codigo += rsOp2.EtiquetaF; } result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { if (rsOp1.EtiquetaV != null) { result.EtiquetaV += rsOp1.EtiquetaV; } if (rsOp1.EtiquetaF != null) { result.EtiquetaF += rsOp1.EtiquetaF; } if (rsOp2.EtiquetaV != null) { result.EtiquetaV += rsOp2.EtiquetaV; } if (rsOp2.EtiquetaF != null) { result.EtiquetaF += rsOp2.EtiquetaF; } } } else { result.Codigo += rsOp1.Codigo; if (Op1 is Relacional || Op1 is Literal) { result.Codigo += rsOp1.EtiquetaV; rsOp1.EtiquetaV = rsOp1.EtiquetaF; rsOp1.EtiquetaF = null; } else if (Op1 is Logica) { result.Codigo += rsOp1.EtiquetaF; rsOp1.EtiquetaF = null; } result.Codigo += rsOp2.Codigo; if (Op2 is Relacional || Op2 is Literal) { string copy = rsOp2.EtiquetaV; rsOp2.EtiquetaV = rsOp2.EtiquetaF; rsOp2.EtiquetaF = copy; } if (!Evaluar) { result.Valor = NuevoTemporal(); string etiquetaS = NuevaEtiqueta(); if (rsOp1.EtiquetaV != null) { result.Codigo += rsOp1.EtiquetaV; } if (rsOp2.EtiquetaV != null) { result.Codigo += rsOp2.EtiquetaV; } result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; if (rsOp1.EtiquetaF != null) { result.Codigo += rsOp1.EtiquetaF; } if (rsOp2.EtiquetaF != null) { result.Codigo += rsOp2.EtiquetaF; } result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { if (rsOp1.EtiquetaV != null) { result.EtiquetaV += rsOp1.EtiquetaV; } if (rsOp1.EtiquetaF != null) { result.EtiquetaF += rsOp1.EtiquetaF; } if (rsOp2.EtiquetaV != null) { result.EtiquetaV += rsOp2.EtiquetaV; } if (rsOp2.EtiquetaF != null) { result.EtiquetaF += rsOp2.EtiquetaF; } } } } else { if (Op == Operador.AND) { if (Op2 is Literal && !Op2.GetTipo().IsNone()) { result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp2.Valor + ";\n"; } else { result.Codigo += rsOp2.Codigo; result.Valor = rsOp2.Valor; if (Op2 is Relacional || Op2 is Logica) { if (!Evaluar) { result.Valor = NuevoTemporal(); string etiquetaS = NuevaEtiqueta(); if (rsOp2.EtiquetaV != null) { result.Codigo += rsOp2.EtiquetaV; } result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; if (rsOp2.EtiquetaF != null) { result.Codigo += rsOp2.EtiquetaF; } result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { result.EtiquetaV = rsOp2.EtiquetaV; result.EtiquetaF = rsOp2.EtiquetaF; } } } Tipo = Op2.GetTipo(); } else { if (Op1 is Literal && !Op1.GetTipo().IsNone()) { result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + ";\n"; } else { result.Codigo += rsOp1.Codigo; result.Valor = rsOp1.Valor; if (Op1 is Relacional || Op1 is Logica) { if (!Evaluar) { result.Valor = NuevoTemporal(); string etiquetaS = NuevaEtiqueta(); if (rsOp1.EtiquetaV != null) { result.Codigo += rsOp1.EtiquetaV; } result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; if (rsOp1.EtiquetaF != null) { result.Codigo += rsOp1.EtiquetaF; } result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { result.EtiquetaV = rsOp1.EtiquetaV; result.EtiquetaF = rsOp1.EtiquetaF; } } } Tipo = Op1.GetTipo(); } } } else { errores.AddLast(new Error("Semántico", "Error de tipos en operación lógica.", Linea, Columna)); } } else /*NOT*/ { Tipo.Tip = Tipo.Type.BOOLEAN; if (Op1.GetTipo().IsBoolean()) /*Boolean, exp logica y relacional*/ { if (Op1 is Literal) { rsOp1.EtiquetaV = NuevaEtiqueta(); rsOp1.EtiquetaF = NuevaEtiqueta(); rsOp1.Codigo += "ifFalse (" + rsOp1.Valor + " == 1) goto " + rsOp1.EtiquetaV + ";\n"; rsOp1.Codigo += "goto " + rsOp1.EtiquetaF + ";\n"; rsOp1.EtiquetaV += ":\n"; rsOp1.EtiquetaF += ":\n"; } result.Codigo += rsOp1.Codigo; if (!Evaluar) { result.Valor = NuevoTemporal(); string etiquetaS = NuevaEtiqueta(); if (rsOp1.EtiquetaV != null) { result.Codigo += rsOp1.EtiquetaV; } result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; if (rsOp1.EtiquetaF != null) { result.Codigo += rsOp1.EtiquetaF; } result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { if (rsOp1.EtiquetaV != null) { result.EtiquetaF = rsOp1.EtiquetaV; } if (rsOp1.EtiquetaF != null) { result.EtiquetaV = rsOp1.EtiquetaF; } } } else { if (Op1 is Literal) { string tmp = NuevoTemporal(); rsOp1.Codigo += tmp + " = " + rsOp1.Valor + ";\n"; rsOp1.Valor = tmp; } if (Op1.GetTipo().IsString()) { rsOp1.Codigo += rsOp1.Valor + " = 0 - 1;\n"; } result.Codigo += rsOp1.Codigo; if (!Evaluar) { result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = 0;\n"; result.Codigo += "ifFalse (" + rsOp1.Valor + " == 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += result.Valor + " = 1;\n"; result.Codigo += result.EtiquetaV + ":\n"; } else { result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "ifFalse (" + rsOp1.Valor + " == 0) goto " + result.EtiquetaF + ";\n"; result.Codigo += "goto " + result.EtiquetaV + ";\n"; result.EtiquetaV += ":\n"; result.EtiquetaF += ":\n"; } } } return(result); }
public ZipOp(Zip <TKey, TValue, TValue, TCursorLeft, TCursorRight> zip) { var op = new Op2 <TKey, TValue, TOp, Zip <TKey, TValue, TValue, TCursorLeft, TCursorRight> >(zip); _op = op; }
private String RightShiftToString() { return(Op1.ToString() + " >> " + Op2.ToString()); }
public override Tipo GetTipo(Entorno e) { if (!(Op1 is Operacion) && !(Op2 is Operacion)) { Tipo tip1 = Op1.GetTipo(e); Tipo tip2 = Op2.GetTipo(e); if (tip1 != Tipo.NULL && tip2 != Tipo.NULL) { if ((tip1 == Tipo.DECIMAL || tip1 == Tipo.ENTERO) && (tip2 == Tipo.DECIMAL || tip2 == Tipo.ENTERO)) { try { if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { double val1 = Convert.ToDouble(Op1.GetValor()); double val2 = Convert.ToDouble(Op2.GetValor()); switch (Op) { case Operador.MENORQUE: valor = val1 < val2 ? 1 : 0; return(Tipo.DECIMAL); case Operador.MAYORQUE: valor = val1 > val2 ? 1 : 0; return(Tipo.DECIMAL); case Operador.MENORIGUAL: valor = val1 <= val2 ? 1 : 0; return(Tipo.DECIMAL); case Operador.MAYORIGUAL: valor = val1 >= val2 ? 1 : 0; return(Tipo.DECIMAL); case Operador.IGUAL: valor = val1 == val2 ? 1 : 0; return(Tipo.DECIMAL); case Operador.DIFERENTE: valor = val1 != val2 ? 1 : 0; return(Tipo.DECIMAL); } } else { int val1 = Convert.ToInt32(Op1.GetValor()); int val2 = Convert.ToInt32(Op2.GetValor()); switch (Op) { case Operador.MENORQUE: valor = val1 < val2 ? 1 : 0; return(Tipo.ENTERO); case Operador.MAYORQUE: valor = val1 > val2 ? 1 : 0; return(Tipo.ENTERO); case Operador.MENORIGUAL: valor = val1 <= val2 ? 1 : 0; return(Tipo.ENTERO); case Operador.MAYORIGUAL: valor = val1 >= val2 ? 1 : 0; return(Tipo.ENTERO); case Operador.IGUAL: valor = val1 == val2 ? 1 : 0; return(Tipo.ENTERO); case Operador.DIFERENTE: valor = val1 != val2 ? 1 : 0; return(Tipo.ENTERO); } } } catch (Exception) { Console.WriteLine("Error, no se puede realizar la operación relacional. Línea: " + Linea); } } else { Console.WriteLine("Error, no se puede realizar la operación relacional. Línea: " + Linea); } } } else { Console.WriteLine("Error, se esta usando más de 3 direcciones. Línea: " + Linea); } return(Tipo.NULL); }
public override Result GetC3D(Ent e, bool funcion, bool ciclo, bool isObjeto, LinkedList <Error> errores) { Result result = new Result(); Result rsOp1 = Op1.GetC3D(e, funcion, ciclo, isObjeto, errores); if (Op2 != null) { Result rsOp2 = Op2.GetC3D(e, funcion, ciclo, isObjeto, errores); TipoDominante(Op1.GetTipo(), Op2.GetTipo()); if (!Tipo.IsIndefinido()) { result.Codigo += rsOp1.Codigo; result.Codigo += rsOp2.Codigo; if (Tipo.IsString()) { if (!Op1.GetTipo().IsString()) { ConvertirString(Op1, rsOp1, result); } if (!Op2.GetTipo().IsString()) { ConvertirString(Op2, rsOp2, result); } result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); string etqCiclo = NuevaEtiqueta(); string tmpCiclo = NuevoTemporal(); result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = H;\n"; result.Codigo += tmpCiclo + " = heap[" + rsOp1.Valor + "];\n"; result.Codigo += etqCiclo + ":\n"; result.Codigo += "if (" + tmpCiclo + " == 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += "heap[H] = " + tmpCiclo + ";\n"; result.Codigo += "H = H + 1;\n"; result.Codigo += rsOp1.Valor + " = " + rsOp1.Valor + " + 1;\n"; result.Codigo += tmpCiclo + " = heap[" + rsOp1.Valor + "];\n"; result.Codigo += "goto " + etqCiclo + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); etqCiclo = NuevaEtiqueta(); tmpCiclo = NuevoTemporal(); result.Codigo += tmpCiclo + " = heap[" + rsOp2.Valor + "];\n"; result.Codigo += etqCiclo + ":\n"; result.Codigo += "if (" + tmpCiclo + " == 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += "heap[H] = " + tmpCiclo + ";\n"; result.Codigo += "H = H + 1;\n"; result.Codigo += rsOp2.Valor + " = " + rsOp2.Valor + " + 1;\n"; result.Codigo += tmpCiclo + " = heap[" + rsOp2.Valor + "];\n"; result.Codigo += "goto " + etqCiclo + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += "heap[H] = 0;\n"; result.Codigo += "H = H + 1;\n"; } else { switch (Op) { case Operador.SUMA: result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " + " + rsOp2.Valor + ";\n"; break; case Operador.RESTA: result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " - " + rsOp2.Valor + ";\n"; break; case Operador.MULTIPLICACION: result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " * " + rsOp2.Valor + ";\n"; break; case Operador.DIVISION: result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " / " + rsOp2.Valor + ";\n"; break; case Operador.MODULO: result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " % " + rsOp2.Valor + ";\n"; break; case Operador.FLOOR: result.EtiquetaV = NuevaEtiqueta(); string etqSalida = NuevaEtiqueta(); if (Op1 is Literal) { string tmpOp1 = NuevoTemporal(); result.Codigo += tmpOp1 + " = " + rsOp1.Valor + ";\n"; rsOp1.Valor = tmpOp1; } if (Op2 is Literal) { string tmpOp2 = NuevoTemporal(); result.Codigo += tmpOp2 + " = " + rsOp2.Valor + ";\n"; rsOp2.Valor = tmpOp2; } result.Valor = NuevoTemporal(); result.Codigo += "if (" + rsOp2.Valor + " != 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + etqSalida + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; string tmpCond = NuevoTemporal(); result.Codigo += tmpCond + " = 0;\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + rsOp2.Valor + " > 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += tmpCond + " = 1;\n"; string menos = NuevoTemporal(); result.Codigo += menos + " = 0 - 1;\n"; result.Codigo += rsOp2.Valor + " = " + rsOp2.Valor + " * " + menos + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; string tmpCond2 = NuevoTemporal(); result.Codigo += tmpCond2 + " = 0;\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + rsOp1.Valor + " >= 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += tmpCond2 + " = 1;\n"; menos = NuevoTemporal(); result.Codigo += menos + " = 0 - 1;\n"; result.Codigo += rsOp1.Valor + " = " + rsOp1.Valor + " * " + menos + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "if (" + rsOp2.Valor + " > " + rsOp1.Valor + ") goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += result.Valor + " = 0;\n"; result.Codigo += result.EtiquetaF + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); string etqCiclo = NuevaEtiqueta(); string tmp = NuevoTemporal(); result.Codigo += tmp + " = " + rsOp1.Valor + " - " + rsOp2.Valor + ";\n"; result.Codigo += etqCiclo + ":\n"; result.Codigo += tmp + " = " + tmp + " - " + rsOp2.Valor + ";\n"; result.Codigo += "if (" + tmp + " >= 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += result.Valor + " = " + result.Valor + " + 1;\n"; result.Codigo += "goto " + etqCiclo + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + tmpCond + " == 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; string etqVerd = result.EtiquetaV; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + tmpCond2 + " == 1) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += result.Valor + " = " + result.Valor + " + 1;\n"; menos = NuevoTemporal(); result.Codigo += menos + " = 0 - 1;\n"; result.Codigo += result.Valor + " = " + result.Valor + " * " + menos + ";\n"; result.Codigo += etqVerd + ":\n"; result.Codigo += result.EtiquetaV + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + tmpCond2 + " == 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; etqVerd = result.EtiquetaV; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + tmpCond + " == 1) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += result.Valor + " = " + result.Valor + " + 1;\n"; menos = NuevoTemporal(); result.Codigo += menos + " = 0 - 1;\n"; result.Codigo += result.Valor + " = " + result.Valor + " * " + menos + ";\n"; result.Codigo += etqVerd + ":\n"; result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += etqSalida + ":\n"; break; case Operador.POTENCIA: if (Op1 is Literal) { string tmpOp1 = NuevoTemporal(); result.Codigo += tmpOp1 + " = " + rsOp1.Valor + ";\n"; rsOp1.Valor = tmpOp1; } if (Op2 is Literal) { string tmpOp2 = NuevoTemporal(); result.Codigo += tmpOp2 + " = " + rsOp2.Valor + ";\n"; rsOp2.Valor = tmpOp2; } else if (Op2 is Aritmetica) { if (((Aritmetica)Op2).Op2 == null && ((Aritmetica)Op2).Op == Operador.RESTA) { Tipo.Tip = Tipo.Type.DOUBLE; } } result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); string factorNeg = NuevoTemporal(); string nuevoValor = NuevoTemporal(); string etqSalida2 = NuevaEtiqueta(); //string etqError = NuevaEtiqueta(); result.Codigo += "if (" + rsOp2.Valor + " >= 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += factorNeg + " = 0 - 1;\n"; result.Codigo += rsOp2.Valor + " = " + rsOp2.Valor + " * " + factorNeg + ";\n"; //result.Codigo += "if (" + rsOp1.Valor + " == 0) goto " + etqError + ";\n";/*0**-num*/ result.Codigo += nuevoValor + " = 1.0 / " + rsOp1.Valor + ";\n"; result.Codigo += "goto " + etqSalida2 + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += nuevoValor + " = " + rsOp1.Valor + ";\n"; result.Codigo += etqSalida2 + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); string etqCiclo2 = NuevaEtiqueta(); result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = 1;\n"; result.Codigo += etqCiclo2 + ":\n"; result.Codigo += "if (" + rsOp2.Valor + " <= 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += result.Valor + " = " + result.Valor + " * " + nuevoValor + ";\n"; result.Codigo += rsOp2.Valor + " = " + rsOp2.Valor + " - 1;\n"; result.Codigo += "goto " + etqCiclo2 + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; break; } } } else { errores.AddLast(new Error("Semántico", "Error de tipos en operación aritmética.", Linea, Columna)); } } else { Tipo tipOp1 = Op1.GetTipo(); if (tipOp1.IsNumeric() || tipOp1.IsBoolean()) { if (tipOp1.IsNumeric()) { Tipo = Op1.GetTipo(); } else { Tipo = new Tipo(Tipo.Type.INT); } result.Codigo += rsOp1.Codigo; result.Valor = NuevoTemporal(); switch (Op) { case Operador.SUMA: result.Codigo += result.Valor + " = " + rsOp1.Valor + " * 1;\n"; break; case Operador.RESTA: result.Codigo += result.Valor + " = 0 - 1;\n"; string tmp = result.Valor; result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " * " + tmp + ";\n"; break; } } else { errores.AddLast(new Error("Semántico", "Error de tipos en operación aritmética.", Linea, Columna)); } } return(result); }
public override object GetValor(Entorno e, LinkedList <Salida> log, LinkedList <Error> errores) { object valOp1 = Op1.GetValor(e, log, errores); object valOp2 = Op2.GetValor(e, log, errores); if (valOp1 != null && valOp2 != null) { if (valOp1 is Throw) { return(valOp1); } if (valOp2 is Throw) { return(valOp2); } TipoDominante(errores); if (Tipo != null) { switch (Tipo.Type) { case Type.STRING: Cadena cad = new Cadena { Valor = valOp1.ToString() + valOp2.ToString() }; return(cad); case Type.DOUBLE: switch (Op) { case Operador.SUMA: return(Convert.ToDouble(valOp1) + Convert.ToDouble(valOp2)); case Operador.RESTA: return(Convert.ToDouble(valOp1) - Convert.ToDouble(valOp2)); case Operador.MULTIPLICACION: return(Convert.ToDouble(valOp1) * Convert.ToDouble(valOp2)); case Operador.POTENCIA: return(Math.Pow(Convert.ToDouble(valOp1), Convert.ToDouble(valOp2))); case Operador.MODULO: return(Convert.ToDouble(valOp1) % Convert.ToDouble(valOp2)); case Operador.DIVISION: if (Convert.ToDouble(valOp2) != 0) { return(Convert.ToDouble(valOp1) / Convert.ToDouble(valOp2)); } //errores.AddLast(new Error("Semántico", "División entre 0.", Linea, Columna)); return(new Throw("ArithmeticException", Linea, Columna)); } break; case Type.INT: switch (Op) { case Operador.SUMA: return(Convert.ToInt32(valOp1) + Convert.ToInt32(valOp2)); case Operador.RESTA: return(Convert.ToInt32(valOp1) - Convert.ToInt32(valOp2)); case Operador.MULTIPLICACION: return(Convert.ToInt32(valOp1) * Convert.ToInt32(valOp2)); case Operador.POTENCIA: return(Math.Pow(Convert.ToInt32(valOp1), Convert.ToInt32(valOp2))); case Operador.MODULO: return(Convert.ToInt32(valOp1) % Convert.ToInt32(valOp2)); case Operador.DIVISION: if (Convert.ToInt32(valOp2) != 0) { return(Convert.ToInt32(valOp1) / Convert.ToInt32(valOp2)); } //errores.AddLast(new Error("Semántico", "División entre 0.", Linea, Columna)); return(new Throw("ArithmeticException", Linea, Columna)); } break; case Type.MAP: if (valOp1 is Null) { return(new Throw("NullPointerException", Linea, Columna)); } if (valOp2 is Null) { return(new Throw("NullPointerException", Linea, Columna)); } Collection map1 = (Collection)valOp1; Collection map2 = (Collection)valOp2; foreach (CollectionValue value in map2.Valores) { if (Op == Operador.SUMA) { if (map1.Tipo.Clave.Equals(map2.Tipo.Clave) && map1.Tipo.Valor.Equals(map2.Tipo.Valor)) { if (map1.Get(value.Clave) == null) { map1.Insert(value.Clave, value.Valor); } else { map1.Set(value.Clave, value.Valor); //errores.AddLast(new Error("Semántico", "Ya existe un valor con la clave: " + value.Clave.ToString() + " en Map.", Linea, Columna)); } } else { Casteo cast1 = new Casteo(map1.Tipo.Clave, new Literal(map2.Tipo.Clave, value.Clave, 0, 0), 0, 0) { Mostrar = false }; Casteo cast2 = new Casteo(map1.Tipo.Valor, new Literal(map2.Tipo.Valor, value.Valor, 0, 0), 0, 0) { Mostrar = false }; object clave = cast1.GetValor(e, log, errores); object valor = cast2.GetValor(e, log, errores); if (clave != null && valor != null) { if (clave is Throw) { return(clave); } if (valor is Throw) { return(valor); } if (map1.Get(clave) == null) { map1.Insert(clave, valor); } else { map1.Set(clave, valor); //errores.AddLast(new Error("Semántico", "Ya existe un valor con la clave: " + clave.ToString() + " en Map.", Linea, Columna)); } continue; } errores.AddLast(new Error("Semántico", "Los tipos de los parametros no coinciden con la clave:valor del Map.", Linea, Columna)); return(null); } } else if (Op == Operador.RESTA) { if (map1.Tipo.Clave.Equals(map2.Tipo.Valor)) { if (!map1.Remove(value.Valor)) { errores.AddLast(new Error("Semántico", "No existe un valor con la clave: " + value.Valor.ToString() + " en Map.", Linea, Columna)); } } else { Casteo cast = new Casteo(map1.Tipo.Clave, new Literal(map2.Tipo.Valor, value.Valor, 0, 0), 0, 0) { Mostrar = false }; object clave = cast.GetValor(e, log, errores); if (clave != null) { if (!map1.Remove(clave)) { errores.AddLast(new Error("Semántico", "No existe un valor con la clave: " + clave.ToString() + " en Map.", Linea, Columna)); } } } } else { return(new Throw("ArithmeticException", Linea, Columna)); } } return(map1); case Type.LIST: case Type.SET: if (valOp1 is Null) { return(new Throw("NullPointerException", Linea, Columna)); } if (valOp2 is Null) { return(new Throw("NullPointerException", Linea, Columna)); } Collection set1 = (Collection)valOp1; Collection set2 = (Collection)valOp2; foreach (CollectionValue value in set2.Valores) { if (Op == Operador.SUMA) { if (set1.Tipo.Valor.Equals(set2.Tipo.Valor)) { set1.Insert(set1.Posicion++, value.Valor); } else { Casteo cast = new Casteo(set1.Tipo.Valor, new Literal(set2.Tipo.Valor, value.Valor, 0, 0), 0, 0) { Mostrar = false }; object valor = cast.GetValor(e, log, errores); if (valor != null) { if (valor is Throw) { return(valor); } set1.Insert(set1.Posicion++, valor); continue; } errores.AddLast(new Error("Semántico", "El tipo del parametro no coinciden con el valor de la Collection.", Linea, Columna)); return(null); } } else if (Op == Operador.RESTA) { if (set1.Tipo.Valor.Equals(set2.Tipo.Valor)) { if (!set1.RemoveValor(value.Valor)) { errores.AddLast(new Error("Semántico", "No existe un valor: " + value.Valor.ToString() + " en Collection.", Linea, Columna)); } } else { Casteo cast = new Casteo(set1.Tipo.Valor, new Literal(set2.Tipo.Valor, value.Valor, 0, 0), 0, 0) { Mostrar = false }; object valor = cast.GetValor(e, log, errores); if (valor != null) { if (valor is Throw) { return(valor); } if (!set1.RemoveValor(valor)) { errores.AddLast(new Error("Semántico", "No existe un valor: " + valor.ToString() + " en Collection.", Linea, Columna)); } continue; } errores.AddLast(new Error("Semántico", "El tipo del parametro no coinciden con el valor de la Collection.", Linea, Columna)); return(null); } } else { return(new Throw("ArithmeticException", Linea, Columna)); } } return(set1); } } return(new Throw("ArithmeticException", Linea, Columna)); } return(null); }
public override StackEntry Duplicate() { return(new BinaryOperator(Operation, IsComparison, Op1.Duplicate(), Op2.Duplicate(), Kind)); }
private String LeftShiftToString() { return(Op1.ToString() + " << " + Op2.ToString()); }
private String OrToString() { return(Op1.ToString() + " | " + Op2.ToString()); }
public bool IsValidFormat() => Op1?.IsValidFormat() == true && Op2?.IsValidFormat() == true && Metadata?.IsValidFormat() == true;
private String SubtractionToString() { return(Op1.ToString() + " - " + Op2.ToString()); }
public override Tipo GetTipo(Entorno e) { if (!(Op1 is Operacion) && !(Op2 is Operacion)) { Tipo tip1 = Op1.GetTipo(e); Tipo tip2 = Op2.GetTipo(e); if (tip1 != Tipo.NULL && tip2 != Tipo.NULL) { if ((tip1 == Tipo.ENTERO || tip1 == Tipo.DECIMAL) && (tip2 == Tipo.ENTERO || tip2 == Tipo.DECIMAL)) { Object val1 = Op1.GetValor(); Object val2 = Op2.GetValor(); try { switch (Op) { case Operador.MAS: if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { valor = Convert.ToDouble(val1) + Convert.ToDouble(val2); return(Tipo.DECIMAL); } else { int val = Convert.ToInt32(val1) + Convert.ToInt32(val2); valor = val; return(Tipo.ENTERO); } case Operador.MENOS: if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { valor = Convert.ToDouble(val1) - Convert.ToDouble(val2); return(Tipo.DECIMAL); } else { int val = Convert.ToInt32(val1) - Convert.ToInt32(val2); valor = val; return(Tipo.ENTERO); } case Operador.POR: if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { valor = Convert.ToDouble(val1) * Convert.ToDouble(val2); return(Tipo.DECIMAL); } else { int val = Convert.ToInt32(val1) * Convert.ToInt32(val2); valor = val; return(Tipo.ENTERO); } case Operador.DIVIDIO: if (Convert.ToInt32(val2) != 0) { if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { valor = Convert.ToDouble(val1) / Convert.ToDouble(val2); return(Tipo.DECIMAL); } else { double val = Convert.ToDouble(val1) / Convert.ToDouble(val2); valor = Math.Truncate(val); return(Tipo.ENTERO); } } else { Console.WriteLine("Division entre 0-> linea: " + Op2.Linea + " columna: " + Op2.Columna); return(Tipo.NULL); } case Operador.MODULO: if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { valor = Math.Truncate(Convert.ToDouble(val1) % Convert.ToDouble(val2)); return(Tipo.DECIMAL); } else { double val = Convert.ToDouble(val1) % Convert.ToDouble(val2); valor = Math.Truncate(val); return(Tipo.ENTERO); } } } catch (Exception) { Console.WriteLine("Error, no se puede realizar la operación aritmética. Línea: " + Linea); } } else { Console.WriteLine("Error, no se puede realizar la operación aritmética. Línea: " + Linea); } } } else { Console.WriteLine("Error, se esta usando más de 3 direcciones. Línea: " + Linea); } return(Tipo.NULL); }
public override Operation Substitute(Variable variable, Operation operation) { return(new Arthmetic(Op1.Substitute(variable, operation), Op2.Substitute(variable, operation), OperationType)); }
public Lauren(Op2 op, object parameters) { this.op = op; this.parameters = parameters; }
public void FindUsesAndDefines() { Defines = new List <String>(); Uses = new List <String>(); if (Kind == CStatement.Kinds.Assignment && Op1.Kind == CStatement.OperandKinds.Variable) { Defines.Add(Op1.Name); } else { if (Op1 != null) { List <String> uses = Op1.GetUses(); if (uses != null) { Uses.AddRange(uses); } } } if (Op2 != null) { List <String> uses = Op2.GetUses(); if (uses != null) { Uses.AddRange(uses); } } if (Condition != null) { if (Condition.Op1 != null) { List <String> uses = Condition.Op1.GetUses(); if (uses != null) { Uses.AddRange(uses); } } if (Condition.Op2 != null) { List <String> uses = Condition.Op2.GetUses(); if (uses != null) { Uses.AddRange(uses); } } } if (BranchDestinationRegister != null) { Uses.Add(BranchDestinationRegister); } if (Kind == Kinds.Call) { Defines.AddRange(new String[] { "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" }); if (CalledFunction != null && CalledFunction.ArgCount != -1) { for (int i = 0; i < CalledFunction.ArgCount; i++) { Uses.Add("r" + (i + 3)); } } else { Uses.AddRange(new String[] { "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10" }); } } }
public void CouldAddTwoSeriesWithSameKeys(double expected, SortedMap <int, double> sm1, SortedMap <int, double> sm2) { var count = sm1.Count; var c1 = sm1.GetEnumerator(); var c2 = sm2.GetEnumerator(); //var ds1 = new Deedle.Series<int, double>(sm1.Keys.ToArray(), sm1.Values.ToArray()); //var ds2 = new Deedle.Series<int, double>(sm2.Keys.ToArray(), sm2.Values.ToArray()); Assert.NotNull(c1.Comparer); Assert.NotNull(c2.Comparer); var zipSum = (sm1 + sm2); double actual = 0; var zipCursor = //zipSum.GetAsyncEnumerator(); new Zip <int, double, double, SortedMapCursor <int, double>, SortedMapCursor <int, double> >( c1, c2); //.Map((k, v) => v.Item1 + v.Item2) var op2 = new Op2 <int, double, AddOp <double>, Zip <int, double, double, SortedMapCursor <int, double>, SortedMapCursor <int, double> > >(zipCursor).Source; var zipCursorOp2 = op2.GetEnumerator(); using (Benchmark.Run("Zip", count * 2)) { while (zipCursorOp2.MoveNext()) { actual += zipCursorOp2.CurrentValue; } } Assert.AreEqual(expected, actual); //var zipped = sm1.Zip(sm2, (k, l, r) => l + r); // sm1.Zip(sm2).Map((k, v) => v.Item1 + v.Item2); // //actual = 0; //using (Benchmark.Run("Zip MN Extension", count * 2)) //{ // foreach (var keyValuePair in zipped) // { // actual += keyValuePair.Value; // } //} //Assert.AreEqual(expected, actual); //var zipN = new[] { sm1, sm2 }.Zip((k, varr) => varr[0] + varr[1], true).GetCursor(); //actual = 0; //using (Benchmark.Run("ZipN", count * 2)) //{ // while (zipN.MoveNextAsync()) // { // actual += zipN.CurrentValue; // } //} //Assert.AreEqual(expected, actual); //var zipNOld = new[] { sm1, sm2 }.ZipOld((k, varr) => varr[0] + varr[1]).GetCursor(); //actual = 0; //using (Benchmark.Run("ZipN (old)", count * 2)) //{ // while (zipNOld.MoveNextAsync()) // { // actual += zipNOld.CurrentValue; // } //} //Assert.AreEqual(expected, actual); //zipCursor.Reset(); //actual = 0; //using (Benchmark.Run("Zip MP", count * 2)) //{ // while (zipCursor.MovePrevious()) // { // actual += zipCursor.CurrentValue; // } //} //Assert.AreEqual(expected, actual); //actual = 0; //using (Benchmark.Run("LINQ", count * 2)) //{ // var linq = sm1.Zip(sm2, (l, r) => l.Value + r.Value); // foreach (var d in linq) // { // actual += d; // } //} //Assert.AreEqual(expected, actual); //actual = 0; //using (Benchmark.Run("Deedle", count * 2)) //{ // var sum = ds1 + ds2; // foreach (var v in sum.Values) // ds1.ZipInner(ds2).Values) // { // actual += v; //.Item1 + v.Item2; // } //} //Assert.AreEqual(expected, actual); }