source: comparacioncriptosistemas/field_number.H @ 267b1a7

/*
  Copyright (C) 2015
  Alejandro Mujica (amujica en cenditel.gob.ve)
  José Ángel Contreras (jancontreras en cenditel.gob.ve)
  Antonio Araujo (aaraujo en cenditel.gob.ve)
  Pedro Buitrago (pbuitrago en cenditel.gob.ve)
 
  CENDITEL Fundación Centro Nacional de Desarrollo e Investigación en
  Tecnologías Libres
 
  Este programa es software libre; Usted puede usarlo bajo los términos de la
  licencia de software GPL versión 2.0 de la Free Software Foundation.
 
  Este programa se distribuye con la esperanza de que sea útil, pero SIN
  NINGUNA GARANTÍA; tampoco las implícitas garantías de MERCANTILIDAD o
  ADECUACIÓN A UN PROPÓSITO PARTICULAR.
  Consulte la licencia GPL para más detalles. Usted debe recibir una copia
  de la GPL junto con este programa; si no, escriba a la Free Software
  Foundation Inc. 51 Franklin Street,5 Piso, Boston, MA 02110-1301, USA.
*/

/*
  Este archivo contiene la definición e implementación de una clase tipo
  plantilla para representar números enteros restringidos a un campo finito.

  Creado por:        Alejandro J. Mujica
  Fecha de creación: 
*/


# ifndef FIELD_NUMBER_H
# define FIELD_NUMBER_H

# include <iostream>
# include <typeinfo>

/**
 * Plantilla que representa un número restringido a un campo.
 *
 * @param Number_Type tipo numérico que se va a restringir. Debe ser un tipo
 *                    de los enteros de la biblioteca estándar de C++.
 *
 * @param Field       Tipo de campo a utilizar. El campo debe manejar el mismo
 *                    tipo de número que se usa en esta plantilla.
 *
 * @see               Field.
 *
 * @author Alejandro J. Mujica (amujica en cenditel punto gob punto ve).
 */
template <typename Number_Type, class Field_Type>
class Field_Number
{
  static_assert(std::is_integral<Number_Type>::value,
                "first template argument must be an integral type");

  static_assert(std::is_same<Number_Type, typename Field_Type::number_t>::value,
  "first template argument in Field_Number is not the same type template\
 argument in Field");

public:
  /// Tipo de campo que restringe al número.
  typedef          Field_Type        field_t;  
  /// Tipo de número restringido.
  typedef typename field_t::number_t number_t;

private:
  field_t  field;

  number_t value;

public:
  /// Constructor que funge de paramétrico y por omisión.
  Field_Number(const number_t & _value = number_t(0));

  Field_Number operator + (const Field_Number &);

  Field_Number & operator += (const Field_Number &);

  Field_Number operator - (const Field_Number &);

  Field_Number & operator -= (const Field_Number &);

  Field_Number operator * (const Field_Number &);

  Field_Number & operator *= (const Field_Number &);

  Field_Number operator / (const Field_Number &);

  Field_Number & operator /= (const Field_Number &);

  bool operator == (const Field_Number &) const;

  bool operator != (const Field_Number &) const;

  bool operator ! () const;

  friend std::ostream & operator << (std::ostream & out,
                                     const Field_Number & fn)
  {
    out << (number_t) fn.value;
    return out;
  }

  Field_Number & operator ++ () const;

  Field_Number & operator -- () const;

  /// Operador de casting para el tipo numérico base.
  operator number_t & ()
  {
    return value;
  }
};

template <typename Number_Type, class Field>
Field_Number<Number_Type, Field>::Field_Number(const number_t & _value)
  : field(), value(field(_value))
{
  // Empty
}

template <typename Number_Type, class Field> Field_Number<Number_Type, Field>
Field_Number<Number_Type, Field>::operator + (const Field_Number & fn)
{
  Field_Number ret;
  ret.value = field.sum(value, fn.value);
  return ret;
}

template <typename Number_Type, class Field> Field_Number<Number_Type, Field> &
Field_Number<Number_Type, Field>::operator += (const Field_Number & fn)
{
  *this = *this + fn;
  return *this;
}

template <typename Number_Type, class Field> Field_Number<Number_Type, Field>
Field_Number<Number_Type, Field>::operator - (const Field_Number & fn)
{
  Field_Number ret;
  ret.value = field.sub(value, fn.value);
  return ret;
}

template <typename Number_Type, class Field> Field_Number<Number_Type, Field> &
Field_Number<Number_Type, Field>::operator -= (const Field_Number & fn)
{
  *this = *this - fn;
  return *this;
}

template <typename Number_Type, class Field> Field_Number<Number_Type, Field>
Field_Number<Number_Type, Field>::operator * (const Field_Number & fn)

{
  Field_Number ret;
  ret.value = field.mul(value, fn.value);
  return ret;
}

template <typename Number_Type, class Field> Field_Number<Number_Type, Field> &
Field_Number<Number_Type, Field>::operator *= (const Field_Number & fn)
{
  *this = *this * fn;
  return *this;
}

template <typename Number_Type, class Field> Field_Number<Number_Type, Field>
Field_Number<Number_Type, Field>::operator / (const Field_Number & fn)
{
  Field_Number ret;
  ret.value = field.div(value, fn.value);
  return ret;
}

template <typename Number_Type, class Field> Field_Number<Number_Type, Field> &
Field_Number<Number_Type, Field>::operator /= (const Field_Number & fn)
{
  *this = *this / fn;
  return *this;
}

template <typename Number_Type, class Field> bool
Field_Number<Number_Type, Field>::operator == (const Field_Number & fn) const
{
  return value == fn.value;
}

template <typename Number_Type, class Field> bool
Field_Number<Number_Type, Field>::operator != (const Field_Number & fn) const
{
  return not (*this == fn);
}

template <typename Number_Type, class Field>
bool Field_Number<Number_Type, Field>::operator ! () const
{
  return value == number_t(0);
}

template <typename Number_Type, class Field> Field_Number<Number_Type, Field> &
Field_Number<Number_Type, Field>::operator ++ () const
{
  ++value;
  return *this;
}

template <typename Number_Type, class Field> Field_Number<Number_Type, Field> &
Field_Number<Number_Type, Field>::operator -- () const
{
  --value;
  return *this;
}

# endif // FIELD_NUMBER_H