/// <summary>
/// Permite fazer a leitura de um vector.
/// </summary>
/// <typeparam name="T">O tipo de elementos do vector.</typeparam>
/// <param name="dimension">A dimensão do vector a ser lido.</param>
/// <param name="vectorText">O texto que representa o vector.</param>
/// <param name="vectorFactory">A fábrica responsável pela criação de vectores.</param>
/// <param name="elementParser">O leitor de elementos.</param>
/// <param name="readNegativeNumbers">Indica se são lidos os números negativos.</param>
/// <returns></returns>
public static IMathVector <T> ReadVector <T>(
int dimension,
string vectorText,
IMathVectorFactory <T> vectorFactory,
IParse <T, string, string> elementParser,
bool readNegativeNumbers = false)
{
var reader = new StringReader(vectorText);
var stringSymbolReader = new StringSymbolReader(reader, readNegativeNumbers);
var arrayVectorReader = new ConfigVectorReader <T, string, string, CharSymbolReader <string> >(
dimension,
vectorFactory);
arrayVectorReader.MapInternalDelimiters("left_bracket", "right_bracket");
arrayVectorReader.AddBlanckSymbolType("blancks");
arrayVectorReader.SeparatorSymbType = "comma";
var vector = default(IMathVector <T>);
if (arrayVectorReader.TryParseVector(stringSymbolReader, elementParser, out vector))
{
return(vector);
}
else
{
throw new Exception("Can't read vector.");
}
}
/// <summary>
/// Cria instâncias de objectos do tipo <see cref="VectorSpace{CoeffType}"/>.
/// </summary>
/// <param name="dimension">A dimensão dos vectoes tratados pelo espaço vectorial.</param>
/// <param name="vectorFactory">A fábrica responsável pela criação de vectores..</param>
/// <param name="field">O corpo responsável pelas operações sobre vectores.</param>
/// <exception cref="ArgumentNullException">
/// Se os argumentos "vectorFactory" ou "field" forem nulos.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">Se a dimensão for um número negativo.</exception>
public VectorSpace(
int dimension,
IMathVectorFactory <CoeffType> vectorFactory,
IField <CoeffType> field)
{
if (field == null)
{
throw new ArgumentNullException("field");
}
else if (vectorFactory == null)
{
throw new ArgumentNullException("vectorFactory");
}
else if (dimension < 0)
{
throw new ArgumentOutOfRangeException("dimension");
}
else
{
this.dimension = dimension;
this.field = field;
this.vectorFactory = vectorFactory;
this.orderedColComparer = new OrderedEqualityColComparer <CoeffType>(field);
}
}
/// <summary>
/// Instancia um novo objecto do tipo <see cref="ConfigVectorReader{T, SymbValue, SymbType, InputReader}"/>.
/// </summary>
/// <param name="lines">O número de linhas.</param>
/// <param name="vectorFactory">A fábrica responsável pela criação de vectores.</param>
/// <exception cref="ArgumentNullException">Se a fábrica de vectores for nula.</exception>
public ConfigVectorReader(int lines, IMathVectorFactory <T> vectorFactory)
{
if (vectorFactory == null)
{
throw new ArgumentNullException("vectorFactory");
}
else
{
this.vectorFactory = vectorFactory;
this.rangeReader = new RangeConfigReader <T, SymbValue, SymbType>(
new int[] { lines });
}
}
/// <summary>
/// Cria a instância de um objecto capaz de multiplicar um coeficiente por um vector.
/// </summary>
/// <param name="coeffsMultOperation">A operação de multiplicação entre os coeficientes.</param>
/// <param name="vectorFactory">Uma fábrica que permita criar instâncias de vectores.</param>
/// <exception cref="ArgumentNullException">Caso ambos os argumentos sejam nulos.</exception>
public CoeffVectorMultiplicationOperation(
IMultiplicationOperation <CoeffType, CoeffVectorType, CoeffVectorType> coeffsMultOperation,
IMathVectorFactory <CoeffVectorType> vectorFactory)
{
if (vectorFactory == null)
{
throw new ArgumentNullException("vectorFactory");
}
else if (coeffsMultOperation == null)
{
throw new ArgumentNullException("coeffsMultOperation");
}
else
{
this.vectorFactory = vectorFactory;
this.coeffsMultOperation = coeffsMultOperation;
}
}
/// <summary>
/// Instancia um novo objecto do tipo
/// <see cref="SubsetSumLLLReductionAlgorithm{CoeffType, NearestCoeffFieldType}"/>.
/// </summary>
/// <param name="vectorFactory">A fábrica responsável pela criação de vectores.</param>
/// <param name="scalarProd">O objecto responsável pelos produtos escalares.</param>
/// <param name="nearest">O objecto responsável pela determinação dos valores mais próximos.</param>
/// <param name="fieldComparer">O comparador de objectos do corpo.</param>
/// <param name="converter">O conversor de objectos.</param>
/// <param name="nearestField">O objecto responsável pela determinação dos elementos mais próximos.</param>
/// <exception cref="ArgumentNullException">
/// Se algum dos argumentos for nulo.
/// </exception>
public SubsetSumLLLReductionAlgorithm(
IMathVectorFactory <NearestCoeffFieldType> vectorFactory,
IScalarProductSpace <IMathVector <NearestCoeffFieldType>, NearestCoeffFieldType> scalarProd,
INearest <NearestCoeffFieldType, NearestCoeffFieldType> nearest,
IComparer <NearestCoeffFieldType> fieldComparer,
IConversion <CoeffType, NearestCoeffFieldType> converter,
IField <NearestCoeffFieldType> nearestField)
{
if (nearestField == null)
{
throw new ArgumentNullException("nearestField");
}
else if (converter == null)
{
throw new ArgumentNullException("converter");
}
else if (fieldComparer == null)
{
throw new ArgumentNullException("fieldComparer");
}
else if (nearest == null)
{
throw new ArgumentNullException("nearest");
}
else if (scalarProd == null)
{
throw new ArgumentNullException("scalarProd");
}
else if (vectorFactory == null)
{
throw new ArgumentNullException("vectorFactory");
}
else
{
this.vectorFactory = vectorFactory;
this.scalarProd = scalarProd;
this.nearest = nearest;
this.fieldComparer = fieldComparer;
this.converter = converter;
this.nearestField = nearestField;
}
}
