public Permutation Insert(int position, int letter, IEnumerable <int> positionsHigherLetters)
{
int maximum;
bool lettersIncreased = false;
NumSequenceBasic newNumSequenceBasic;
if (Maximum >= letter)
{
lettersIncreased = true;
maximum = Maximum + 1;
}
else
{
maximum = letter;
}
NumSequenceBasic numSequenceBasicTemp = NumSequenceBasic.InsertLetter
(position - LowestPosition,
letter);
if (lettersIncreased)
{
newNumSequenceBasic = numSequenceBasicTemp.Change(CorrectPositions(positionsHigherLetters),
+1);
}
else
{
newNumSequenceBasic = numSequenceBasicTemp;
}
return(patternFactory.GetPattern(newNumSequenceBasic,
HighestPosition + 1, maximum));
}
public override PatternBasic Insert(int position, int letter)
{
NumSequenceBasic newNumSequenceBasic = NumSequenceBasic.InsertLetter(position - LowestPosition, letter);
return(PatternFactory.GetPattern(newNumSequenceBasic,
HighestPosition + 1));
}
public override Permutation Insert(int position, int letter)
{
int maximum;
bool lettersIncreased = false;
NumSequenceBasic newNumSequenceBasic;
if (Maximum >= letter)
{
maximum = Maximum + 1;
lettersIncreased = true;
}
else
{
maximum = letter;
}
NumSequenceBasic numSequenceBasicTemp = NumSequenceBasic.InsertLetter
(position - LowestPosition, letter);
if (lettersIncreased)
{
newNumSequenceBasic = IncreaseHigherLetters(numSequenceBasicTemp, letter,
position - LowestPosition);
}
else
{
newNumSequenceBasic = numSequenceBasicTemp;
}
return(patternFactory.GetPattern(newNumSequenceBasic,
HighestPosition + 1, maximum));
}
public bool IsPermutation(NumSequenceBasic numSequenceBasic)
{
if (numSequenceBasic == null)
{
return(false);
}
HashSet <int> letters = new HashSet <int>();
int length = numSequenceBasic.Length;
for (int i = 0; i < length; i++)
{
int letter = numSequenceBasic.GetLetter(i);
if (letters.Contains(letter) || letter >= length)
{
return(false);
}
else
{
letters.Add(letter);
}
}
return(true);
}
public override Permutation InsertPosition(int position)
{
NumSequenceBasic newNumSequenceBasic = NumSequenceBasic.InsertLetter(position - LowestPosition,
Maximum + 1);
return(PatternFactory.GetPattern(newNumSequenceBasic, HighestPosition + 1,
Maximum + 1));
}
public bool IsPatternBasic(NumSequenceBasic numSequenceBasic)
{
if (numSequenceBasic == null)
{
return(false);
}
return(true);
}
public PatternBasic ChangePositive(IEnumerable <int> positions, int difference)
{
NumSequenceBasic newNumSequenceBasic;
IEnumerable <int> correctedPositions = CorrectPositions(positions);
newNumSequenceBasic = NumSequenceBasic.Change(correctedPositions, difference);
return(patternFactory.GetPattern(newNumSequenceBasic, highestPosition));
}
public bool IsPermutation(NumSequenceBasic numSequenceBasic)
{
if (numSequenceBasic == null)
{
return(false);
}
return(true);
}
public Permutation GetPattern(NumSequenceBasic numSequenceBasic,
int highestPosition, int maximum)
{
if (isPermutation.IsPermutation(numSequenceBasic))
{
return(new Permutation(numSequenceBasic, highestPosition, maximum));
}
return(null);
}
public PatternBasic GetPattern(NumSequenceBasic numSequenceBasic,
int highestPosition)
{
if (isPatternBasic.IsPatternBasic(numSequenceBasic))
{
return(new PatternBasic(numSequenceBasic, highestPosition));
}
return(null);
}
protected void FillNumSequenceLetters(NumSequenceBasic numSequenceBasic, string[] letters)
{
int letter;
for (int i = letters.Length - 1; i >= 0; i--)
{
int.TryParse(letters[i], out letter);
numSequenceBasic.InsertLetterMutable(0, letter);
}
}
public Permutation Delete(int position, IEnumerable <int> positionsHigherLetters)
{
NumSequenceBasic numSequenceBasicTemp = DeleteInternal(position);
NumSequenceBasic newNumSequenceBasic = numSequenceBasicTemp.
Change(CorrectPositions(positionsHigherLetters),
-1);
return(patternFactory.GetPattern(newNumSequenceBasic,
HighestPosition - 1, Maximum - 1));
}
public T CreatePattern(ulong[] words, byte letterSize, int length)
{
factoryBuilder.SetLength(length);
factoryBuilder.SetLetterSize(letterSize);
factoryBuilder.SetWords(words);
INumSequenceBasicWsBuilder builder;
factoryBuilder.TryGetBuilder(out builder);
NumSequenceBasic numSequenceBasic = factoryNumSequence.CreateNumSequenceBasic(builder);
return(ConstructPattern(numSequenceBasic,
length - 1, length - 1));
}
public T CreatePattern(string[] letters, byte letterSize)
{
factoryBuilder.SetLength(0);
factoryBuilder.SetLetterSize(letterSize);
factoryBuilder.SetWords(new ulong[] { 0 });
INumSequenceBasicWsBuilder builder;
factoryBuilder.TryGetBuilder(out builder);
NumSequenceBasic numSequenceBasic = factoryNumSequence.CreateNumSequenceBasic(builder);
FillNumSequenceLetters(numSequenceBasic, letters);
return(ConstructPattern(numSequenceBasic,
letters.Length - 1, letters.Length - 1));
}
private IEnumerable <int> FindPositionsToBeAltered(NumSequenceBasic numSequenceBasic, int letter,
int avoidedPosition)
{
List <int> positions = new List <int>();
for (int i = 0; i < numSequenceBasic.Length; i++)
{
if (avoidedPosition != i)
{
if (numSequenceBasic.GetLetter(i) >= letter)
{
positions.Add(i);
}
}
}
return(positions);
}
public override Permutation Delete(int position)
{
NumSequenceBasic newNumSequenceBasic;
int letter = NumSequenceBasic.GetLetter(position - LowestPosition);
NumSequenceBasic numSequenceBasicTemp = NumSequenceBasic.
DeleteLetterPosition(position - LowestPosition);
if (letter == Maximum)
{
newNumSequenceBasic = numSequenceBasicTemp;
}
else
{
newNumSequenceBasic = DecreaseHigherLetters(numSequenceBasicTemp, letter,
position - LowestPosition);
}
return(patternFactory.GetPattern(newNumSequenceBasic,
HighestPosition - 1, Maximum - 1));
}
public Permutation ComputeInversion()
{
if (inversionSet)
{
return(inversion);
}
else
{
NumSequenceBasicFactory factory = new NumSequenceBasicFactory();
NumSequenceBasic numSequenceBasic = factory.GetNumSequenceDefault(LetterSize, Length, false);
for (int i = LowestPosition; i <= HighestPosition; i++)
{
numSequenceBasic.SetLetterMutable(NumSequenceBasic.GetLetter(i), i);
}
inversionSet = true;
inversion = patternFactory.GetPattern(numSequenceBasic, HighestPosition, Maximum);
return(inversion);
}
}
public override PatternBasic Delete(int position)
{
NumSequenceBasic newNumSequenceBasic = DeleteInternal(position);
return(PatternFactory.GetPattern(newNumSequenceBasic, HighestPosition - 1));
}
private Permutation(NumSequenceBasic numSequenceBasic, int highestPosition, int maximum)
: base(numSequenceBasic, maximum)
{
this.highestPosition = highestPosition;
inversionSet = false;
}
private NumSequenceBasic CorrectNumSequence(NumSequenceBasic numSequenceBasic,
int difference, IEnumerable <int> positions)
{
return(numSequenceBasic.Change(positions, difference));
}
public override PatternBasic Clone()
{
return(PatternFactory.GetPattern(NumSequenceBasic.Clone(), HighestPosition));
}
public PatternBasic(NumSequenceBasic numSequenceBasic,
int highestPosition) : base(numSequenceBasic)
{
this.highestPosition = highestPosition;
}
protected PatternIm(NumSequenceBasic numSequenceBasic)
{
this.numSequenceBasic = numSequenceBasic;
}
private NumSequenceBasic DecreaseHigherLetters(NumSequenceBasic numSequenceBasic, int letter,
int avoidedPosition)
{
return(CorrectNumSequence(numSequenceBasic, -1, FindPositionsToBeAltered(numSequenceBasic,
letter, avoidedPosition)));
}
protected abstract T ConstructPattern(NumSequenceBasic numSequenceBasic, int highestPosition, int maximum);
protected override Permutation ConstructPattern(NumSequenceBasic numSequenceBasic, int highestPosition, int maximum)
{
return(patternFactory.GetPattern(numSequenceBasic, highestPosition, maximum));
}
public override Permutation Switch(int positionFrom, int positionTo)
{
NumSequenceBasic newNumSequenceBasic = SwitchInternal(positionFrom, positionTo);
return(PatternFactory.GetPattern(newNumSequenceBasic, HighestPosition, Maximum));
}
