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);
}
