/// <summary>
/// Adds number to exponent.
/// IMPORTANT- Doesn't count variety of formats (only Integer)
/// </summary>
/// <param name="inNumber"></param>
/// <param name="inStr"></param>
/// <param name="inCapacity"></param>
public void sumExp(String Exponent, String inStr, IPBNumber.NumberCapacity inCapacity)
{
String E;
int iE, Offset = 0;
E = Exponent; // It can be Fraction or Interval
Offset = (int)getNumberOffset(inCapacity);
/*switch (inNumberFormat)
{
case 0: Offset = (int)inNumber.Offset; break;
case 1:
case 2: Offset = inNumber.OffsetFI; break;
case 3: Offset = inNumber.OffsetTetra; break;
case 4: Offset = inNumber.OffsetFITetra; break;
}*/
E = convert2to10IPart(E);
iE = int.Parse(E) - Offset;
// Check if inStr > E.Max
iE += int.Parse(inStr); // This Addition is UNSECURE !
// Check if iE > E.Max
E = convert10to2IPart((iE + Offset).ToString());
Exponent = E;
}
/// <summary>
/// Denormolizes number
/// </summary>
/// <param name="dataString">Input String to dernomolize</param>
/// <param name="NumberFormat">Indicates format of input number</param>
/// <returns>Denormolized number as String</returns>
public IPBNumber.IFPartsOfNumber DenormalizeNumber(String dataString, IPBNumber.NumberFormat inNumberFormat)
{
String denormNumber = "";
String denormIntPart = "", denormFloatPart = "";
String ExpSign, Sign = "0", SignCharacter = "+";
String E;
String[] tempArray;
IPBNumber.IFPartsOfNumber returnValue = new IPBNumber.IFPartsOfNumber();
try
{
ExpSign = dataString.Substring(dataString.IndexOf('e') + 1, 1);
if (dataString[0] == '+')
{
if (inNumberFormat == 0)
{
Sign = "0";
SignCharacter = "+";
}
else
{
/*
if (Left_Right == PartOfNumber.Left)
{
SignLeft = "0";
SignCharacterLeft = "+";
}
else
{
SignRight = "0";
SignCharacterRight = "+";
}*/
}
}
else
if (dataString[0] == '-')
{
if (inNumberFormat == 0)
{
Sign = "1";
SignCharacter = "-";
}
else
{
/*
if (Left_Right == PartOfNumber.Left)
{
SignLeft = "1";
SignCharacterLeft = "-";
}
else
{
SignRight = "1";
SignCharacterRight = "-";
}*/
}
}
else
{
if (inNumberFormat == 0)
{
Sign = "0";
SignCharacter = "+";
}
else
{
/*
if (Left_Right == PartOfNumber.Left)
{
SignLeft = "0";
SignCharacterLeft = "+";
}
else
{
SignRight = "0";
SignCharacterRight = "+";
}*/
}
}
returnValue.Sign = Sign;
//throw new Exception("Func [selectSEM]:= NoSignException.");
int index = dataString.IndexOf('e') + 1;
if (index < dataString.Length)
E = dataString.Substring(index, dataString.Length - index);
else
throw new Exception("Func [selectSEM]:= NoExponentaException.");
int iExp = Math.Abs(int.Parse(E));
if ((dataString[0] == '-') || (dataString[0] == '+'))
dataString = dataString.Substring(1);
/*iPart */
denormIntPart = dataString.Substring(0, dataString.IndexOf(','));
index = dataString.IndexOf(',') + 1;
/*fPart*/
denormFloatPart = dataString.Substring(index, dataString.IndexOf('e') - index);////+1
if (ExpSign == "+")
{
String fPartTemp = denormFloatPart;
if (iExp > 0)
{
tempArray = new String[Math.Abs(iExp - denormFloatPart.Length)];
for (int i = 0; i < (Math.Abs(iExp - denormFloatPart.Length)); i++)
tempArray[i] = "0";
fPartTemp = fPartTemp + String.Join("", tempArray);
denormFloatPart = "0";
}
denormIntPart = denormIntPart + fPartTemp.Substring(0, iExp);
denormFloatPart = fPartTemp.Substring(iExp);
if (denormFloatPart.Length == 0)
denormFloatPart = "0";
}
else
{
String iPartTemp = denormIntPart;
tempArray = new String[Math.Abs(iExp - denormIntPart.Length)];
for (int i = 0; i < Math.Abs((iExp - denormIntPart.Length)); i++)
tempArray[i] = "0";
iPartTemp = String.Join("", tempArray) + iPartTemp;
if (iExp > denormIntPart.Length)
{
denormFloatPart = iPartTemp + denormFloatPart;
denormIntPart = "0";
}
else
{
denormFloatPart = iPartTemp.Substring(iPartTemp.Length - iExp) + denormFloatPart;
if (iPartTemp.Length != iExp)
denormIntPart = iPartTemp.Substring(0, iPartTemp.Length - iExp);
else
denormIntPart = "0";
}
}
// iPart = myUtil.deleteZeroFromNumber(iPart);
// if (iPart[0] == '0')
// iPart = iPart.Substring(1);
while ((denormIntPart[0] == '0') && (denormIntPart.Length > 1))
{
denormIntPart = denormIntPart.Substring(1);
}
// Compact to one statement num32 = num64 = num128 = num256 = denorm
denormNumber = SignCharacter + denormIntPart + "," + denormFloatPart;
//Num32.Denormalized = Num64.Denormalized = Num128.Denormalized = Num256.Denormalized =
if (inNumberFormat == 0)
{
/*Num32.IntPartDenormalized = Num64.IntPartDenormalized = Num128.IntPartDenormalized = Num256.IntPartDenormalized = IntPartDenormalized = denormIntPart;
Num32.FloatPartDenormalized = Num64.FloatPartDenormalized = Num128.FloatPartDenormalized = Num256.FloatPartDenormalized = FloatPartDenormalized = denormFloatPart;*/
//DenormIntPart = denormIntPart;
returnValue.IntegerPart = denormIntPart;
//DenormFloatPart = denormFloatPart;
returnValue.FloatPart = denormFloatPart;
}
else
{
/*
if (Left_Right == PartOfNumber.Left)
{
IntPartDenormalizedFILeft = denormIntPart;
FloatPartDenormalizedFILeft = denormFloatPart;
}
else
{
IntPartDenormalizedFIRight = denormIntPart;
FloatPartDenormalizedFIRight = denormFloatPart;
}
//Num32.IntPartDenormalizedFI = Num64.IntPartDenormalizedFI = Num128.IntPartDenormalizedFI = Num256.IntPartDenormalizedFI = IntPartDenormalizedFI = denormIntPart;
//Num32.FloatPartDenormalizedFI = Num64.FloatPartDenormalizedFI = Num128.FloatPartDenormalizedFI = Num256.FloatPartDenormalizedFI = FloatPartDenormalizedFI = denormFloatPart;
DenormIntPartFI = denormIntPart;
DenormFloatPartFI = denormFloatPart;
*/
}
return returnValue;
}
catch (Exception ex)
{
//throw new FCCoreFunctionException("Exception in Func ['selectSEM'] Mess=[" + ex.Message + "]");
throw new Exception(ex.Message, ex.InnerException);
}
}
/// <summary>
/// Calculates number offset depending on number capacity.
/// IMPORTANT- Doesn't count variety of formats (only Integer)
/// </summary>
/// <param name="inCapacity"></param>
/// <returns></returns>
public IPBNumber.NumberOffset getNumberOffset(IPBNumber.NumberCapacity inCapacity)
{
switch (inCapacity)
{
case IPBNumber.NumberCapacity.PB32:
{
return IPBNumber.NumberOffset.PB32;
}
case IPBNumber.NumberCapacity.PB64:
{
return IPBNumber.NumberOffset.PB64;
}
case IPBNumber.NumberCapacity.PB128:
{
return IPBNumber.NumberOffset.PB128;
}
case IPBNumber.NumberCapacity.PB256:
{
return IPBNumber.NumberOffset.PB256;
}
}
return IPBNumber.NumberOffset.PB128;
}
public String NormalizeNumber(String dataString, int inAccuracy, IPBNumber.NumberFormat inNumberFormat)
{
/// Current Number Sign 0 = '+'; 1 = '-'
String Sign;
try
{
if (dataString.Length > inAccuracy)
dataString = dataString.Substring(0, inAccuracy);
if (dataString.Contains("E"))
dataString = dataString.Replace('E', 'e');
//else
// return null || Rise FCCoreException
if (dataString.Contains("."))
dataString = dataString.Replace('.', ',');
//else
// return null || Rise FCCoreException
if (dataString.IndexOf(',') == 0)
dataString = "0" + dataString;
if ((dataString[0] != '-') && (dataString[0] != '+'))
{
dataString = "+" + dataString;
if (inNumberFormat == 0)
{
Sign = "0";
//SignLeft = "0";
}
else
{
/** Reserved for float and interval formats
if (Left_Right == PartOfNumber.Left)
SignLeft = "0";
else
SignRight = "0";
*/
}
}
else
{
if (inNumberFormat == 0)
{
Sign = "0";
//SignLeft = "1";
}
else
{
/** Reserved for float and interval formats
if (Left_Right == PartOfNumber.Left)
SignLeft = "1";
else
SignRight = "1";
*/
}
}
if (dataString.IndexOf(',') == -1)
if (dataString.IndexOf('e') != -1)
dataString = dataString.Substring(0, dataString.IndexOf('e')) + ",0" + dataString.Substring(dataString.IndexOf('e'));
else
dataString = dataString + ",0";
if ((dataString[dataString.IndexOf('e') + 1] != '+') &&
(dataString[dataString.IndexOf('e') + 1] != '-'))
dataString = dataString.Replace("e", "e+");
if (dataString.IndexOf('e') == -1)
dataString = dataString + "e+0";
}
catch (Exception ex)
{
throw new Exception("NormalizeNumber:" + ex.Message);
}
return dataString;
}
/// <summary>
/// Calculates number mantissa length depending on number capacity.
/// IMPORTANT- Doesn't count variety of formats (only Integer)
/// </summary>
/// <param name="inCapacity"></param>
/// <returns></returns>
public IPBNumber.NumberMantissaLength getNumberMantissaLength(IPBNumber.NumberCapacity inCapacity)
{
switch (inCapacity)
{
case IPBNumber.NumberCapacity.PB32:
{
return IPBNumber.NumberMantissaLength.PB32;
}
case IPBNumber.NumberCapacity.PB64:
{
return IPBNumber.NumberMantissaLength.PB64;
}
case IPBNumber.NumberCapacity.PB128:
{
return IPBNumber.NumberMantissaLength.PB128;
}
case IPBNumber.NumberCapacity.PB256:
{
return IPBNumber.NumberMantissaLength.PB256;
}
}
return IPBNumber.NumberMantissaLength.PB128;
}
/// <summary>
/// Gets empty mantissa depending on number capacity.
/// </summary>
/// <param name="inCapacity"></param>
/// <returns></returns>
public String getEmptyMantissa(IPBNumber.NumberCapacity inCapacity)
{
switch (inCapacity)
{
case IPBNumber.NumberCapacity.PB32:
{
return IPBNumber.EmptyMantissa[(int)IPBNumber.NumberFormatCode.PB32];
}
case IPBNumber.NumberCapacity.PB64:
{
return IPBNumber.EmptyMantissa[(int)IPBNumber.NumberFormatCode.PB64];
}
case IPBNumber.NumberCapacity.PB128:
{
return IPBNumber.EmptyMantissa[(int)IPBNumber.NumberFormatCode.PB128];
}
case IPBNumber.NumberCapacity.PB256:
{
return IPBNumber.EmptyMantissa[(int)IPBNumber.NumberFormatCode.PB256];
}
}
return IPBNumber.EmptyMantissa[(int)IPBNumber.NumberFormatCode.PB128];
}
// PBNumber inObjectNumber,
/// <summary>
/// Calculates Mantissa for specified number. Define Exponent before Mantissa for correct running algorithm.
/// Uses funcs: isStringZero,convert10to2IPart, checkStringFull, sumExp
/// Uses Vars: Number.BinaryIntPart,Number.BinaryFloatPart
/// </summary>
/// <param name="inNumber">Number - var from which mantissa need to be taken</param>
/// <param name="Left_Right">False - Left part og number, else - Right </param>
/// <returns>Returns Mantissa in 2cc</returns>
private void selectMantissa(IFPartsOfNumber inStringNumber, IPBNumber.NumberCapacity inCapacity, IPBNumber.NumberFormat inNumberFormat, IPBNumber.RoundingType inRoundingType)
{
int i, l = 0;
int currMBits;
String result = "";
String[] tempArray;
int offsetDot = 1;
String bynaryStringInt = "", bynaryStringFloat = "";
if (inNumberFormat == 0)
{
bynaryStringInt = inStringNumber.IntegerPart;
bynaryStringFloat = inStringNumber.FloatPart;
}
try
{
if ((bynaryStringInt != null) && (bynaryStringFloat != null))
{
if ((bynaryStringInt != "") && (bynaryStringFloat != ""))
{
if (bynaryStringInt.IndexOf('1') != -1)
{
offsetDot = bynaryStringInt.IndexOf('1');
result = bynaryStringInt.Substring(offsetDot + 1) + bynaryStringFloat;
}
else
if (bynaryStringFloat.IndexOf('1') != -1)
if (pbConvertion.isStringZero(Exponent))
result = "" + bynaryStringFloat.Substring((int)pbConvertion.getNumberOffset(inCapacity) - 1, (int)pbConvertion.getNumberMantissaLength(inCapacity) + 1);
else
{
offsetDot = bynaryStringFloat.IndexOf('1') + 1;
result = "" + bynaryStringFloat.Substring(offsetDot);
}
else
{
currMBits = (int)pbConvertion.getNumberMantissaLength(inCapacity);
tempArray = new String[currMBits];
for (i = 0; i < currMBits; i++)
tempArray[i] = "0";
result = result + String.Join("", tempArray);
}
}
else
{
throw new PBArithmeticException("Exception in Func ['selectMantissa'] Mess=[ Empty String - BynaryIntPart or BynaryFloatPart ] ( PB" + inCapacity + "=" + inStringNumber.ToString() + ")");
}
}
else
{
throw new PBArithmeticException("Exception in Func ['selectMantissa'] Mess=[ Null - BynaryIntPart or BynaryFloatPart ] ( PB" + inCapacity + "=" + inStringNumber.ToString() + ")");
}
currMBits = (int)pbConvertion.getNumberMantissaLength(inCapacity);
if (result.Length <= (int)currMBits)
{
// After Research Modification HERE NEEDED !
l = currMBits + 1 - result.Length;
tempArray = new String[l];
for (i = 0; i < l; i++)
{
tempArray[i] = "0";
}
result = result + String.Join("", tempArray);
}
Round(inRoundingType, result, currMBits, inStringNumber, offsetDot, inCapacity);
}
catch (Exception ex)
{
throw new PBFunctionException("Exception in Func ['selectMantissa'] Mess=[" + ex.Message + "]");
}
}
//, PBNumber inObjectNumber
/// <summary>
/// Calculates Exponent for specified number
/// Uses : Number.BinaryIntPart,Number.BinaryFloatPart
/// </summary>
/// <param name="inNumber">Number - var from which exponenta need to be taken</param>
/// <param name="Left_Right">False - Left part og number, else - Right </param>
/// <returns>Returns Exponent in 2cc</returns>
private void selectExp(IFPartsOfNumber inStingNumber, IPBNumber.NumberCapacity inCapacity, IPBNumber.NumberFormat inNumberFormat)
{
int z = 0;
int Offset = 0;
String temp, result = "";
String bynaryStringInt = "", bynaryStringFloat = "";
bynaryStringInt = inStingNumber.IntegerPart;
bynaryStringFloat = inStingNumber.FloatPart;
try
{
Offset = (int)pbConvertion.getNumberOffset(inCapacity);
if (bynaryStringInt.IndexOf('1') != -1)
{
temp = bynaryStringInt;
temp = temp.TrimStart('0');
z = temp.Length - (temp.IndexOf('1') + 1);
if (z > Offset)
z = Offset;
}
else
if (bynaryStringFloat.IndexOf('1') != -1)
{
temp = bynaryStringFloat;
temp = temp.TrimEnd('0');
z = (temp.IndexOf('1') + 1);
z *= -1;
if (z < -Offset)
z = -Offset;
}
else
{
z = -Offset;
}
result = pbConvertion.convert10to2IPart((z + Offset).ToString());
this.Exponent = result;
}
catch (Exception ex)
{
throw new PBFunctionException("Exception in Func ['selectExp'] Mess=[" + ex.Message + "]");
}
}
public void Round(IPBNumber.RoundingType inRoundingType, String result, int currMBits, IFPartsOfNumber inStringNumber, int offsetDot, IPBNumber.NumberCapacity inCapacity)
{
String M = "";
switch (inRoundingType)
{
case IPBNumber.RoundingType.ZERO: // to ZERO
M = result.Substring(0, currMBits);
break;
case IPBNumber.RoundingType.NEAR_INTEGER:// to INTEGER
if (pbConvertion.isStringZero(Exponent))
{
String[] tempArray = new String[offsetDot];
for (int i = 0; i < offsetDot; i++)
tempArray[i] = "0";
M = M + String.Join("", tempArray);
M += result.Substring(0, currMBits + 1 - offsetDot);
}
else
M = result.Substring(0, currMBits + 0);
if ((result[currMBits] == '1') && (inStringNumber.Sign[0] == '+'))
{
if (!pbConvertion.checkStringFull(M))
{
M = pbConvertion.convert2to10IPart(M);
M = pbConvertion.Addition(M, "1");
}
else
{
M = "0";
if (!pbConvertion.checkStringFull(Exponent))
{
pbConvertion.sumExp(Exponent, "1", inCapacity);
}
}
M = pbConvertion.convert10to2IPart(M);
if (M.Length + 1 == currMBits)
{
M = "0" + M;
}
else
if (M.Length < currMBits)
{
int l = currMBits - M.Length;
String[] tempArray = new String[l];
for (int i = 0; i < l; i++)
tempArray[i] = "0";
M = String.Join("", tempArray) + M;
}
}
break;
case IPBNumber.RoundingType.POSITIVE_INFINITY:// +Inf
M = result.Substring(0, currMBits);
if (inStringNumber.Sign[0] == '0')
{
if (!pbConvertion.checkStringFull(M))
{
M = pbConvertion.convert2to10IPart(M);
M = pbConvertion.Addition(M, "1");
}
else
{
M = "0";
if (!pbConvertion.checkStringFull(Exponent))
{
pbConvertion.sumExp(Exponent, "1", inCapacity);
}
}
M = pbConvertion.convert10to2IPart(M);
}
break;
case IPBNumber.RoundingType.NEGATIVE_INFINITY:
// -Inf
M = result.Substring(0, currMBits);
if (inStringNumber.Sign[0] == '1')
{
if (!pbConvertion.checkStringFull(M))
{
M = pbConvertion.convert2to10IPart(M);
M = pbConvertion.Addition(M, "1");
}
else
{
M = "0";
if (!pbConvertion.checkStringFull(Exponent))
{
pbConvertion.sumExp(Exponent, "1", inCapacity);
}
}
M = pbConvertion.convert10to2IPart(M);
}
break;
case IPBNumber.RoundingType.POST_BINARY:
if (result.Length >= currMBits)
{
M = result.Substring(0, currMBits);
}
else
{
M = result;
while (M.Length < currMBits)
{
M = "0" + M;
}
}
if (result.Length >= currMBits + 2)
{
String nonSignificantBits = result.Substring(currMBits, 2);
if ((nonSignificantBits == "01") || (nonSignificantBits == "10"))
{
int lastZero = M.LastIndexOf('0');
if (lastZero == -1)
{
if (nonSignificantBits == "10")
{
M = pbConvertion.getEmptyMantissa(inCapacity).ToString();
//TODO: Create function for addition in binary, and delete next 3th lines of code
String tempExponent = pbConvertion.convert2to10IPart(this.Exponent);//
tempExponent = pbConvertion.Addition(tempExponent, "1"); // ADD 1 to Exponent
this.Exponent = pbConvertion.convert10to2IPart(tempExponent); //
}
}
else
{
//TODO: Control here
M = M.Substring(0, lastZero) + "M";
while (M.Length < currMBits)
{
M += "A";
}
}
}else
if (nonSignificantBits == "11")
{
if (M.LastIndexOf('0')!=-1)
{
M = pbConvertion.convert10to2IPart( pbConvertion.Addition(pbConvertion.convert2to10IPart(M), "1") );
}else
{
Round(IPBNumber.RoundingType.NEAR_INTEGER, result, currMBits, inStringNumber, offsetDot, inCapacity);
}
}
}
break;
}
this.Mantissa = M;
}
