//Botton "Export Data"
private void button1_Click(object sender, RibbonControlEventArgs e)
{
try
{
int START_ROW = 9;
int START_COL = 3;
Excel.Worksheet active_worksheet = Globals.ThisAddIn.Application.ActiveSheet;
//Acquire Target Data and Export
Target TargetData = new Target();
TargetData.GetData(active_worksheet);
TargetData.ExportData();
//Acquire Comparable Data and Export
for (int col_index = START_COL; active_worksheet.Cells[START_ROW, col_index].Value != null ; col_index ++)
{
Comparable comparable_data = new Comparable();
comparable_data.GetData(active_worksheet, START_ROW, col_index);
comparable_data.ExportData();
}
MessageBox.Show("Successfully export data.");
}
catch (Exception exception)
{
Debug.WriteLine(exception.ToString());
}
}
public Comparable minimo()
{
Comparable minimo = this.pila[0];
for (int i = 0; i < this.cuantos(); i++)
{
if (this.pila[i].sosMenor(minimo))
{
minimo = this.pila[i];
}
}
return(minimo);
}
public bool contiene(Comparable obj)
{
bool existe = false;
foreach (Comparable elemento in datos)
{
if (comparador.esIgual((Comparable)elemento, (Comparable)obj))
{
existe = true;
}
}
return(existe);
}
public bool pertenece(Comparable obj)
{
bool existe = false;
foreach (Comparable elemento in datos)
{
if (elemento.sosIgual(obj))
{
existe = true;
}
}
return(existe);
}
public Comparable mayor()
{
Comparable maximo = this.datos[0];
foreach (Comparable elemento in datos)
{
if (comparador.esMayor((ClaveValor)elemento, (ClaveValor)maximo))
{
maximo = elemento;
}
}
return(maximo);
}
public void UnlessGtHelper_renders_expected_result_when_not_greater()
{
var one = new Comparable {
Thing = "a"
};
var two = new Comparable {
Thing = "b"
};
var result = Render.StringToString("{{#unless_gt one compare=two}}less{{/unless_gt}}", new { one, two });
result.Should().Be("less");
}
public void IfGtHelper_renders_inverse_when_not_greater()
{
var one = new Comparable {
Thing = "a"
};
var two = new Comparable {
Thing = "b"
};
var result = Render.StringToString("{{#if_gt one compare=two}}greater{{else}}less{{/if_gt}}", new { one, two });
result.Should().Be("less");
}
public void IfGtHelper_renders_expected_result_when_not_greater()
{
var one = new Comparable {
Thing = "a"
};
var two = new Comparable {
Thing = "b"
};
var result = Render.StringToString("{{#if_gt one compare=two}}greater{{/if_gt}}", new { one, two });
result.Should().BeEmpty();
}
public void UnlessGtEqHelper_renders_expected_result_when_equal()
{
var one = new Comparable {
Thing = "a"
};
var two = new Comparable {
Thing = "a"
};
var result = Render.StringToString("{{#unless_gteq one compare=two}}less{{/unless_gteq}}", new { one, two });
result.Should().BeEmpty();
}
public void IfGtEqHelper_renders_expected_result_when_equal()
{
var one = new Comparable {
Thing = "a"
};
var two = new Comparable {
Thing = "a"
};
var result = Render.StringToString("{{#if_gteq one compare=two}}greater{{/if_gteq}}", new { one, two });
result.Should().Be("greater");
}
public Comparable mayor()
{
Comparable maximo = datos[0];
foreach (Comparable elemento in datos)
{
if (((Comparable)elemento).sosMayor(maximo))
{
maximo = elemento;
}
}
return(maximo);
}
/// <summary> Remove the smallest item from the priority queue.</summary>
/// <returns> the smallest item, or null, if empty.
/// </returns>
public virtual Comparable deleteMin()
{
if (Empty)
{
return(null);
}
Comparable minItem = findMin();
array[1] = array[currentSize--];
percolateDown(1);
return(minItem);
}
public Comparable minimo()
{
Comparable minPila = this.pila.minimo();
Comparable minCola = this.cola.minimo();
if (minPila.sosMenor(minCola))
{
return(minPila);
}
else
{
return(minCola);
}
}
/// <summary> Insert into the priority queue, and return a PairNode
/// that can be used by decreaseKey.
/// Duplicates are allowed.
/// </summary>
/// <param name="x">the item to insert.
/// </param>
/// <returns> the node containing the newly inserted item.
/// </returns>
public virtual PairNode insert(Comparable x)
{
PairNode newNode = new PairNode(x);
if (root == null)
{
root = newNode;
}
else
{
root = compareAndLink(root, newNode);
}
return(newNode);
}
public bool contiene(Comparable comparable)
{
bool tienepila = this.pila.contiene(comparable);
bool tienecola = this.cola.contiene(comparable);
if (tienepila || tienecola)
{
return(true);
}
else
{
return(false);
}
}
public override void Write(byte[] buffer, int offset, int count)
{
if (count > _available)
{
throw new InvalidOperationException("Exceeded write operation limit.");
}
if (_available > 0 && count > 0)
{
int write = (int)Comparable.Min(_available, count);
_stream.Write(buffer, offset, write);
_available -= write;
}
}
public Comparable maximo()
{
Comparable maxPila = this.pila.maximo();
Comparable maxCola = this.cola.maximo();
if (maxPila.sosMayor(maxCola))
{
return(maxPila);
}
else
{
return(maxCola);
}
}
public bool pertenece(Comparable comparable)
{
bool existeElemento = false;
for (int i = 0; i < this.conjunto.Count; i++)
{
if (this.conjunto[i].sosIgual(comparable))
{
existeElemento = true;
}
}
return(existeElemento);
}
public void UnlessLtEqHelper_renders_inverse_when_not_less()
{
var one = new Comparable {
Thing = "a"
};
var two = new Comparable {
Thing = "b"
};
var result = Render.StringToString("{{#unless_lteq one compare=two}}less{{else}}less{{/unless_lteq}}",
new { one, two });
result.Should().Be("less");
}
public void Agregar(object valor, Comparable clave)
{
ClaveValor claveValor = new ClaveValor(valor, clave);
foreach (Comparable a in conjunto.getConjunto())
{
if (((ClaveValor)a).sosIgual(claveValor))
{
((ClaveValor)a).setValor(valor);
break;
}
}
conjunto.agregar(claveValor);
}
public void IfLtHelper_throws_when_not_comparable()
{
var one = new Comparable {
Thing = "a"
};
var two = new Incomparable {
Thing = "b"
};
Action action =
() => Render.StringToString("{{#if_lt one compare=two}}less{{else}}less{{/if_lt}}", new { one, two });
action.ShouldThrow <InvalidOperationException>().WithMessage(
"The objects being compared must implement IComparable.");
}
public Comparable maximo()
{
Comparable maximo = this.cola[0];
{
for (int i = 0; i < this.cuantos(); i++)
{
if (this.cola[i].sosMayor(maximo))
{
maximo = this.cola[i];
}
}
}
return(maximo);
}
public void agregar(Comparable comparable)
{
this.Agregar(comparable, clave = new Numero(((Numero)clave).getValor() + 1));
if (this.cuantos() == 1 & this.ordenInicio != null)
{
this.ordenInicio.ejecutar();
}
if (this.ordenLlegaAlumno != null)
{
this.ordenLlegaAlumno.ejecutar(comparable);
}
if (this.cuantos() == 40 & this.ordenEnAulaLlena != null)
{
this.ordenEnAulaLlena.ejecutar();
}
}
public bool contiene(Comparable obj)
{
bool existe = false;
if (this.datos.Count > 0)
{
foreach (Comparable elemento in datos)
{
if (comparador.esIgual(elemento, obj))
{
existe = true;
}
}
}
return(existe);
}
public int CompareTo(TNode other, Comparable <TNode> compare)
{
if (compare == null && other is IComparable <TNode> )
{
IComparable <TNode> value = other as IComparable <TNode>;
return(value.CompareTo(Value));
}
else if (compare != null)
{
return(compare.Invoke(other, Value));
}
else
{
throw new ComparatorHasNotBeenFoundException("Comparator has not been found check it and try again.");
}
}
/// <summary> Insert into the priority queue, maintaining heap order.
/// Duplicates are allowed.
/// </summary>
/// <param name="x">the item to insert.
/// </param>
/// <exception cref="Overflow">if container is full.
/// </exception>
public virtual void insert(Comparable x)
{
if (Full)
{
throw new Overflow();
}
// Percolate up
int hole = ++currentSize;
for (; hole > 1 && x.compareTo(array[hole / 2]) < 0; hole /= 2)
{
array[hole] = array[hole / 2];
}
array[hole] = x;
}
public void agregar(Comparable parametro)
{
this.pila.Add(parametro);
if (this.cuantos() == 1 & this.ordenInicio != null)
{
this.ordenInicio.ejecutar();
}
if (this.ordenLlegaAlumno != null)
{
this.ordenLlegaAlumno.ejecutar(parametro);
}
if (this.cuantos() == 43 & this.ordenEnAulaLlena != null)
{
this.ordenEnAulaLlena.ejecutar();
}
}
public static void informar(Coleccionable <Comparable> coleccionable, int queComparable)
{
Console.WriteLine("----------INFORMAR----------");
Console.WriteLine("La {0} posee {1} elementos.", coleccionable.ToString(), coleccionable.cuantos());
Console.WriteLine("Minimo >> " + (coleccionable.minimo()));
Console.WriteLine("Maximo >> " + (coleccionable.maximo()));
Comparable comparable = FabricaDeComparables.crearPorTeclado(queComparable);
if (coleccionable.contiene(comparable))
{
Console.WriteLine("El elemento leído está en la colección");
}
else
{
Console.WriteLine("El elemento leído NO está en la colección");
}
} //E6
private static void Main(string[] args)
{
Console.WriteLine("F0.Common");
Console.WriteLine();
int integer = GetInteger(args);
Console.WriteLine($"{nameof(integer)} {integer} is {(Parity.IsEven(integer) ? "" : "not ")}even.");
Console.WriteLine($"{nameof(integer)} {integer} is {(Parity.IsOdd(integer) ? "" : "not ")}odd.");
Console.WriteLine();
const int min = -240;
const int max = +240;
Console.WriteLine($"{nameof(integer)} {integer} clamped to the inclusive range of {min} and {max}:");
Console.WriteLine(Comparable.Clamp(integer, min, max));
}
static void informar(Coleccionable parametro, int opcion)
{
Console.WriteLine("Cantidad de elementos en el coleccionable: {0}", parametro.cuantos());
Console.WriteLine("Elemento mínimo en el coleccionable: {0}", parametro.minimo());
Console.WriteLine("Elemento máximo en el coleccionable: {0}{1}", parametro.maximo(), "\n");
Comparable comparable = Fabrica.crearPorTeclado(opcion);
if (parametro.contiene(comparable))
{
Console.WriteLine("\nEl elemento leido está en la colección.");
}
else
{
Console.WriteLine("\nEl elemento leido no está en la colección.");
}
}
// quicksort the subarray a[lo .. hi] using 3-way partitioning
private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo) return;
int lt = lo, gt = hi;
Comparable v = a[lo];
int i = lo + 1;
while (i <= gt) {
int cmp = a[i].compareTo(v);
if (cmp < 0) exch(a, lt++, i++);
else if (cmp > 0) exch(a, i, gt--);
else i++;
}
// a[lo..lt-1] < v = a[lt..gt] < a[gt+1..hi].
sort(a, lo, lt-1);
sort(a, gt+1, hi);
assert isSorted(a, lo, hi);
}
