public void AddNatural(Natural unit) { unit.ID = naturals.Count; naturals.Add(unit.ID, unit); unit.transform.SetParent(NaturalGroup, false); unit.BindCells(true); }
public void TestDeserialization() { Natural n = new Natural(); n.FromWord("4"); Assert.AreEqual(n.value, 4); }
public IEnumerator <Coroutine> LoadNatural(string path) { ClearNaturals(); using (BinaryReader reader = new BinaryReader(File.OpenRead(Path.Combine(path, "natural.dat")))) { int header = reader.ReadInt32(); if (header <= 0) { int counter = reader.ReadInt32(); for (int i = 0; i < counter; i++) { TriCoordinates coord = TriCoordinates.Load(reader); Natural loaded = Natural.Load(reader); if (loaded) { loaded.ID = i; loaded.Location = grid.GetCell(coord); loaded.transform.SetParent(NaturalGroup); AddNatural(loaded); loaded.validateRotation(); } // if (i % Strings.refreshLimit == 0) yield return null; } } else { Debug.LogWarning("Unknown naturals format " + header); } } yield return(null); }
public void DivRem(Natural dividend, Natural divisor) { Natural quotient, remainder; DivRem(dividend, divisor, out quotient, out remainder); dividend.SetValue(quotient); divisor.SetValue(remainder); }
public BindingList <Natural> listarClienteNatural() { BindingList <Natural> lista = new BindingList <Natural>(); Conexion con = new Conexion(); if (con.IsConnected()) { MySqlCommand comando = new MySqlCommand(); comando.CommandType = System.Data.CommandType.StoredProcedure; comando.CommandText = "LISTAR_CLIENTE_NATURAL"; comando.Connection = con.Connection; MySqlDataReader reader = comando.ExecuteReader(); while (reader.Read()) { Natural n = new Natural(); n.ApMat = reader.GetString("AP_MATERNO"); n.ApPat = reader.GetString("AP_PATERNO"); n.Direccion = reader.GetString("DIRECCION"); n.Dni = reader.GetString("DNI"); n.Email = reader.GetString("EMAIL"); n.FechaNac = (DateTime)reader.GetMySqlDateTime("FECHA_NACIMIENTO"); n.IdPersona = reader.GetInt32("ID_PERSONA").ToString(); n.Nombre = reader.GetString("NOMBRE"); n.Sexo = reader.GetChar("SEXO"); n.Telefono = reader.GetString("TELEFONO"); lista.Add(n); } con.Close(); } return(lista); }
public void DivisionTest() { Natural.DefaultNumberSize = defnumsize; foreach (ulong l in samples) { foreach (ulong r in samples) { Natural ll = new Natural(l); Natural rr = new Natural(r); BigInteger bl = new BigInteger(l); BigInteger br = new BigInteger(r); if (r == 0) continue; BigInteger resb = bl / br; BigInteger resn = (BigInteger)(ll / rr); if (resb != resn) Debugger.Break(); Assert.AreEqual(resb, resn); } } }
protected void btnEliminar_Click(object sender, EventArgs e) { try { Cliente clienteNatural = new Cliente(txtEliminar.Text); if (clienteNatural != null) { Natural personaNatural = new Natural(txtEliminar.Text); Telefono telefono = new Telefono(); List <Telefono> listaTelefono = telefono.Leer(clienteNatural); CorreoElectronico correo = new CorreoElectronico(clienteNatural.CodigoCorreoElectronico); foreach (Telefono numero in listaTelefono) { numero.Eliminar(); } personaNatural.Eliminar(); clienteNatural.Eliminar(); correo.Eliminar(); ScriptManager.RegisterStartupScript(this, this.GetType(), "alert", "alert('la persona ha sido eliminada');" + "window.location ='Clientes_Admin.aspx';", true); } else { ScriptManager.RegisterStartupScript(this, this.GetType(), "alert", "alert('La persona no existe');", true); } } catch (Exception ex) { Session["mensajeError"] = "Ha ocurrido un error con la base de datos. " + ex; ScriptManager.RegisterStartupScript(this, this.GetType(), "alert", "alert('No hay conexión con la base de datos');", true); } }
public int registrarClienteNatural(Natural c) { Conexion con = new Conexion(); if (con.IsConnected()) { MySqlCommand comando = new MySqlCommand(); comando.CommandType = System.Data.CommandType.StoredProcedure; comando.CommandText = "REGISTRAR_CLIENTE_NATURAL"; comando.Connection = con.Connection; comando.Parameters.Add("_NOMBRE", MySqlDbType.VarChar).Value = c.Nombre; comando.Parameters.Add("_DNI", MySqlDbType.VarChar).Value = c.Dni; comando.Parameters.Add("_AP_PATERNO", MySqlDbType.VarChar).Value = c.ApPat; comando.Parameters.Add("_AP_MATERNO", MySqlDbType.VarChar).Value = c.ApMat; comando.Parameters.Add("_SEXO", MySqlDbType.VarChar).Value = c.Sexo; comando.Parameters.Add("_FECHA_NAC", MySqlDbType.Date).Value = c.FechaNac; comando.Parameters.Add("_TELEFONO", MySqlDbType.VarChar).Value = c.Telefono; comando.Parameters.Add("_EMAIL", MySqlDbType.VarChar).Value = c.Email; comando.Parameters.Add("_DIRECCION", MySqlDbType.VarChar).Value = c.Direccion; comando.Parameters.Add("_ID_PERSONA", MySqlDbType.Int32).Direction = System.Data.ParameterDirection.Output; int check = comando.ExecuteNonQuery(); con.Close(); if (check == 1) { return(Int32.Parse(comando.Parameters["_ID_PERSONA"].Value.ToString())); } else { return(0); } } return(-1); }
public void Add(Natural x, Natural y) { int length = Math.Max(x.usedDigits, y.usedDigits); x.PushLength(length + 1); y.PushLength(length); // Expand so we know we can index those digits Digit carry = 0; for (int i = 0; i < length; i++) { Carry res = (Carry)x.digits[i] + y.digits[i] + carry; Digit val; if (res > Digit.MaxValue) { carry = 1; val = (Digit)(res - Digit.MaxValue - 1); } else { carry = 0; val = (Digit)res; } x.digits[i] = val; } x.digits[length] = carry; x.usedDigits = length + (int)carry; // If carry == 1 we used another extra digit x.PopLength(); y.PopLength(); }
public void TestAddition() { Natural n1 = new Natural(1), n2 = new Natural(2); Assert.AreEqual(new NaturalSemiring().Add(n1, n2).value, 3); }
public void AddTest() { Natural.DefaultNumberSize = defnumsize; foreach (ulong l in samples) { foreach (ulong r in samples) { Natural ll = new Natural(l); Natural rr = new Natural(r); BigInteger bl = new BigInteger(l); BigInteger br = new BigInteger(r); Assert.AreEqual(bl + br, (BigInteger)(ll + rr)); } } for (int i = 2; i < 10; i++) { for (int p = 32; p < 256; p += 12) { BigInteger b = BigInteger.Pow(i, p); BigInteger l = BigInteger.Pow(i + 1, p - 1) * 7; BigInteger r = b + l; Natural n = (Natural)b + (Natural)l; Assert.AreEqual(r, (BigInteger)n); } } }
//1,3 public static bool Test(ulong exponent, ref ulong startI, ref Natural startS, List <ulong> primes) { if (!DLib.Math.Prime.Test.Probabilistic.Division(exponent, primes, 3, (ulong)System.Math.Sqrt(exponent) + 1)) { return(false); } lock (primes) { int i = primes.Count; for (; i > 0 && primes[i - 1] > exponent; i--) { ; } if (i > 0 && primes[i - 1] != exponent) { primes.Insert(i, exponent); } } if ((exponent & 3) == 3 && DLib.Math.Prime.Test.Probabilistic.Division((exponent << 1) + 1, primes, 3, (ulong)System.Math.Sqrt((exponent << 1) + 1) + 1)) { return(false); } Natural mersenneNumber = MersenneNumber((int)exponent); return(TrialDivision(exponent, mersenneNumber, primes) && LucasLehmerTest(exponent, mersenneNumber, ref startI, ref startS)); }
public void Multiply(Natural factor1, Natural factor2) { if (factor1 == 0 || factor2 == 0) { factor1.SetValue(Natural.Zero); } else if (factor2 == 1) { // factor1 = factor1 (jupp, that's the only optimization) } else { Natural product = Natural.Zero; for (int i = 0; i < factor1.usedDigits; i++) { Digit d = factor1.digits[i]; Natural partial = MulDigit(factor2, d); Natural.ShiftLeft(partial, i); Natural.Add(product, partial); } factor1.SetValue(product); } }
public List <Natural> AutocompleteCliente() { List <Natural> Listado = null; Natural Entidad = null; SqlDataReader lector; conexion.Open(); string query = "SELECT CONCAT(nComercial,' - ',ruc) autocomplete FROM Cli_Juridico "; query += "UNION "; query += "SELECT CONCAT(nombre,' ',apepat,' ',apemat,' - ',dni) autocomplete FROM Cli_Natural "; SqlCommand comando_val = new SqlCommand(query, conexion); lector = comando_val.ExecuteReader(); if (lector.HasRows) { Listado = new List <Natural>(); while (lector.Read()) { Entidad = new Natural(); Entidad.autocomplete = lector["autocomplete"].ToString(); Listado.Add(Entidad); } } conexion.Close(); return(Listado); }
public void Multiply(Natural factor1, Natural factor2) { if (factor1 == Natural.Zero || factor2 == Natural.Zero) { factor1.SetValue(Natural.Zero); } else if (factor1 == Natural.One) { factor1.SetValue(factor2); } else { Natural increase = factor1.Clone(); Natural decrease = factor2.Clone(); factor1.PushLength(factor1.usedDigits * factor2.usedDigits); while (decrease > 1) // We already have 1 factor1 { Natural.Add(factor1, increase); Natural.Decrement(decrease); } factor1.PopLength(); } }
public void TestMultiplication() { Natural n1 = new Natural(2), n2 = new Natural(3); Assert.AreEqual(new NaturalSemiring().Multiply(n1, n2).value, 6); }
public List <Natural> ListarEstado() { List <Natural> Listado = null; Natural Entidad = null; SqlDataReader lector; //Abrimos conexión conexion.Open(); //Creamos un sqlCommand junto con el query para poder consultar a la bd. string query = "SELECT id_estado, estado FROM Estados"; SqlCommand comando_val = new SqlCommand(query, conexion); lector = comando_val.ExecuteReader(); if (lector.HasRows) { Listado = new List <Natural>(); while (lector.Read()) { Entidad = new Natural(); Entidad.id_estado = int.Parse(lector["id_estado"].ToString()); Entidad.estado_descripcion = lector["estado"].ToString(); Listado.Add(Entidad); } } //Despues, cerramos la conexion! conexion.Close(); //Retorna el listao lleno de datos return(Listado); }
public void Subtract(Natural minuend, Natural subtrahend) { /* * If y is zero, return x * If x is larger than y, use Sub1 * If x is smaller than y, would return negative * If x == y, set x to 0 and return x */ if (subtrahend == 0) { } else if (minuend > subtrahend) { int digits = minuend.usedDigits; Natural.Complement(Natural.Add(Natural.Complement(minuend), subtrahend), digits); } else if (minuend < subtrahend) { throw new InvalidOperationException(Resources.Strings.WouldBeNegative); } else { minuend.Clear(); } }
void Shorten() { Natural gcd = Natural.GCD(Denominator, (Natural)Numerator); Numerator /= gcd; Denominator /= gcd; }
public void Subtract(Natural minuend, Natural subtrahend, out Natural difference) { int cmp = minuend.CompareTo(subtrahend); if (cmp < 0) { throw new InvalidOperationException(Resources.Strings.WouldBeNegative); } else if( cmp == 0) { difference = Natural.Zero; } else { IndexedArraySegment<Digit> digits = new Digit[minuend.usedDigits]; int carry = 0; int msd = 0; for (int i = 0; i < minuend.usedDigits; i++) { long diff = (long)minuend.digits[i] - subtrahend.digits[i] - carry; if (diff < 0) // Need to borrow from next { diff = diff + Digit.MaxValue + 1; carry = 1; digits[i] = (Digit)diff; } else if (diff > 0) { digits[i] = (Digit)diff; carry = 0; msd = i; } } difference = new Natural(digits, msd + 1); } }
public void NumberTheory_Basic_Test() { var natural = new Natural(9); var relative_natural = new Natural(38); var valid_natural = new Natural(36); int relativelyprime = 1, gcd = 9, lcm = 342; Natural actual; actual = natural.Gcd(relative_natural); //actual = relative_natural.Gcd(natural); Assert.AreEqual(relativelyprime, actual.GetIntValue()); Console.WriteLine("Relatively Prime (38,9): " + actual.GetIntValue()); natural = new Natural(9); var IsRelativelyPrime = natural.IsRelativelyPrimeTo(relative_natural); Assert.AreEqual(true, IsRelativelyPrime); Console.WriteLine("Relatively Prime (38,9): " + IsRelativelyPrime); natural = new Natural(0); var IsPrime = natural.IsPrime(); Console.WriteLine("Is 38 Prime?: " + IsPrime); natural = new Natural(9); actual = natural.Lcm(relative_natural); Assert.AreEqual(lcm, actual.GetIntValue()); Console.WriteLine("Valid LCM (38,9): " + actual.GetIntValue()); natural = new Natural(9); actual = natural.Gcd(valid_natural); Assert.AreEqual(gcd, actual.GetIntValue()); Console.WriteLine("Valid GCD (36,9): " + actual.GetIntValue()); }
public void Multiply(Natural factor1, Natural factor2, out Natural product) { if (factor1 == Natural.Zero || factor2 == Natural.Zero) { product = Natural.Zero; } else if (factor1 == Natural.One) { product = factor2.Clone(); } else { Natural counter = factor2.Clone(); product = factor1.Clone(); product.PushLength(factor1.usedDigits * factor2.usedDigits); while (counter > 1) // We already have 1 factor1 { Natural.Add(product, factor1); Natural.Decrement(counter); } product.PopLength(); } }
public void RemoveNatural(int id) { Natural unit = naturals[id]; Destroy(unit.gameObject); naturals.Remove(id); }
public void Multiply(Natural factor1, Natural factor2, out Natural product) { if (factor1 == 0 || factor2 == 0) { product = Natural.Zero; } else if (factor2 == 1) { product = factor1.Clone(); } else { product = Natural.Zero; for (int i = 0; i < factor1.usedDigits; i++) { Digit d = factor1.digits[i]; Natural partial = MulDigit(factor2, d); Natural.ShiftLeft(partial, i); Natural.Add(product, partial); } } }
static void Main() { var e1 = Natural.Create(100); int n; e1.Increment(); e1.GetNumber(out n); }
public AI(Character IAM) { intensity = Ferocity.Balanced; perferredTarget = Target.Any; state = Natural.Balanced; intelligence = Intelligence.Normal; owner = IAM; }
public Integer(Natural x) { sign = 0; magnitude = x; if (magnitude > 0) sign = 1; }
public static Natural ToNatural(this long num) { if (num < 0) throw new ArgumentOutOfRangeException("num"); var retVal = Natural.Zero; for (long i = 0; i < num; i++) retVal = new Natural(retVal); return retVal; }
protected void btnGuardarCambios(object sender, EventArgs e) { try { int CodLug1 = this.CodLugar(dplParroquia, dplMunicipio, dplEstado); Lugar lugar = new Lugar(CodLug1); Natural ClienteNatural = new Natural(dplRif.SelectedValue + txtRif.Text); CorreoElectronico ctrlCorreo = new CorreoElectronico(ClienteNatural.CodigoCorreoElectronico); ctrlCorreo.Direccion = txtCorreo.Text; ctrlCorreo.Actualizar(); //Cliente datosCliente = new Cliente(dplRif.SelectedValue + txtRif.Text, txtContraseña.Text, ctrlCorreo, null); //datosCliente.Actualizar(); ClienteNatural.Password = txtContraseña.Text; ClienteNatural.Cedula = dplCedula.SelectedValue + txtCedula.Text; ClienteNatural.Nombre1 = Nombre1.Text; ClienteNatural.Nombre2 = Nombre2.Text; ClienteNatural.Apellido1 = Apellido1.Text; ClienteNatural.Apellido2 = Apellido2.Text; ClienteNatural.Direccion = lugar.Codigo; //Natural natural = new Natural(dplRif.SelectedValue + txtRif.Text, txtContraseña.Text,ctrlCorreo, dplCedula.SelectedValue + txtCedula.Text,Nombre1.Text,Nombre2.Text,Apellido1.Text,Apellido2.Text,lugar); ClienteNatural.Actualizar(); Telefono telefono = new Telefono(); List <Telefono> telefonos = telefono.Leer(ClienteNatural); Telefono telefono1 = new Telefono(int.Parse(CodigoPais1.SelectedValue), int.Parse(CodAre.Text), int.Parse(txtTelefono1.Text), TipoTelf.Text, ClienteNatural); Telefono telefono2 = new Telefono(int.Parse(CodigoPais2.SelectedValue), int.Parse(CodAre2.Text), int.Parse(txtTelefono2.Text), TipoTelf2.Text, ClienteNatural); if (!VerificarCambiosTelefono(telefonos[0], telefono1)) { telefonos[0].Eliminar(); telefono1.Insertar(); } if (!VerificarCambiosTelefono(telefonos[1], telefono2)) { telefonos[1].Eliminar(); telefono2.Insertar(); } //Response.Redirect("/Views/Clientes_Admin.aspx", false); ScriptManager.RegisterStartupScript(this, this.GetType(), "alert", "alert('El cliente se ha sido modificado exitosamente');" + "window.location ='Clientes_Admin';", true); } catch (Exception ex) { Session["mensajeError"] = "Ha ocurrido un error al modificar el cliente natural. " + ex; ScriptManager.RegisterStartupScript(this, this.GetType(), "alert", "alert('NO DEBE HABER CAMPOS VACÍOS');", true); } }
public static void Integers() { Natural n1 = 5; Integer n2 = -10; Integer itg = n1 - (int)n2; Console.WriteLine(itg); }
/// <summary> /// /// </summary> /// <param name="a"></param> /// <param name="b"></param> /// <returns>a < b: - 1; a == b: 0; a > b: == 1</b></returns> public static int Compare(Integer a, Integer b) { int i = Natural.Compare(a.Abs(), b.Abs()); if (i == 0 && a.IsZero()) { return(0); } return((a.Positive ? 1 : -1) * (a.Positive != b.Positive ? 1 : i)); }
public static Integer Parse(string value, bool positive = true, bool hex = false) { if (!hex && !Regex.IsMatch(value, @"^-?[0-9]+$") || hex && !Regex.IsMatch(value, @"^-?[0-9a-fA-F]+$")) { throw new ArgumentException($"String was not in correct format: {value}."); } return(value.StartsWith("-") ? new Integer(Natural.Parse(value.Substring(1)), false) : new Integer(Natural.Parse(value), positive)); }
public Integer(string value, bool hex = true) { if (value.StartsWith("-")) { Positive = false; value = value.Substring(1); } Absolute = new Natural(value, hex); }
public static Integer Pow(Integer b, Natural exp) { Integer result = 1; for (Integer i = 0; i < exp; i++) { result *= b; } return(result); }
/// <summary> /// Выбор минимального значения /// </summary> static Natural Min(Natural N1, Natural N2) { if (N_1.Run(N1, N2) == 2) { return(N1); } else { return(N2); } }
public void Addition_Test() { var natural1 = new Natural(Int32.MaxValue); var natural2 = new Natural(Int64.MaxValue); bool expected = true; var actual = natural1.Add(natural2); Assert.AreEqual(expected, (actual.GetBigValue() > Int64.MaxValue)); Console.WriteLine("The Big Integer sum is: " + actual.GetBigValue()); }
static void Main(string[] args) { Func <int, int> sqr = capturedVar => capturedVar * capturedVar; // Single-treaded for loop is easy for (int i = 1; i <= 5; i++) { int outerVar = i; // struct/ValueType make a copy on assignment. delegate/lambda may change it! Console.WriteLine(sqr(outerVar)); // outerVar is a captured variable, lambda expression sqr is a closure } Action[] actions = new Action[3]; for (int i = 0; i < actions.Length; i++) { // each closure catches the same 'i' variable actions[i] = () => Console.Write(i); } foreach (var action in actions) { action(); // 333 } Console.WriteLine(); for (int i = 0; i < actions.Length; i++) { int localScopedVar = i; // each closure captures a fresh localScopedVar actions[i] = () => Console.Write(localScopedVar); } foreach (var action in actions) { action(); // 012 } Console.WriteLine(); for (int i = 0; i < 3; i++) { var f = Natural(); Console.WriteLine($"{f()} \t{Natural()()}"); } }
public void Division_Algorithm_Test() { var natural = new Natural(158); var natural2 = new Natural(17); var actual = natural.DivisionAlgorithm(natural2); Console.WriteLine("The Division Algorithm of {0} / {1} is: " + actual, natural, natural2); natural = new Natural(int.MaxValue); natural2 = new Natural(86340); actual = natural.DivisionAlgorithm(natural2); Console.WriteLine("The Division Algorithm of {0} / {1} is: " + actual, natural, natural2); }
public void Domain_Exception_Test() { try { var negative_natural = new Natural(-5); } catch (ArgumentException e) { Console.WriteLine(e); throw; } }
public bool RegistrarCliente(Natural cli) { //AQUI ELK PROFE APLICO LA MANIPULACION DE TRY CATCH!, APLICAR A TODO DE LA CAP NEGOCIO try { var aux = clienteDatos.RegistrarCliente(cli); return(true); } catch (Exception) { return(false); } }
public void Prime_Test() { var val = new Natural(199); var exponent = new Natural(7); var modulo = new Natural(3); var expected = true; var actual = val.IsPrime(); Assert.AreEqual(expected, actual); Console.WriteLine("The value of expected {0} vs actual: " + actual, expected); }
public void Mod_Test() { var val = new Natural(52); var exponent = new Natural(7); var modulo = new Natural(3); var expected = BigInteger.ModPow(52, 7, 3); var actual = val.ModPow(exponent, modulo); Assert.AreEqual(expected, actual.GetBigValue()); Console.WriteLine("The value of expected {0} vs actual: " + actual.GetBigValue(), expected); }
private static Natural MulDigit(Natural x, Digit y) { Natural total = 0; for (int i = 0; i < x.usedDigits; i++) { Natural partial = (Carry)x.digits[i] * y; Natural.ShiftLeft(partial, i); Natural.Add(total, partial); } return total; }
public void DivRem(Natural dividend, Natural divisor, out Natural quotient, out Natural remainder) { if (divisor == 0) throw new DivideByZeroException(); dividend = dividend.Clone(); quotient = 0; while (dividend >= divisor) { Natural.Subtract(dividend, divisor); Natural.Increment(quotient); } remainder = dividend; }
private void InternalDivRem(Natural dividend, Natural divisor, out Natural quotient, out Natural remainder) { int dcmp = dividend.CompareTo(divisor); if (dcmp == 0) { quotient = Natural.One; remainder = Natural.Zero; } else if (dcmp < 0) // dividend < divisor { quotient = Natural.Zero; remainder = dividend.Clone(); // Do we have to clone? } else // dividend > divisor { Natural modifiedDivisor = divisor.Clone(); Natural subquotient = Natural.One; long bitshifts = Natural.Log2(dividend) - Natural.Log2(modifiedDivisor); // Gets how many factors of two from divisor to dividend Natural.BitShiftLeft(modifiedDivisor, bitshifts); // Shifts divisor that many times (multiply by 2^bitshifts) Natural.BitShiftLeft(subquotient, bitshifts); int cmp = dividend.CompareTo(modifiedDivisor); if (cmp < 0) // Dividend < modifiedDivisors - shifted 1 too much { Natural.BitShiftRight(subquotient, 1); // Divide by 2 to get the right quotient Natural.BitShiftRight(modifiedDivisor, 1); } else if (cmp == 0) // Divisor equal to dividend! { quotient = subquotient; remainder = Natural.Zero; return; } // dividend > modifiedDivisor Natural newDividend = Natural.Subtract(dividend, modifiedDivisor); // Optimize away the clone (put this in private function - clone up front) InternalDivRem(newDividend, divisor, out quotient, out remainder); // Repeat division on difference between dividend and modifiedDivisor Natural.Add(quotient, subquotient); // Add the quotient we calculated in this iteration } }
public void DivisionTest() { Natural.DefaultNumberSize = 4; foreach (ulong l in samples) { foreach (ulong r in samples) { Natural ll = new Natural(l); Natural rr = new Natural(r); BigInteger bl = new BigInteger(l); BigInteger br = new BigInteger(r); if (r == 0) continue; Assert.AreEqual(bl / br, (BigInteger)(ll / rr)); } } }
public void Add(Natural addend1, Natural addend2, out Natural sum) { sum = addend1.Clone(); Add(sum, addend2); }
public INaturalMultiplier GetMultiplier(Natural n1, Natural n2) { return GetDefaultMultiplier(); }
public void Subtract(Natural minuend, Natural subtrahend) { Natural difference; Subtract(minuend, subtrahend, out difference); minuend.SetValue(difference); }
public INaturalSubtracter GetSubtracter(Natural n1, Natural n2) { return GetDefaultSubtracter(); }
public void MultiplyTest() { Natural.DefaultNumberSize = defnumsize; foreach (ulong l in samples) { foreach (ulong r in samples) { Natural ll = new Natural(l); Natural rr = new Natural(r); BigInteger bl = new BigInteger(l); BigInteger br = new BigInteger(r); BigInteger bres = bl * br; BigInteger nres = (BigInteger)(ll * rr); Debug.WriteLine("{0:X} * {1:X} = {2:X} = {3:X}", l, r, bres, nres); Assert.AreEqual(bres, nres); } } Natural pow = 1; BigInteger bi = BigInteger.Pow(2147483647, 5); pow *= 2147483647; pow *= 2147483647; pow *= 2147483647; pow *= 2147483647; pow *= 2147483647; if (bi != (BigInteger)pow) Assert.Fail("Pow. Got {0}, should be {1}", (BigInteger)pow, bi); }
public void Subtract(Natural minuend, Natural subtrahend, out Natural difference) { difference = minuend.Clone(); Subtract(difference, subtrahend); }
public void LargeNumTest() { Natural.DefaultNumberSize = defnumsize; int[] powers = { 0, 1, 2, 3, 4, 5 }; foreach (ulong l in samples) { foreach (int p in powers) { Natural ll = new Natural(l); BigInteger bl = new BigInteger(l); BigInteger rs = (BigInteger)Natural.Pow(ll, p); Assert.AreEqual(BigInteger.Pow(bl, p), rs); } } }
public void DivRem(Natural dividend, Natural divisor, out Natural quotient, out Natural remainder) { InternalDivRem(dividend.Clone(), divisor, out quotient, out remainder); }
public void SubtractTest() { Natural.DefaultNumberSize = defnumsize; foreach (ulong l in samples) { foreach (ulong r in samples) { if (r > l) continue; Natural ll = new Natural(l); Natural rr = new Natural(r); BigInteger bl = new BigInteger(l); BigInteger br = new BigInteger(r); Assert.AreEqual(bl - br, (BigInteger)(ll - rr)); } } }
public void Remainder(Natural dividend, Natural divisor, out Natural remainder) { Natural quotient; DivRem(dividend, divisor, out quotient, out remainder); }
public Integer() { sign = 0; magnitude = 0; }
public INaturalDivider GetDivider(Natural n1, Natural n2) { return GetDefaultDivider(); }
public INaturalAdder GetAdder(Natural n1, Natural n2) { return GetDefaultAdder(); }
public void ToStringTest() { Natural.DefaultNumberSize = defnumsize; foreach (ulong l in samples) { Natural n = new Natural(l); BigInteger b = new BigInteger(l); string s = n.ToString(); Assert.AreEqual(BigInteger.Parse(s), b); } }