public ImagePsd(string p_FileFullPath)
{
if (!File.Exists(p_FileFullPath))
{
return;
}
FileStream _PSD = File.Open(p_FileFullPath, FileMode.Open);
byte[] _HeadByte = new byte[26];
_PSD.Read(_HeadByte, 0, 26);
m_Head = new PSDHEAD(_HeadByte);
m_ColorModel = new ColorModel(_PSD);
long _ReadCount = _PSD.Position;
while (true)
{
BIM _Bim = new BIM(_PSD);
if (!_Bim.Read || _PSD.Position - _ReadCount >= m_ColorModel.BIMSize)
{
break;
}
m_8BIMList.Add(_Bim);
}
m_LayerMaskInfo = new LayerMaskInfo(_PSD);
m_ImageData = new ImageData(_PSD, m_Head);
if (m_Head.ColorMode == 2)
{
m_ImageData.PSDImage.Palette = m_ColorModel.ColorData;
}
_PSD.Close();
}
public BIM.BusinessEntities.VerificadorPLD ServicioVerificadorPLD(BIM.BusinessEntities.BitacoraPLD parametros)
{
BIM.BusinessEntities.VerificadorPLD result = null;
try
{
result = (new VerificadorPLDLogic()).ServicioVerificadorPLD(parametros);
}
catch (Exception ex)
{
#if(DEBUG)
if (Directory.Exists(RepositorioTmpLocal))
Directory.CreateDirectory(RepositorioTmpLocal);
string msg = DateTime.Today.ToShortDateString() + " - " + DateTime.Today.ToShortTimeString() + " Mensaje error: " + ex.Message;
File.AppendAllText(RepositorioTmpLocal + ArchivoError, msg);
#else
EventLogManager.LogErrorEntry("Error en VerificadorPLDServices.ServicioVerificadorPLD: " + ex.Message);
//TODO: Codificar envío de notificación de error al EventLog
#endif
}
return result;
}
public static BIM bimLiftOver(Chain chain,
BIM input)
{
string chr = input.Chromosome;
int pos = input.Position;
if (pos > 0)
{
foreach (ChainRecord chainRecord in chain.chainRecords)
{
if (chainRecord.tName == ("chr" + chr) &&
chainRecord.tStart <= pos &&
chainRecord.tEnd >= pos)
{
int tStart = chainRecord.tStart, qStart = chainRecord.qStart;
for (int idx = 0; idx < chainRecord.chainGaps.Count; ++idx)
{
var chainGap = chainRecord.chainGaps[idx];
if (pos < tStart + chainGap.size)
{
input.Position = pos + (qStart - tStart);
break;
}
tStart += chainGap.size + chainGap.dt;
qStart += chainGap.size + chainGap.dq;
}
break;
}
}
}
return(input);
}
public BIM.BusinessEntities.VerificadorPLD ServicioVerificadorPLD(BIM.BusinessEntities.BitacoraPLD parametros)
{
BIM.BusinessEntities.VerificadorPLD result = null;
try
{
result = (new VerificadorPLDLogic()).ServicioVerificadorPLD(parametros);
}
catch (Exception ex)
{
#if(DEBUG)
const string fic = @"C:\inetpub\wwwroot\PLD\Prueba.txt";
string texto = ex.Message;
System.IO.StreamWriter sw = new System.IO.StreamWriter(fic);
sw.WriteLine(texto);
sw.Close();
//Console.WriteLine("Error en VerificadorPLDServices.ServicioVerificadorPLD: " + ex.Message);
//if (!EventLog.SourceExists(cs))
// EventLog.CreateEventSource(cs, "Application");
//EventLog.WriteEntry(cs, ex.Message, EventLogEntryType.Error);
#else
EventLogManager.LogErrorEntry("Error en VerificadorPLDServices.ServicioVerificadorPLD: " + ex.Message);
//TODO: Codificar envío de notificación de error al EventLog
#endif
}
return result;
}
public static BigDec FromString(string v)
{
if (v == null)
{
throw new FormatException();
}
BIM integral = BIM.Zero;
BIM fraction = BIM.Zero;
int exponent = 0;
int len = v.Length;
int i = v.IndexOf('e');
if (i >= 0)
{
if (i + 1 == v.Length)
{
throw new FormatException();
}
exponent = Int32.Parse(v.Substring(i + 1, len - i - 1));
len = i;
}
int fractionLen = 0;
i = v.IndexOf('.');
if (i >= 0)
{
if (i + 1 == v.Length)
{
throw new FormatException();
}
fractionLen = len - i - 1;
fraction = BIM.Parse(v.Substring(i + 1, fractionLen));
len = i;
}
integral = BIM.Parse(v.Substring(0, len));
if (!fraction.IsZero)
{
while (fractionLen > 0)
{
integral = integral * ten;
exponent = exponent - 1;
fractionLen = fractionLen - 1;
}
}
if (integral.Sign == -1)
{
return(new BigDec(integral - fraction, exponent));
}
else
{
return(new BigDec(integral + fraction, exponent));
}
}
// ``floor`` rounds towards negative infinity (like SMT-LIBv2's to_int).
/// <summary>
/// NOTE: This may give wrong results, it hasn't been tested extensively
/// If you're getting weird bugs, you may want to check this function out...
/// Computes the floor and ceiling of this BigFloat. Note the choice of rounding towards negative
/// infinity rather than zero for floor is because SMT-LIBv2's to_int function floors this way.
/// </summary>
/// <param name="floor">The Floor (rounded towards negative infinity)</param>
/// <param name="ceiling">Ceiling (rounded towards positive infinity)</param>
public void FloorCeiling(out BIM floor, out BIM ceiling)
{
BIM two = new BIM(2);
BIM sig = Significand + BIM.Pow(two, SignificandSize); //Add hidden bit
BIM exp = Exponent - BIM.Pow(two, ExponentSize - 1) + 1;
while (exp > BIM.Zero)
{
exp--;
sig = sig << 1;
}
sig = sig >> SignificandSize;
if (isNeg)
{
ceiling = -sig + 1;
floor = -sig;
}
else
{
ceiling = sig + 1;
floor = sig;
}
}
public override string /*!*/ ToString()
{
Contract.Ensures(Contract.Result <string>() != null);
if (value == "")
{
byte[] sigBytes = significand.ToByteArray();
StringBuilder binSig = new StringBuilder();
if (exponent == 0)
{
binSig.Append('0');
}
else
{
binSig.Append('1'); //hidden bit
}
for (int i = significandSize - 2; i >= 0; --i) //little endian
{
if (i / 8 < sigBytes.Length)
{
binSig.Append((char)('0' + ((sigBytes[i / 8] >> (i % 8)) & 1)));
}
else
{
binSig.Append('0');
}
}
BIM bias = two_n(exponentSize - 1) - 1;
if (exponent == 0)
{
--bias;
}
int moveDec = ((int)((exponent - bias) % 4) + 4) % 4;
BIM finalExp = (exponent - bias - moveDec) / 4;
string leftBinSig = binSig.ToString().Substring(0, moveDec + 1);
string rightBinSig = binSig.ToString().Substring(moveDec + 1);
leftBinSig = new string('0', 4 - leftBinSig.Length % 4) + leftBinSig;
rightBinSig = rightBinSig + new string('0', 4 - rightBinSig.Length % 4);
StringBuilder leftHexSig = new StringBuilder();
StringBuilder rightHexSig = new StringBuilder();
for (int i = 0; i < leftBinSig.Length / 4; ++i)
{
leftHexSig.AppendFormat("{0:X}", Convert.ToByte(leftBinSig.Substring(i * 4, 4), 2));
}
for (int i = 0; i < rightBinSig.Length / 4; ++i)
{
rightHexSig.AppendFormat("{0:X}", Convert.ToByte(rightBinSig.Substring(i * 4, 4), 2));
}
return(String.Format("{0}0x{1}.{2}e{3}f{4}e{5}", isNeg ? "-" : "", leftHexSig, rightHexSig, finalExp, significandSize, exponentSize));
}
return(String.Format("0{0}{1}e{2}", value, significandSize, exponentSize));
}
public static BigFloat operator +(BigFloat x, BigFloat y)
{
//TODO: Modify for correct fp functionality
Contract.Requires(x.ExponentSize == y.ExponentSize);
Contract.Requires(x.SignificandSize == y.SignificandSize);
BIM m1 = x.significand;
BIM e1 = x.Exponent;
BIM m2 = y.significand;
BIM e2 = y.Exponent;
m1 = m1 + two_n(x.significandSize + 1); //Add implicit bit
m2 = m2 + two_n(y.significandSize + 1);
if (e2 > e1)
{
m1 = y.significand;
e1 = y.Exponent;
m2 = x.significand;
e2 = x.Exponent;
}
while (e2 < e1)
{
m2 = m2 / two;
e2 = e2 + one;
}
return(new BigFloat(false, e1, m1 + m2, x.significandSize, x.ExponentSize));
}
public static BigNum FromString(string v)
{
try {
return(new BigNum(BIM.Parse(v)));
} catch (System.ArgumentException) {
throw new FormatException();
}
}
public BigFloat(bool isNeg, BIM significand, BIM exponent, int significandSize, int exponentSize)
{
this.exponentSize = exponentSize;
this.exponent = exponent;
this.significand = significand;
this.significandSize = significandSize + 1;
this.isNeg = isNeg;
this.value = "";
}
public BigFloat(bool isSignBitSet, BIM significand, BIM exponent, int significandSize, int exponentSize)
{
this.exponentSize = exponentSize;
this.exponent = exponent;
this.significand = significand;
this.significandSize = significandSize;
this.isSignBitSet = isSignBitSet;
this.value = "";
}
private BIM maxsignificand()
{
BIM result = one;
for (int i = 0; i < significandSize; i++)
{
result = result * two;
}
return(result - one);
}
private static BIM two_n(int n)
{
BIM toReturn = one;
for (int i = 0; i < n; i++)
{
toReturn = toReturn * two;
}
return(toReturn);
}
////////////////////////////////////////////////////////////////////////////
// Conversion operations
/// <summary>
/// NOTE: THIS METHOD MAY NOT WORK AS EXPECTED!!!
/// Converts the given decimal value (provided as a string) to the nearest floating point approximation
/// the returned fp assumes the given significand and exponent size
/// </summary>
/// <param name="value"></param>
/// <param name="significandSize"></param>
/// <param name="exponentSize"></param>
/// <returns></returns>
public static BigFloat Round(String value, int exponentSize, int significandSize)
{
int i = value.IndexOf('.');
if (i == -1)
{
return(Round(BIM.Parse(value), BIM.Zero, exponentSize, significandSize));
}
return(Round(i == 0 ? BIM.Zero : BIM.Parse(value.Substring(0, i)), BIM.Parse(value.Substring(i + 1, value.Length - i - 1)), exponentSize, significandSize));
}
public BigFloat(String value, int significandSize, int exponentSize)
{
this.exponentSize = exponentSize;
this.significandSize = significandSize;
this.exponent = BIM.Zero;
this.significand = BIM.Zero;
this.value = value;
if (value.Equals("nan"))
{
this.value = "NaN";
}
this.isNeg = value[0] == '-';
}
public static BigFloat FromString(String s)
{
/*
* String must be either of the format *e*f*e*
* or of the special value formats: 0NaN*e* 0nan*e* 0+oo*e* 0-oo*e*
* Where * indicates an integer value (digit)
*/
BIM sig, exp;
int sigSize, expSize;
bool isNeg;
if (s.IndexOf('f') == -1)
{
String val = s;
sigSize = int.Parse(s.Substring(4, s.IndexOf('e') - 4));
expSize = int.Parse(s.Substring(s.IndexOf('e') + 1));
if (sigSize <= 0 || expSize <= 0)
{
throw new FormatException("Significand and Exponent sizes must be greater than 0");
}
return(new BigFloat(val, sigSize, expSize));
}
sig = BIM.Parse(s.Substring(0, s.IndexOf('e')));
exp = BIM.Parse(s.Substring(s.IndexOf('e') + 1, s.IndexOf('f') - s.IndexOf('e') - 1));
sigSize = int.Parse(s.Substring(s.IndexOf('f') + 1, s.IndexOf('e', s.IndexOf('e') + 1) - s.IndexOf('f') - 1));
expSize = int.Parse(s.Substring(s.IndexOf('e', s.IndexOf('e') + 1) + 1));
isNeg = s[0] == '-'; //We do this so that -0 is parsed correctly
if (sigSize <= 0 || expSize <= 0)
{
throw new FormatException("Significand and Exponent sizes must be greater than 0");
}
sigSize = sigSize - 1; //Get rid of sign bit
sig = BIM.Abs(sig); //sig must be positive
//Uncomment if you want to shift the exponent for the user (i.e. 0e-1f24e8 --> 0e126f24e8)
//exp = exp + BIM.Pow(new BIM(2), expSize-1) - BIM.One;
if (exp < 0 || exp >= BIM.Pow(new BIM(2), expSize))
{
throw new FormatException("The given exponent " + exp + " cannot fit in the bit size " + expSize);
}
if (sig >= BIM.Pow(new BIM(2), sigSize))
{
throw new FormatException("The given significand " + sig + " cannot fit in the bit size " + (sigSize + 1));
}
return(new BigFloat(isNeg, sig, exp, sigSize, expSize));
}
internal BigDec(BIM mantissa, int exponent)
{
if (mantissa.IsZero)
{
this.mantissa = mantissa;
this.exponent = 0;
}
else
{
while (mantissa % ten == BIM.Zero)
{
mantissa = mantissa / ten;
exponent = exponent + 1;
}
this.mantissa = mantissa;
this.exponent = exponent;
}
}
public String ToDecimalString(int maxDigits)
{
string s = this.mantissa.ToString();
int digits = (this.mantissa >= 0) ? s.Length : s.Length - 1;
BIM max = BIM.Pow(10, maxDigits);
BIM min = -max;
if (this.exponent >= 0)
{
if (maxDigits < digits || maxDigits - digits < this.exponent)
{
return(String.Format("{0}.0", (this.mantissa >= 0) ? max.ToString() : min.ToString()));
}
else
{
return(String.Format("{0}{1}.0", s, new string('0', this.exponent)));
}
}
else
{
int exp = -this.exponent;
if (exp < digits)
{
int intDigits = digits - exp;
if (maxDigits < intDigits)
{
return(String.Format("{0}.0", (this.mantissa >= 0) ? max.ToString() : min.ToString()));
}
else
{
int fracDigits = Math.Min(maxDigits, digits - intDigits);
return(String.Format("{0}.{1}", s.Substring(0, intDigits), s.Substring(intDigits, fracDigits)));
}
}
else
{
int fracDigits = Math.Min(maxDigits, digits);
return(String.Format("0.{0}{1}", new string('0', exp - fracDigits), s.Substring(0, fracDigits)));
}
}
}
////////////////////////////////////////////////////////////////////////////
// Conversion operations
// ``floor`` rounds towards negative infinity (like SMT-LIBv2's to_int).
/// <summary>
/// Computes the floor and ceiling of this BigDec. Note the choice of rounding towards negative
/// infinity rather than zero for floor is because SMT-LIBv2's to_int function floors this way.
/// </summary>
/// <param name="floor">The Floor (rounded towards negative infinity)</param>
/// <param name="ceiling">Ceiling (rounded towards positive infinity)</param>
public void FloorCeiling(out BIM floor, out BIM ceiling)
{
BIM n = this.mantissa;
int e = this.exponent;
if (n.IsZero)
{
floor = ceiling = n;
}
else if (0 <= e)
{
// it's an integer
for (; 0 < e; e--)
{
n = n * ten;
}
floor = ceiling = n;
}
else
{
// it's a non-zero integer, so the ceiling is one more than the floor
for (; e < 0 && !n.IsZero; e++)
{
n = n / ten; // Division rounds towards negative infinity
}
if (this.mantissa >= 0)
{
floor = n;
ceiling = n + 1;
}
else
{
ceiling = n;
floor = n - 1;
}
}
Debug.Assert(floor <= ceiling, "Invariant was not maintained");
}
public static BigDec operator +(BigDec x, BigDec y)
{
BIM m1 = x.mantissa;
int e1 = x.exponent;
BIM m2 = y.mantissa;
int e2 = y.exponent;
if (e2 < e1)
{
m1 = y.mantissa;
e1 = y.exponent;
m2 = x.mantissa;
e2 = x.exponent;
}
while (e2 > e1)
{
m2 = m2 * ten;
e2 = e2 - 1;
}
return(new BigDec(m1 + m2, e1));
}
public BIM Floor(BIM?minimum, BIM?maximum)
{
BIM n = this.mantissa;
if (this.exponent >= 0)
{
int e = this.exponent;
while (e > 0 && (minimum == null || minimum <= n) && (maximum == null || n <= maximum))
{
n = n * ten;
e = e - 1;
}
}
else
{
int e = -this.exponent;
while (e > 0 && !n.IsZero)
{
n = n / ten;
e = e - 1;
}
}
if (minimum != null && n < minimum)
{
return((BIM)minimum);
}
else if (maximum != null && maximum < n)
{
return((BIM)maximum);
}
else
{
return(n);
}
}
/// <summary>
/// Momentum equations for the u wind component - algebraic mixing lenght model
/// </summary>
/// <param name="IS">ADI direction for x cells</param>
/// <param name="JS">ADI direction for y cells</param>
/// <param name="Cmueh">Constant</param>
/// <param name="VISHMIN">Minimum horizontal turbulent exchange coefficients </param>
/// <param name="AREAxy">Area of a flow field cell</param>
/// <param name="UG">Geostrophic wind</param>
/// <param name="building_Z0">Roughness of buildings</param>
/// <param name="relax">Relaxation factor</param>
public static void Calculate(int IS, int JS, float Cmueh, float VISHMIN, float AREAxy, Single UG, float relax)
{
float DXK = Program.DXK; float DYK = Program.DYK;
Vector <float> DXK_V = new Vector <float>(DXK);
Vector <float> DYK_V = new Vector <float>(DYK);
Vector <float> VISHMIN_V = new Vector <float>(VISHMIN);
Vector <float> AREAxy_V = new Vector <float>(AREAxy);
Vector <float> UG_V = new Vector <float>(UG);
Parallel.For(3, Program.NII, Program.pOptions, i1 =>
{
Span <float> PIMU = stackalloc float[Program.KADVMAX + 1];
Span <float> QIMU = stackalloc float[Program.KADVMAX + 1];
Span <float> Mask = stackalloc float[SIMD];
Span <float> Mask2 = stackalloc float[SIMD];
Span <float> AIM_A = stackalloc float[SIMD];
Span <float> BIM_A = stackalloc float[SIMD];
Span <float> CIM_A = stackalloc float[SIMD];
Span <float> DIMU_A = stackalloc float[SIMD];
Vector <float> DVDXN, DVDXS, DUDXE, DUDXW, DWDXT, DWDXB;
Vector <float> DE, DW, DS, DN, DT, DB;
Vector <float> FE, FW, FS, FN, FT, FB;
Vector <float> PE, PW, PS, PN, PT, PB;
Vector <float> BIM, CIM, AE1, AW1, AS1, AN1, AIM;
Vector <float> DIM_U, windhilf;
Vector <float> DDPX;
Vector <float> UKSim_LV;
Vector <float> VKSjm_LV, WKSim_LV, WKSimM_LV, WKSkM_LV;
Vector <float> VKSimjm_LV, VKSimjp_LV, VKSjp_LV, UKip_LV, VKSim_LV;
Vector <float> WKS_V, VKS_V, UKS_V, DZK_V;
Vector <float> DXKDZK, DYKDZK, AP0_V, intern, intern2;
Vector <float> VIS, zs, mixL;
Vector <float> UK_LV, UKim_LV;
Vector <float> HOKART_KKART_V;
Vector <float> Mask_V = Vector <float> .Zero;
Vector <float> DUDZ, DVDZ;
int i = i1;
if (IS == -1)
{
i = Program.NII - i1 + 1;
}
for (int j1 = 2; j1 <= Program.NJJ - 1; ++j1)
{
int j = j1;
if (JS == -1)
{
j = Program.NJJ - j1 + 1;
}
if (Program.ADVDOM[i][j] == 1)
{
//inside a prognostic sub d omain
int jM1 = j - 1;
int jP1 = j + 1;
int iM1 = i - 1;
int iP1 = i + 1;
Single[] UK_L = Program.UK[i][j];
Single[] UKS_L = Program.UKS[i][j];
Single[] VKS_L = Program.VKS[i][j];
Single[] WKS_L = Program.WKS[i][j];
Single[] DPMNEW_L = Program.DPMNEW[i][j];
Single[] UKim_L = Program.UK[iM1][j];
Single[] UKip_L = Program.UK[iP1][j];
Single[] UKjm_L = Program.UK[i][jM1];
Single[] UKjp_L = Program.UK[i][jP1];
Single[] UKSim_L = Program.UKS[iM1][j];
Single[] VKSim_L = Program.VKS[iM1][j];
Single[] VKSimjm_L = Program.VKS[iM1][jM1];
Single[] VKSjm_L = Program.VKS[i][jM1];
Single[] VKSimjp_L = Program.VKS[iM1][jP1];
Single[] VKSjp_L = Program.VKS[i][jP1];
Single[] WKSim_L = Program.WKS[iM1][j];
Single[] DPMNEWim_L = Program.DPMNEW[iM1][j];
Single[] VKSipjp_L = Program.VKS[iP1][jP1];
Single[] VKSipjm_L = Program.VKS[iP1][jM1];
Single[] WKSip_L = Program.WK[iP1][j];
Single[] VK_L = Program.VK[i][j];
int Vert_Index_LL = Program.VerticalIndex[i][j];
float Ustern_terrain_helpterm = Program.UsternTerrainHelpterm[i][j];
float Ustern_obstacles_helpterm = Program.UsternObstaclesHelpterm[i][j];
bool ADVDOM_JM = (Program.ADVDOM[i][jM1] < 1) || (j == 2);
bool ADVDOM_JP = (Program.ADVDOM[i][jP1] < 1) || (j == Program.NJJ - 1);
bool ADVDOM_IM = (Program.ADVDOM[iM1][j] < 1) || (i == 2);
bool ADVDOM_IP = (Program.ADVDOM[iP1][j] < 1) || (i == Program.NII - 1);
float CUTK_L = Program.CUTK[i][j];
Single[] VEG_L = Program.VEG[i][j];
Single COV_L = Program.COV[i][j];
float Z0 = Program.Z0;
if (Program.AdaptiveRoughnessMax < 0.01)
{
//Use GRAMM Roughness with terrain or Roughness from point 1,1 without terrain
int IUstern = 1;
int JUstern = 1;
if ((Program.Topo == 1) && (Program.LandUseAvailable == true))
{
double x = i * Program.DXK + Program.GralWest;
double y = j * Program.DYK + Program.GralSouth;
double xsi1 = x - Program.GrammWest;
double eta1 = y - Program.GrammSouth;
IUstern = Math.Clamp((int)(xsi1 / Program.DDX[1]) + 1, 1, Program.NX);
JUstern = Math.Clamp((int)(eta1 / Program.DDY[1]) + 1, 1, Program.NY);
}
Z0 = Program.Z0Gramm[IUstern][JUstern];
}
else
{
Z0 = Program.Z0Gral[i][j];
}
int KKART_LL = Program.KKART[i][j];
HOKART_KKART_V = new Vector <float>(Program.HOKART[KKART_LL]);
int KSTART = 1;
if (CUTK_L == 0) // building heigth == 0 m
{
KSTART = KKART_LL + 1;
}
int KKART_LL_P1 = KKART_LL + 1;
int KEND = Vert_Index_LL + 1; // simpify for-loop
bool end = false; // flag for the last loop
int k_real = 0;
for (int k = KSTART; k < KEND; k += SIMD)
{
// to compute the top levels - reduce k, remember k_real and set end to true
k_real = k;
if (k > KEND - SIMD)
{
k = KEND - SIMD;
end = true;
}
int kM1 = k - 1;
int kP1 = k + 1;
WKS_V = new Vector <float>(WKS_L, k);
VKS_V = new Vector <float>(VKS_L, k);
UKS_V = new Vector <float>(UKS_L, k);
DZK_V = new Vector <float>(Program.DZK, k);
DXKDZK = DXK_V * DZK_V;
DYKDZK = DYK_V * DZK_V;
//turbulence modelling
zs = new Vector <float>(Program.HOKART, k) - HOKART_KKART_V - DZK_V * Vect_05;
VIS = Vector <float> .Zero;
// Create Mask if KKART_LL is between k and k + SIMD
bool mask_v_enable = false;
if (KKART_LL_P1 >= k && KKART_LL_P1 < (k + SIMD))
{
for (int ii = 0; ii < Mask.Length; ++ii)
{
if ((k + ii) > KKART_LL_P1)
{
Mask[ii] = 1;
}
else
{
Mask[ii] = 0;
}
}
Mask_V = new Vector <float>(Mask);
mask_v_enable = true;
}
if ((k + SIMD) > KKART_LL_P1)
{
//k-eps model
//float VIS = (float)Math.Sqrt(TURB_L[k]) * zs * Cmueh;
//mixing-length model
mixL = Vector.Min(Vect_0071 * zs, Vect_100);
//adapted mixing-leng th within vegetation layers
if (COV_L > 0)
{
mixL *= (Vect_1 - Vect_099 * new Vector <float>(COV_L));
//mixL = (float)Math.Min(0.071 * Math.Max(1 - Math.Min(2 * VEG_L[kM1], 1), 0.05) * zs, 100);
}
intern = (new Vector <float>(UK_L, kP1) - new Vector <float>(UK_L, kM1)) / (Vect_2 * DZK_V);
DUDZ = intern * intern;
intern = (new Vector <float>(VK_L, kP1) - new Vector <float>(VK_L, kM1)) / (Vect_2 * DZK_V);
DVDZ = intern * intern;
if (mask_v_enable)
{
VIS = Vector.Min(mixL * mixL * Vector.SquareRoot(Vect_05 * (DUDZ + DVDZ)), Vect_15) * Mask_V;
}
else
{
VIS = Vector.Min(mixL * mixL * Vector.SquareRoot(Vect_05 * (DUDZ + DVDZ)), Vect_15);
}
}
DE = Vector.Max(VIS, VISHMIN_V) * DYKDZK / DXK_V;
DW = DE;
DS = Vector.Max(VIS, VISHMIN_V) * DXKDZK / DYK_V;
DN = DS;
DT = Vector.Max(VIS, VISHMIN_V) * AREAxy_V / DZK_V;
DB = Vector <float> .Zero;
if (mask_v_enable)
{
DB = DT * Mask_V;
}
else if (k > KKART_LL_P1) // otherwise k < KKART_LL_P1 and DB=0!
{
DB = DT;
}
//BOUNDARY CONDITIONS FOR DIFFUSION TERMS
if (ADVDOM_JM)
{
DS = Vector <float> .Zero;
}
if (ADVDOM_JP)
{
DN = Vector <float> .Zero;
}
if (ADVDOM_IM)
{
DW = Vector <float> .Zero;
}
if (ADVDOM_IP)
{
DE = Vector <float> .Zero;
}
//ADVECTION TERMS
VKSimjp_LV = new Vector <float>(VKSimjp_L, k);
VKSjp_LV = new Vector <float>(VKSjp_L, k);
VKSim_LV = new Vector <float>(VKSim_L, k);
VKSimjm_LV = new Vector <float>(VKSimjm_L, k);
VKSjm_LV = new Vector <float>(VKSjm_L, k);
WKSim_LV = new Vector <float>(WKSim_L, k);
UKSim_LV = new Vector <float>(UKSim_L, k);
FE = UKS_V * DYKDZK;
FW = UKSim_LV * DYKDZK;
FS = Vect_025 * (VKSim_LV + VKS_V + VKSimjm_LV + VKSjm_LV) * DXKDZK;
FN = Vect_025 * (VKSim_LV + VKS_V + VKSimjp_LV + VKSjp_LV) * DXKDZK;
FT = Vect_025 * (WKSim_LV + WKS_V + new Vector <float>(WKSim_L, kP1) + new Vector <float>(WKS_L, kP1)) * AREAxy_V;
FB = Vector <float> .Zero;
WKSkM_LV = new Vector <float>(WKS_L, kM1);
WKSimM_LV = new Vector <float>(WKSim_L, kM1);
if (mask_v_enable)
{
FB = Vect_025 * (WKSim_LV + WKS_V + WKSimM_LV + WKSkM_LV) * AREAxy_V * Mask_V;
}
else if (k > KKART_LL_P1) // otherwise k < KKART_LL_P1 and FB=0!
{
FB = Vect_025 * (WKSim_LV + WKS_V + WKSimM_LV + WKSkM_LV) * AREAxy_V;
}
//PECLET NUMBERS
DE = Vector.Max(DE, Vect_0001);
DB = Vector.Max(DB, Vect_0001);
DW = Vector.Max(DW, Vect_0001);
DS = Vector.Max(DS, Vect_0001);
DN = Vector.Max(DN, Vect_0001);
DT = Vector.Max(DT, Vect_0001);
PE = Vector.Abs(FE / DE);
PB = Vector.Abs(FB / DB);
PW = Vector.Abs(FW / DW);
PS = Vector.Abs(FS / DS);
PN = Vector.Abs(FN / DN);
PT = Vector.Abs(FT / DT);
//POWER LAW ADVECTION SCHEME
intern = Vect_1 - Vect_01 * PT;
BIM = DT * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(-FT, Vect_0);
intern = Vect_1 - Vect_01 * PB;
CIM = DB * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(FB, Vect_0);
intern = Vect_1 - Vect_01 * PE;
AE1 = DE * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(-FE, Vect_0);
intern = Vect_1 - Vect_01 * PW;
AW1 = DW * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(FW, Vect_0);
intern = Vect_1 - Vect_01 * PS;
AS1 = DS * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(FS, Vect_0);
intern = Vect_1 - Vect_01 * PN;
AN1 = DN * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(-FN, Vect_0);
//UPWIND SCHEME
/*
* double BIM = DT + Program.fl_max(-FT, 0);
* double CIM = DB + Program.fl_max(FB, 0);
* double AE1 = DE + Program.fl_max(-FE, 0);
* double AW1 = DW + Program.fl_max(FW, 0);
* double AS1 = DS + Program.fl_max(FS, 0);
* double AN1 = DN + Program.fl_max(-FN, 0);
*/
AP0_V = new Vector <float>(PrognosticFlowfield.AP0, k);
AIM = BIM + CIM + AW1 + AS1 + AE1 + AN1 + AP0_V;
//SOURCE TERMS
intern2 = Vect_05 * (VKSim_LV + VKS_V);
intern = Vect_05 * (UKSim_LV + UKS_V);
windhilf = Vector.Max(Vector.SquareRoot(intern * intern + intern2 * intern2), Vect_001);
DDPX = new Vector <float>(DPMNEWim_L, k) - new Vector <float>(DPMNEW_L, k);
UKim_LV = new Vector <float>(UKim_L, k);
UKip_LV = new Vector <float>(UKip_L, k);
UKSim_LV = new Vector <float>(UKSim_L, k);
UK_LV = new Vector <float>(UK_L, k);
DIM_U = AW1 * UKim_LV +
AS1 * new Vector <float>(UKjm_L, k) +
AE1 * UKip_LV +
AN1 * new Vector <float>(UKjp_L, k) +
AP0_V * Vect_05 * (UKSim_LV + UKS_V) +
DDPX * DYKDZK +
(Program.CorolisParam * (UG_V - UK_LV) -
new Vector <float>(VEG_L, kM1) * UK_LV * windhilf) * AREAxy_V * DZK_V;
//BOUNDARY CONDITION AT SURFACES (OBSTACLES AND TERRAIN)
if ((k <= KKART_LL_P1) && ((k + SIMD) > KKART_LL_P1))
{
Mask2.Clear();
//Array.Clear(Mask2, 0, Mask2.Length);
int ii = KKART_LL_P1 - k; // 0 to SIMD - 1
Mask2[ii] = 1; // Set the mask2 at SIMD position k == KKART_LL_P1 to 1
intern = Vect_05 * (UKSim_LV + UKS_V);
intern2 = Vect_05 * (VKSim_LV + VKS_V);
windhilf = Vector.Max(Vector.SquareRoot(intern * intern + intern2 * intern2), Vect_01);
if (CUTK_L < 1) // building heigth < 1 m
{
// above terrain
float Ustern_Buildings = Ustern_terrain_helpterm * windhilf[ii];
if (Z0 >= DZK_V[ii] * 0.1F)
{
int ind = k + ii + 1;
Ustern_Buildings = Ustern_terrain_helpterm * MathF.Sqrt(Program.Pow2(0.5F * ((UKSim_L[ind]) + UKS_L[ind])) + Program.Pow2(0.5F * ((VKSim_L[ind]) + VKS_L[ind])));
}
Vector <float> Ustern_Buildings_V = new Vector <float>(Ustern_Buildings * Ustern_Buildings);
DIM_U -= UK_LV / windhilf * Ustern_Buildings_V * AREAxy_V * new Vector <float>(Mask2);
}
else
{
//above a building
float Ustern_Buildings = Ustern_obstacles_helpterm * windhilf[ii];
Vector <float> Ustern_Buildings_V = new Vector <float>(Ustern_Buildings * Ustern_Buildings);
DIM_U -= UK_LV / windhilf * Ustern_Buildings_V * AREAxy_V * new Vector <float>(Mask2);
}
}
//additional terms of the eddy-viscosity model
if (k > KKART_LL_P1)
{
DUDXE = (UKip_LV - UK_LV) * DYKDZK;
DUDXW = (UK_LV - UKim_LV) * DYKDZK;
DVDXN = (Vect_05 * (new Vector <float>(VKSipjp_L, k) + VKSjp_LV) - Vect_05 * (VKSjp_LV + VKSimjp_LV)) * DXKDZK;
DVDXS = (Vect_05 * (new Vector <float>(VKSipjm_L, k) + VKSjm_LV) - Vect_05 * (VKSjm_LV + VKSimjm_LV)) * DXKDZK;
DWDXT = (Vect_05 * (new Vector <float>(WKSip_L, k) + WKS_V) - Vect_05 * (WKS_V + WKSim_LV)) * AREAxy_V;
DWDXB = (Vect_05 * (new Vector <float>(WKSip_L, kM1) + WKSkM_LV) - Vect_05 * (WKSkM_LV + WKSimM_LV)) * AREAxy_V;
if (mask_v_enable) // compute ADD_DIFF and add to DIMW
{
DIM_U += VIS / DXK_V * (DUDXE - DUDXW + DVDXN - DVDXS + DWDXT - DWDXB) * Mask_V;
}
else
{
DIM_U += VIS / DXK_V * (DUDXE - DUDXW + DVDXN - DVDXS + DWDXT - DWDXB);
}
}
//RECURRENCE FORMULA
int kint_s = 0;
if (end) // restore original indices
{
kint_s = k_real - k;
k_real -= kint_s;
}
AIM.CopyTo(AIM_A);
BIM.CopyTo(BIM_A);
CIM.CopyTo(CIM_A);
DIM_U.CopyTo(DIMU_A);
for (int kint = kint_s; kint < AIM_A.Length; ++kint) // loop over all SIMD values
{
int index_i = k_real + kint;
if (index_i < KEND)
{
if (index_i > KKART_LL_P1)
{
float TERMP = 1 / (AIM_A[kint] - CIM_A[kint] * PIMU[index_i - 1]);
PIMU[index_i] = BIM_A[kint] * TERMP;
QIMU[index_i] = (DIMU_A[kint] + CIM_A[kint] * QIMU[index_i - 1]) * TERMP;
}
else
{
float TERMP = 1 / AIM_A[kint];
PIMU[index_i] = BIM_A[kint] * TERMP;
QIMU[index_i] = DIMU_A[kint] * TERMP;
}
}
}
if (end)
{
k = KEND + 1;
}
} // loop over all k
//OBTAIN NEW U-COMPONENTS
int KKARTm_LL = Math.Max(KKART_LL, Program.KKART[i - 1][j]);
lock (UK_L)
{
for (int k = Vert_Index_LL; k >= KSTART; --k)
{
if (KKARTm_LL < k)
{
UK_L[k] += relax * (PIMU[k] * UK_L[k + 1] + QIMU[k] - UK_L[k]);
}
}
}
}
}
});
}
public static BigDec FromBigInt(BIM v)
{
return(new BigDec(v, 0));
}
public BigFloat(String value, int significandSize, int exponentSize) {
this.exponentSize = exponentSize;
this.significandSize = significandSize;
this.exponent = BIM.Zero;
this.significand = BIM.Zero;
this.value = value;
if (value.Equals("nan"))
this.value = "NaN";
this.isNeg = value[0] == '-';
}
public static BigFloat FromBigInt(BIM v, int significandSize, int exponentSize)
{
return(new BigFloat(v.ToString(), significandSize, exponentSize));
}
/// <summary>
/// Momentum equations for the w wind component - algebraic mixing lenght model
/// </summary>
public static void Calculate(int IS, int JS, float Cmueh, float VISHMIN, float AREAxy, float building_Z0, float relax)
{
Vector <float> DXK_V = new Vector <float>(Program.DXK);
Vector <float> DYK_V = new Vector <float>(Program.DYK);
Vector <float> VISHMIN_V = new Vector <float>(VISHMIN);
Vector <float> AREAxy_V = new Vector <float>(AREAxy);
Parallel.For(2, Program.NII, Program.pOptions, i1 =>
{
int KKART_LL, Vert_Index_LL;
Span <float> PIMW = stackalloc float [Program.KADVMAX + 1];
Span <float> QIMW = stackalloc float [Program.KADVMAX + 1];
Span <float> Mask = stackalloc float [SIMD];
Span <float> AIM_A = stackalloc float [SIMD];
Span <float> BIM_A = stackalloc float [SIMD];
Span <float> CIM_A = stackalloc float [SIMD];
Span <float> DIMW_A = stackalloc float [SIMD];
Vector <float> DUDZE, DUDZW, DVDZN, DVDZS, DWDZT, DWDZB;
Vector <float> DE, DW, DS, DN, DT, DB;
Vector <float> FE, FW, FS, FN, FT, FB;
Vector <float> PE, PW, PS, PN, PT, PB;
Vector <float> BIM, CIM, AE1, AW1, AS1, AN1, AIM;
Vector <float> DIMW, windhilf;
Vector <float> DDPZ;
Vector <float> UKSim_LV, UKSimM_LV;
Vector <float> VKSjm_LV, VKSjmM_LV;
Vector <float> WKS_V, VKS_V, UKS_V, DZK_V;
Vector <float> DXKDZK, DYKDZK, AP0_V, intern, intern2;
Vector <float> VIS, zs, mixL;
Vector <float> HOKART_KKART;
Vector <float> Mask_V = Vector <float> .Zero;
Vector <float> DUDZ, DVDZ;
Vector <float> UKS_M_V, VKS_M_V, WK_LV;
float Ustern_terrain_helpterm, Ustern_obstacles_helpterm;
int i = i1;
if (IS == -1)
{
i = Program.NII - i1 + 1;
}
for (int j1 = 2; j1 < Program.NJJ; ++j1)
{
int j = j1;
if (JS == -1)
{
j = Program.NJJ - j1 + 1;
}
if (Program.ADVDOM[i][j] == 1)
{
int jM1 = j - 1;
int jP1 = j + 1;
int iM1 = i - 1;
int iP1 = i + 1;
Single[] WK_L = Program.WK[i][j];
Single[] WKim_L = Program.WK[iM1][j];
Single[] WKip_L = Program.WK[iP1][j];
Single[] WKjm_L = Program.WK[i][jM1];
Single[] WKjp_L = Program.WK[i][jP1];
Single[] UKS_L = Program.UKS[i][j];
Single[] VKS_L = Program.VKS[i][j];
Single[] WKS_L = Program.WKS[i][j];
Single[] DPMNEW_L = Program.DPMNEW[i][j];
Single[] VKim_L = Program.VK[iM1][j];
Single[] VKip_L = Program.VK[iP1][j];
Single[] VKjm_L = Program.VK[i][jM1];
Single[] VKjp_L = Program.VK[i][jP1];
Single[] UKSim_L = Program.UKS[iM1][j];
Single[] UKSip_L = Program.UKS[iP1][j];
Single[] VKSjm_L = Program.VKS[i][jM1];
Single[] VKSjp_L = Program.VKS[i][jP1];
Single[] UK_L = Program.UK[i][j];
Single[] VK_L = Program.VK[i][j];
KKART_LL = Program.KKART[i][j];
Vert_Index_LL = Program.VerticalIndex[i][j];
Ustern_terrain_helpterm = Program.UsternTerrainHelpterm[i][j];
Ustern_obstacles_helpterm = Program.UsternObstaclesHelpterm[i][j];
bool ADVDOM_JM = (Program.ADVDOM[i][jM1] < 1) || (j == 2);
bool ADVDOM_JP = (Program.ADVDOM[i][jP1] < 1) || (j == Program.NJJ - 1);
bool ADVDOM_IM = (Program.ADVDOM[iM1][j] < 1) || (i == 2);
bool ADVDOM_IP = (Program.ADVDOM[iP1][j] < 1) || (i == Program.NII - 1);
Single[] VEG_L = Program.VEG[i][j];
Single COV_L = Program.COV[i][j];
HOKART_KKART = new Vector <float>(Program.HOKART[KKART_LL]);
int KSTART = 1;
if (Program.CUTK[i][j] == 0)
{
KSTART = KKART_LL + 1;
}
int KKART_LL_P1 = KKART_LL + 1;
int KEND = Vert_Index_LL + 1;
bool end = false; // flag for the last loop
int k_real = 0;
for (int k = KSTART; k < KEND; k += SIMD)
{
// to compute the top levels - reduce k, remember k_real and set end to true
k_real = k;
if (k > KEND - SIMD)
{
k = KEND - SIMD;
end = true;
}
int kM1 = k - 1;
int kP1 = k + 1;
WKS_V = new Vector <float>(WKS_L, k);
VKS_V = new Vector <float>(VKS_L, k);
UKS_V = new Vector <float>(UKS_L, k);
DZK_V = new Vector <float>(Program.DZK, k);
DXKDZK = DXK_V * DZK_V;
DYKDZK = DYK_V * DZK_V;
UKS_M_V = new Vector <float>(UKS_L, kM1);
VKS_M_V = new Vector <float>(VKS_L, kM1);
//turbulence modelling
zs = new Vector <float>(Program.HOKART, k) - HOKART_KKART - DZK_V * Vect_05;
VIS = Vector <float> .Zero;
// Create Mask if KKART_LL is between k and k + SIMD
bool mask_v_enable = false;
if (KKART_LL_P1 >= k && KKART_LL_P1 < (k + SIMD))
{
for (int ii = 0; ii < Mask.Length; ++ii)
{
if ((k + ii) > KKART_LL_P1)
{
Mask[ii] = 1;
}
else
{
Mask[ii] = 0;
}
}
Mask_V = new Vector <float>(Mask);
mask_v_enable = true;
}
if ((k + SIMD) > KKART_LL_P1)
{
//k-eps model
//float VIS = (float)Math.Sqrt(TURB_L[k]) * zs * Cmueh;
//mixing-length model
mixL = Vector.Min(Vect_0071 * zs, Vect_100);
//adapted mixing-leng th within vegetation layers
if (COV_L > 0)
{
mixL *= (Vect_1 - Vect_099 * new Vector <float>(COV_L));
//mixL = (float)Math.Min(0.071 * Math.Max(1 - Math.Min(2 * VEG_L[kM1], 1), 0.05) * zs, 100);
}
intern = (new Vector <float>(UK_L, kP1) - new Vector <float>(UK_L, kM1)) / (Vect_2 * DZK_V);
DUDZ = intern * intern;
intern = (new Vector <float>(VK_L, kP1) - new Vector <float>(VK_L, kM1)) / (Vect_2 * DZK_V);
DVDZ = intern * intern;
if (mask_v_enable)
{
VIS = Vector.Min(mixL * mixL * Vector.SquareRoot(Vect_05 * (DUDZ + DVDZ)), Vect_15) * Mask_V;
}
else
{
VIS = Vector.Min(mixL * mixL * Vector.SquareRoot(Vect_05 * (DUDZ + DVDZ)), Vect_15);
}
}
DE = Vector.Max(VIS, VISHMIN_V) * DYKDZK / DXK_V;
DW = DE;
DS = Vector.Max(VIS, VISHMIN_V) * DXKDZK / DYK_V;
DN = DS;
DT = Vector.Max(VIS, VISHMIN_V) * AREAxy_V / DZK_V;
DB = Vector <float> .Zero;
if (mask_v_enable)
{
DB = DT * Mask_V;
}
else if (k > KKART_LL_P1) // otherwise k < KKART_LL_P1 and DB=0!
{
DB = DT;
}
//BOUNDARY CONDITIONS FOR DIFFUSION TERMS
if (ADVDOM_JM)
{
DS = Vector <float> .Zero;
}
if (ADVDOM_JP)
{
DN = Vector <float> .Zero;
}
if (ADVDOM_IM)
{
DW = Vector <float> .Zero;
}
if (ADVDOM_IP)
{
DE = Vector <float> .Zero;
}
//ADVECTION TERMS
UKSim_LV = new Vector <float>(UKSim_L, k);
UKSimM_LV = new Vector <float>(UKSim_L, kM1);
VKSjm_LV = new Vector <float>(VKSjm_L, k);
VKSjmM_LV = new Vector <float>(VKSjm_L, kM1);
FE = Vect_025 * (UKS_V + new Vector <float>(UKSip_L, k) + UKS_M_V + new Vector <float>(UKSip_L, kM1)) * DYKDZK;
FW = Vect_025 * (UKS_V + UKSim_LV + UKS_M_V + UKSimM_LV) * DYKDZK;
FS = Vect_025 * (VKS_V + VKSjm_LV + VKS_M_V + VKSjmM_LV) * DXKDZK;
FN = Vect_025 * (VKS_V + new Vector <float>(VKSjp_L, k) + VKS_M_V + new Vector <float>(VKSjp_L, kM1)) * DXKDZK;
FT = WKS_V * AREAxy_V;
FB = Vector <float> .Zero;
if (mask_v_enable)
{
FB = new Vector <float>(WKS_L, kM1) * AREAxy_V * Mask_V;
}
else if (k > KKART_LL_P1) // otherwise k < KKART_LL_P1 and FB=0!
{
FB = new Vector <float>(WKS_L, kM1) * AREAxy_V;
}
//PECLET NUMBERS
DE = Vector.Max(DE, Vect_0001);
DB = Vector.Max(DB, Vect_0001);
DW = Vector.Max(DW, Vect_0001);
DS = Vector.Max(DS, Vect_0001);
DN = Vector.Max(DN, Vect_0001);
DT = Vector.Max(DT, Vect_0001);
PE = Vector.Abs(FE / DE);
PB = Vector.Abs(FB / DB);
PW = Vector.Abs(FW / DW);
PS = Vector.Abs(FS / DS);
PN = Vector.Abs(FN / DN);
PT = Vector.Abs(FT / DT);
//POWER LAW ADVECTION SCHEME
intern = Vect_1 - Vect_01 * PT;
BIM = DT * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(-FT, Vect_0);
intern = Vect_1 - Vect_01 * PB;
CIM = DB * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(FB, Vect_0);
intern = Vect_1 - Vect_01 * PE;
AE1 = DE * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(-FE, Vect_0);
intern = Vect_1 - Vect_01 * PW;
AW1 = DW * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(FW, Vect_0);
intern = Vect_1 - Vect_01 * PS;
AS1 = DS * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(FS, Vect_0);
intern = Vect_1 - Vect_01 * PN;
AN1 = DN * Vector.Max(Vect_0, intern * intern * intern * intern * intern)
+ Vector.Max(-FN, Vect_0);
//UPWIND SCHEME
/*
* double BIM = DT + Program.fl_max(-FT, 0);
* double CIM = DB + Program.fl_max(FB, 0);
* double AE1 = DE + Program.fl_max(-FE, 0);
* double AW1 = DW + Program.fl_max(FW, 0);
* double AS1 = DS + Program.fl_max(FS, 0);
* double AN1 = DN + Program.fl_max(-FN, 0);
*/
AP0_V = new Vector <float>(PrognosticFlowfield.AP0, k);
AIM = BIM + CIM + AW1 + AS1 + AE1 + AN1 + AP0_V;
//SOURCE TERMS
intern2 = Vect_05 * (VKSjm_LV + VKS_V);
intern = Vect_05 * (UKSim_LV + UKS_V);
windhilf = Vector.Max(Vector.SquareRoot(intern * intern + intern2 * intern2), Vect_001);
DDPZ = new Vector <float>(DPMNEW_L, kM1) - new Vector <float>(DPMNEW_L, k);
WK_LV = new Vector <float>(WK_L, k);
DIMW = AW1 * new Vector <float>(WKim_L, k) +
AS1 * new Vector <float>(WKjm_L, k) +
AE1 * new Vector <float>(WKip_L, k) +
AN1 * new Vector <float>(WKjp_L, k) +
AP0_V * Vect_05 * (new Vector <float>(WKS_L, kM1) + WKS_V) +
DDPZ * AREAxy_V -
new Vector <float>(VEG_L, kM1) * WK_LV * windhilf * AREAxy_V * DZK_V;
//additional terms of the eddy-viscosity model
if (k > KKART_LL_P1)
{
DUDZE = (Vect_05 * (new Vector <float>(UKS_L, kP1) + UKS_V) - Vect_05 * (UKS_V + UKS_M_V)) * DYKDZK;
DUDZW = (Vect_05 * (new Vector <float>(UKSim_L, kP1) + UKSim_LV) - Vect_05 * (UKSim_LV + UKSimM_LV)) * DYKDZK;
DVDZN = (Vect_05 * (new Vector <float>(VKS_L, kP1) + VKS_V) - Vect_05 * (VKS_V + VKS_M_V)) * DXKDZK;
DVDZS = (Vect_05 * (new Vector <float>(VKSjm_L, kP1) + VKSjm_LV) - Vect_05 * (VKSjm_LV + VKSjmM_LV)) * DXKDZK;
DWDZT = (new Vector <float>(WK_L, kP1) - WK_LV) * AREAxy_V;
DWDZB = (WK_LV - new Vector <float>(WK_L, kM1)) * AREAxy_V;
if (mask_v_enable) // compute ADD_DIFF and add to DIMW
{
DIMW += VIS / DZK_V * (DUDZE - DUDZW + DVDZN - DVDZS + DWDZT - DWDZB) * Mask_V;
}
else
{
DIMW += VIS / DZK_V * (DUDZE - DUDZW + DVDZN - DVDZS + DWDZT - DWDZB);
}
}
//RECURRENCE FORMULA
int kint_s = 0;
if (end) // restore original indices
{
kint_s = k_real - k;
k_real -= kint_s;
}
AIM.CopyTo(AIM_A);
BIM.CopyTo(BIM_A);
CIM.CopyTo(CIM_A);
DIMW.CopyTo(DIMW_A);
for (int kint = kint_s; kint < AIM_A.Length; ++kint) // loop over all SIMD values
{
int index_i = k_real + kint;
if (index_i < KEND)
{
if (index_i > KKART_LL_P1)
{
float TERMP = 1 / (AIM_A[kint] - CIM_A[kint] * PIMW[index_i - 1]);
PIMW[index_i] = BIM_A[kint] * TERMP;
QIMW[index_i] = (DIMW_A[kint] + CIM_A[kint] * QIMW[index_i - 1]) * TERMP;
}
else
{
float TERMP = 1 / AIM_A[kint];
PIMW[index_i] = BIM_A[kint] * TERMP;
QIMW[index_i] = DIMW_A[kint] * TERMP;
}
}
}
if (end)
{
k = KEND + 1;
}
} // loop over all k
//OBTAIN NEW W-COMPONENTS
for (int k = Vert_Index_LL; k >= KSTART; --k)
{
WK_L[k] += relax * (PIMW[k] * WK_L[k + 1] + QIMW[k] - WK_L[k]);
}
}
}
});
}
/// <summary>
/// Exports spatial elements, including rooms, areas and spaces. 2nd level space boundaries.
/// </summary>
/// <param name="ifcExporter">
/// The Exporter object.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="document">
/// The Revit document.
/// </param>
/// <param name="filterView">
/// The view not exported.
/// </param>
/// <param name="spaceExported">
/// The output boolean value indicates if exported successfully.
/// </param>
public static void ExportSpatialElement2ndLevel(BIM.IFC.Exporter.Exporter ifcExporter, ExporterIFC exporterIFC, Document document, View filterView, ref bool spaceExported)
{
using (SubTransaction st = new SubTransaction(document))
{
st.Start();
EnergyAnalysisDetailModel model = null;
try
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction transaction = new IFCTransaction(file))
{
EnergyAnalysisDetailModelOptions options = new EnergyAnalysisDetailModelOptions();
options.Tier = EnergyAnalysisDetailModelTier.SecondLevelBoundaries; //2nd level space boundaries
options.SimplifyCurtainSystems = true;
try
{
model = EnergyAnalysisDetailModel.Create(document, options);
}
catch (System.Exception)
{
spaceExported = false;
return;
}
IList<EnergyAnalysisSpace> spaces = model.GetAnalyticalSpaces();
spaceExported = true;
foreach (EnergyAnalysisSpace space in spaces)
{
SpatialElement spatialElement = document.GetElement(space.SpatialElementId) as SpatialElement;
if (spatialElement == null)
continue;
//quick reject
bool isArea = spatialElement is Area;
if (isArea)
{
if (!IsAreaGrossInterior(exporterIFC, spatialElement))
continue;
}
//current view only
if (filterView != null && !ElementFilteringUtil.IsElementVisible(filterView, spatialElement))
continue;
//
if (!ElementFilteringUtil.ShouldCategoryBeExported(exporterIFC, spatialElement))
continue;
Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
View ownerView = spatialElement.Document.GetElement(spatialElement.OwnerViewId) as View;
if (ownerView != null)
geomOptions.View = ownerView;
GeometryElement geomElem = spatialElement.get_Geometry(geomOptions);
try
{
exporterIFC.PushExportState(spatialElement, geomElem);
using (ProductWrapper productWrapper = ProductWrapper.Create(exporterIFC, true))
{
ElementId levelId = spatialElement.Level != null ? spatialElement.Level.Id : ElementId.InvalidElementId;
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, spatialElement, null, null, levelId))
{
if (!CreateIFCSpace(exporterIFC, spatialElement, productWrapper, setter))
continue;
XYZ offset = GetSapceBoundaryOffset(setter);
//get boundary information from surfaces
IList<EnergyAnalysisSurface> surfaces = space.GetAnalyticalSurfaces();
foreach (EnergyAnalysisSurface surface in surfaces)
{
Element boundingElement = GetBoundaryElement(document, surface.OriginatingElementId);
IList<EnergyAnalysisOpening> openings = surface.GetAnalyticalOpenings();
IFCAnyHandle connectionGeometry = CreateConnectionSurfaceGeometry(file, surface, openings, offset);
CreateIFCSpaceBoundary(file, exporterIFC, spatialElement, boundingElement, setter.LevelId, connectionGeometry);
// try to add doors and windows for host objects if appropriate.
if (boundingElement is HostObject)
{
foreach (EnergyAnalysisOpening opening in openings)
{
Element openingBoundingElem = GetBoundaryElement(document, opening.OriginatingElementId);
IFCAnyHandle openingConnectionGeom = CreateConnectionSurfaceGeometry(file, opening, offset);
CreateIFCSpaceBoundary(file, exporterIFC, spatialElement, openingBoundingElem, setter.LevelId, openingConnectionGeom);
}
}
}
PropertyUtil.CreateInternalRevitPropertySets(exporterIFC, spatialElement, productWrapper);
CreateZoneInfos(exporterIFC, file, spatialElement, productWrapper);
CreateSpaceOccupantInfo(exporterIFC, file, spatialElement, productWrapper);
ifcExporter.ExportElementProperties(exporterIFC, spatialElement, productWrapper);
ifcExporter.ExportElementQuantities(exporterIFC, spatialElement, productWrapper);
}
}
}
catch (Exception ex)
{
ifcExporter.HandleUnexpectedException(ex, exporterIFC, spatialElement);
}
finally
{
exporterIFC.PopExportState();
}
}
transaction.Commit();
}
}
finally
{
if (model != null)
EnergyAnalysisDetailModel.Destroy(model);
}
st.RollBack();
}
}
/// <summary>
/// Export spatial elements, including rooms, areas and spaces. 2nd level space boundaries.
/// </summary>
/// <param name="ifcExporter">
/// The Exporter object.
/// </param>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="document">
/// The Revit document.
/// </param>
/// <param name="filterView">
/// The view not exported.
/// </param>
/// <param name="spaceExported">
/// The output boolean value indicates if exported successfully.
/// </param>
public static void ExportSpatialElement2ndLevel(BIM.IFC.Exporter.Exporter ifcExporter, ExporterIFC exporterIFC, Document document, View filterView)
{
using (SubTransaction st = new SubTransaction(document))
{
st.Start();
bool createEnergyAnalysisDetailModelFailed = false;
EnergyAnalysisDetailModel model = null;
try
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
EnergyAnalysisDetailModelOptions options = new EnergyAnalysisDetailModelOptions();
options.Tier = EnergyAnalysisDetailModelTier.SecondLevelBoundaries; //2nd level space boundaries
options.SimplifyCurtainSystems = true;
try
{
model = EnergyAnalysisDetailModel.Create(document, options);
}
catch (Exception)
{
createEnergyAnalysisDetailModelFailed = true;
throw;
}
IList<EnergyAnalysisSpace> spaces = model.GetAnalyticalSpaces();
foreach (EnergyAnalysisSpace space in spaces)
{
SpatialElement spatialElement = document.get_Element(space.SpatialElementId) as SpatialElement;
if (spatialElement == null)
continue;
//quick reject
bool isArea = spatialElement is Area;
if (isArea)
{
if (!IsAreaGrossInterior(exporterIFC, spatialElement))
continue;
}
//current view only
if (filterView != null && !ElementFilteringUtil.IsElementVisible(filterView, spatialElement))
continue;
//
if (!ElementFilteringUtil.ShouldCategoryBeExported(exporterIFC, spatialElement))
continue;
Options geomOptions = new Options();
View ownerView = spatialElement.Document.get_Element(spatialElement.OwnerViewId) as View;
if (ownerView != null)
geomOptions.View = ownerView;
GeometryElement geomElem = spatialElement.get_Geometry(geomOptions);
try
{
exporterIFC.PushExportState(spatialElement, geomElem);
using (IFCProductWrapper productWrapper = IFCProductWrapper.Create(exporterIFC, true))
{
ElementId levelId = spatialElement.Level != null ? spatialElement.Level.Id : ElementId.InvalidElementId;
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, spatialElement, null, null, levelId))
{
try
{
CreateIFCSpace(exporterIFC, spatialElement, productWrapper, setter);
}
catch (System.Exception)
{
continue;
}
//get boundary information from surfaces
IList<EnergyAnalysisSurface> surfaces = space.GetAnalyticalSurfaces();
foreach (EnergyAnalysisSurface surface in surfaces)
{
Element boundingElement = GetBoundaryElement(document, surface.OriginatingElementId);
if (boundingElement == null)
continue;
IList<EnergyAnalysisOpening> openings = surface.GetAnalyticalOpenings();
IFCAnyHandle connectionGeometry = CreateConnectionSurfaceGeometry(file, surface, openings);
CreateIFCSpaceBoundary(file, exporterIFC, spatialElement, boundingElement, connectionGeometry);
// try to add doors and windows for host objects if appropriate.
if (boundingElement is HostObject)
{
foreach (EnergyAnalysisOpening opening in openings)
{
Element openingBoundingElem = GetBoundaryElement(document, opening.OriginatingElementId);
IFCAnyHandle openingConnectionGeom = CreateConnectionSurfaceGeometry(file, opening);
CreateIFCSpaceBoundary(file, exporterIFC, spatialElement, openingBoundingElem, openingConnectionGeom);
}
}
}
ExporterIFCUtils.CreateSpatialElementPropertySet(exporterIFC, spatialElement, productWrapper);
ifcExporter.ExportElementProperties(exporterIFC, spatialElement, productWrapper);
ifcExporter.ExportElementQuantities(exporterIFC, spatialElement, productWrapper);
}
}
}
finally
{
exporterIFC.PopExportState();
}
}
tr.Commit();
}
}
catch (System.Exception ex)
{
document.Application.WriteJournalComment("IFC error: " + ex.ToString(), true);
}
finally
{
if (model != null)
EnergyAnalysisDetailModel.Destroy(model);
}
//if failed, just export the space element
if (createEnergyAnalysisDetailModelFailed)
{
IFCFile file = exporterIFC.GetFile();
using (IFCTransaction tr = new IFCTransaction(file))
{
ElementFilter spatialElementFilter = ElementFilteringUtil.GetSpatialElementFilter(document, exporterIFC);
FilteredElementCollector collector = (filterView == null) ? new FilteredElementCollector(document) : new FilteredElementCollector(document, filterView.Id);
collector.WherePasses(spatialElementFilter);
foreach (Element elem in collector)
{
SpatialElement spatialElement = elem as SpatialElement;
if (spatialElement == null)
continue;
//current view only
if (filterView != null && !ElementFilteringUtil.IsElementVisible(filterView, spatialElement))
continue;
//
if (!ElementFilteringUtil.ShouldCategoryBeExported(exporterIFC, spatialElement))
continue;
Options geomOptions = new Options();
View ownerView = spatialElement.Document.get_Element(spatialElement.OwnerViewId) as View;
if (ownerView != null)
geomOptions.View = ownerView;
GeometryElement geomElem = spatialElement.get_Geometry(geomOptions);
try
{
exporterIFC.PushExportState(spatialElement, geomElem);
using (IFCProductWrapper productWrapper = IFCProductWrapper.Create(exporterIFC, true))
{
ElementId levelId = spatialElement.Level != null ? spatialElement.Level.Id : ElementId.InvalidElementId;
using (IFCPlacementSetter setter = IFCPlacementSetter.Create(exporterIFC, spatialElement, null, null, levelId))
{
try
{
CreateIFCSpace(exporterIFC, spatialElement, productWrapper, setter);
}
catch (System.Exception)
{
continue;
}
if (!(spatialElement is Area))
ExporterIFCUtils.CreateSpatialElementPropertySet(exporterIFC, spatialElement, productWrapper);
ifcExporter.ExportElementProperties(exporterIFC, spatialElement, productWrapper);
ifcExporter.ExportElementQuantities(exporterIFC, spatialElement, productWrapper);
}
}
}
finally
{
exporterIFC.PopExportState();
}
}
tr.Commit();
}
}
st.RollBack();
}
}
// ``floor`` rounds towards negative infinity (like SMT-LIBv2's to_int).
/// <summary>
/// NOTE: This may give wrong results, it hasn't been tested extensively
/// If you're getting weird bugs, you may want to check this function out...
/// Computes the floor and ceiling of this BigFloat. Note the choice of rounding towards negative
/// infinity rather than zero for floor is because SMT-LIBv2's to_int function floors this way.
/// </summary>
/// <param name="floor">The Floor (rounded towards negative infinity)</param>
/// <param name="ceiling">Ceiling (rounded towards positive infinity)</param>
public void FloorCeiling(out BIM floor, out BIM ceiling)
{
BIM two = new BIM(2);
BIM sig = Significand + BIM.Pow(two, SignificandSize); //Add hidden bit
BIM exp = Exponent - BIM.Pow(two, ExponentSize-1) + 1;
while (exp > BIM.Zero) {
exp--;
sig = sig << 1;
}
sig = sig >> SignificandSize;
if (isNeg) {
ceiling = -sig + 1;
floor = -sig;
}
else {
ceiling = sig + 1;
floor = sig;
}
}
/// <summary>
/// NOTE: THIS METHOD MAY NOT WORK AS EXPECTED!!!!
/// Converts value.dec_value to a the closest float approximation with the given significandSize, exponentSize
/// Returns the result of this calculation
/// </summary>
/// <param name="value"></param>
/// <param name="power"></param>
/// <param name="significandSize"></param>
/// <param name="exponentSize"></param>
/// <returns></returns>
public static BigFloat Round(BIM value, BIM dec_value, int exponentSize, int significandSize)
{
int exp = 0;
BIM one = new BIM(1);
BIM ten = new BIM(10);
BIM dec_max = new BIM(0); //represents the order of magnitude of dec_value for carrying during calculations
//First, determine the exponent
while (value > one) { //Divide by two, increment exponent by 1
if (!(value % two).IsZero) { //Add "1.0" to the decimal
dec_max = new BIM(10);
while (dec_max < dec_value)
dec_max = dec_max * ten;
dec_value = dec_value + dec_max;
}
value = value / two;
if (!(dec_value % ten).IsZero)
dec_value = dec_value * ten; //Creates excess zeroes to avoid losing data during division
dec_value = dec_value / two;
exp++;
}
if (value.IsZero && !dec_value.IsZero) {
dec_max = new BIM(10);
while (dec_max < dec_value)
dec_max = dec_max * ten;
while (value.IsZero) {//Multiply by two, decrement exponent by 1
dec_value = dec_value * two;
if (dec_value >= dec_max) {
dec_value = dec_value - dec_max;
value = value + one;
}
exp--;
}
}
//Second, calculate the significand
value = new BIM(0); //remove implicit bit
dec_max = new BIM(10);
while (dec_max < dec_value)
dec_max = dec_max * ten;
for (int i = significandSize; i > 0 && !dec_value.IsZero; i--) { //Multiply by two until the significand is fully calculated
dec_value = dec_value * two;
if (dec_value >= dec_max) {
dec_value = dec_value - dec_max;
value = value + two_n(i); //Note that i is decrementing so that the most significant bit is left-most in the representation
}
}
return new BigFloat(false, BIM.Zero, BIM.Parse(value.ToString()), exponentSize, significandSize); //Sign not actually checked...
}
public static BigFloat FromBigInt(BIM v)
{
return(new BigFloat(v.ToString(), 24, 8));
}
public static BigFloat operator *(BigFloat x, BigFloat y)
{
Contract.Requires(x.exponentSize == y.exponentSize);
Contract.Requires(x.significandSize == y.significandSize);
if (x.value == "NaN" || y.value == "NaN" || (x.value == "+oo" || x.value == "-oo") && y.IsZero || (y.value == "+oo" || y.value == "-oo") && x.IsZero)
{
return(new BigFloat("NaN", x.significandSize, x.exponentSize));
}
if (x.value != "" || y.value != "")
{
bool xSignBitSet = x.value == "" ? x.isSignBitSet : x.value[0] == '-';
bool ySignBitSet = y.value == "" ? y.isSignBitSet : y.value[0] == '-';
return(new BigFloat((xSignBitSet ^ ySignBitSet ? "-" : "+") + "oo", x.significandSize, x.exponentSize));
}
BIM xsig = x.significand, ysig = y.significand;
BIM xexp = x.exponent, yexp = y.exponent;
BIM hiddenBitPow = BIM.Pow(2, x.significandSize - 1);
if (xexp > 0)
{
xsig += hiddenBitPow;
}
else
{
++xexp;
}
if (yexp > 0)
{
ysig += hiddenBitPow;
}
else
{
++yexp;
}
ysig *= xsig;
yexp += xexp - (BIM.Pow(2, x.exponentSize - 1) - 1) - (x.significandSize - 1);
while (ysig >= hiddenBitPow * 2 || yexp <= 0)
{
ysig >>= 1;
++yexp;
}
while (ysig < hiddenBitPow && yexp > 1)
{
ysig <<= 1;
--yexp;
}
if (ysig < hiddenBitPow)
{
yexp = 0;
}
else
{
ysig -= hiddenBitPow;
}
if (yexp >= BIM.Pow(2, x.exponentSize) - 1)
{
return(new BigFloat(x.isSignBitSet ^ y.isSignBitSet ? "-oo" : "+oo", x.significandSize, x.exponentSize));
}
return(new BigFloat(x.isSignBitSet ^ y.isSignBitSet, ysig, yexp, x.significandSize, x.exponentSize));
}
public static BigFloat FromBigInt(BIM v, int significandSize, int exponentSize)
{
return new BigFloat(v.ToString(), significandSize, exponentSize);
}
public static BigFloat FromBigInt(BIM v) {
return new BigFloat(v.ToString(), 24, 8);
}
public static BigFloat operator +(BigFloat x, BigFloat y)
{
Contract.Requires(x.exponentSize == y.exponentSize);
Contract.Requires(x.significandSize == y.significandSize);
if (x.value != "" || y.value != "")
{
if (x.value == "NaN" || y.value == "NaN" || x.value == "+oo" && y.value == "-oo" || x.value == "-oo" && y.value == "+oo")
{
return(new BigFloat("NaN", x.significandSize, x.exponentSize));
}
if (x.value != "")
{
return(new BigFloat(x.value, x.significandSize, x.exponentSize));
}
return(new BigFloat(y.value, y.significandSize, y.exponentSize));
}
if (x.exponent > y.exponent)
{
BigFloat temp = x;
x = y;
y = temp;
}
BIM xsig = x.significand, ysig = y.significand;
BIM xexp = x.exponent, yexp = y.exponent;
if (yexp - xexp > x.significandSize) //One of the numbers is relatively insignificant
{
return(new BigFloat(y.isSignBitSet, y.significand, y.exponent, y.significandSize, y.exponentSize));
}
BIM hiddenBitPow = BIM.Pow(2, x.significandSize - 1);
if (xexp > 0)
{
xsig += hiddenBitPow;
}
else
{
++xexp;
}
if (yexp > 0)
{
ysig += hiddenBitPow;
}
else
{
++yexp;
}
if (x.isSignBitSet)
{
xsig = -xsig;
}
if (y.isSignBitSet)
{
ysig = -ysig;
}
xsig >>= (int)(yexp - xexp); //Guaranteed to fit in a 32-bit integer
ysig += xsig;
bool isNeg = ysig < 0;
ysig = BIM.Abs(ysig);
if (ysig == 0)
{
return(new BigFloat(x.isSignBitSet && y.isSignBitSet, 0, 0, x.significandSize, x.exponentSize));
}
if (ysig >= hiddenBitPow * 2)
{
ysig >>= 1;
++yexp;
}
while (ysig < hiddenBitPow && yexp > 1)
{
ysig <<= 1;
--yexp;
}
if (ysig < hiddenBitPow)
{
yexp = 0;
}
else
{
ysig -= hiddenBitPow;
}
if (yexp >= BIM.Pow(2, x.exponentSize) - 1)
{
return(new BigFloat(y.isSignBitSet ? "-oo" : "+oo", x.significandSize, x.exponentSize));
}
return(new BigFloat(isNeg, ysig, yexp, x.significandSize, x.exponentSize));
}
public BigFloat(bool isNeg, BIM significand, BIM exponent, int significandSize, int exponentSize) {
this.exponentSize = exponentSize;
this.exponent = exponent;
this.significand = significand;
this.significandSize = significandSize+1;
this.isNeg = isNeg;
this.value = "";
}
/// <summary>
/// NOTE: THIS METHOD MAY NOT WORK AS EXPECTED!!!!
/// Converts value.dec_value to a the closest float approximation with the given significandSize, exponentSize
/// Returns the result of this calculation
/// </summary>
/// <param name="value"></param>
/// <param name="power"></param>
/// <param name="significandSize"></param>
/// <param name="exponentSize"></param>
/// <returns></returns>
public static BigFloat Round(BIM value, BIM dec_value, int exponentSize, int significandSize)
{
int exp = 0;
BIM one = new BIM(1);
BIM ten = new BIM(10);
BIM dec_max = new BIM(0); //represents the order of magnitude of dec_value for carrying during calculations
//First, determine the exponent
while (value > one) //Divide by two, increment exponent by 1
{
if (!(value % two).IsZero) //Add "1.0" to the decimal
{
dec_max = new BIM(10);
while (dec_max < dec_value)
{
dec_max = dec_max * ten;
}
dec_value = dec_value + dec_max;
}
value = value / two;
if (!(dec_value % ten).IsZero)
{
dec_value = dec_value * ten; //Creates excess zeroes to avoid losing data during division
}
dec_value = dec_value / two;
exp++;
}
if (value.IsZero && !dec_value.IsZero)
{
dec_max = new BIM(10);
while (dec_max < dec_value)
{
dec_max = dec_max * ten;
}
while (value.IsZero)//Multiply by two, decrement exponent by 1
{
dec_value = dec_value * two;
if (dec_value >= dec_max)
{
dec_value = dec_value - dec_max;
value = value + one;
}
exp--;
}
}
//Second, calculate the significand
value = new BIM(0); //remove implicit bit
dec_max = new BIM(10);
while (dec_max < dec_value)
{
dec_max = dec_max * ten;
}
for (int i = significandSize; i > 0 && !dec_value.IsZero; i--) //Multiply by two until the significand is fully calculated
{
dec_value = dec_value * two;
if (dec_value >= dec_max)
{
dec_value = dec_value - dec_max;
value = value + two_n(i); //Note that i is decrementing so that the most significant bit is left-most in the representation
}
}
return(new BigFloat(false, BIM.Zero, BIM.Parse(value.ToString()), exponentSize, significandSize)); //Sign not actually checked...
}
public static BigDec FromBigInt(BIM v) {
return new BigDec(v, 0);
}
internal BigDec(BIM mantissa, int exponent) {
if (mantissa.IsZero) {
this.mantissa = mantissa;
this.exponent = 0;
}
else {
while (mantissa % ten == BIM.Zero) {
mantissa = mantissa / ten;
exponent = exponent + 1;
}
this.mantissa = mantissa;
this.exponent = exponent;
}
}
public static BigFloat FromString(String s)
{
/*
* String must be either of the format [-]0x^.^e*f*e*
* or of the special value formats: 0NaN*e* 0nan*e* 0+oo*e* 0-oo*e*
* Where ^ indicates a hexadecimal value and * indicates an integer value
*/
int posLastE = s.LastIndexOf('e');
int expSize = int.Parse(s.Substring(posLastE + 1));
if (expSize <= 1)
{
throw new FormatException("Exponent size must be greater than 1");
}
int posLastF = s.LastIndexOf('f');
int posSig = posLastF + 1;
if (posLastF == -1)//NaN, +oo, -oo
{
posSig = 4;
}
int sigSize = int.Parse(s.Substring(posSig, posLastE - posSig));
if (sigSize <= 1)
{
throw new FormatException("Significand size must be greater than 1");
}
if (posLastF == -1)//NaN, +oo, -oo
{
return(new BigFloat(s.Substring(1, 3), sigSize, expSize));
}
bool isNeg = s[0] == '-';
int posX = s.IndexOf('x');
int posSecondLastE = s.LastIndexOf('e', posLastE - 1);
string hexSig = s.Substring(posX + 1, posSecondLastE - (posX + 1));
BIM oldExp = BIM.Parse(s.Substring(posSecondLastE + 1, posLastF - (posSecondLastE + 1)));
string binSig = string.Join(string.Empty,
hexSig.Select(
c => (c == '.' ? "." : Convert.ToString(Convert.ToInt32(c.ToString(), 16), 2).PadLeft(4, '0'))
)
);
int posDec = binSig.IndexOf('.');
binSig = binSig.Remove(posDec, 1);
int posFirstOne = binSig.IndexOf('1');
int posLastOne = binSig.LastIndexOf('1');
if (posFirstOne == -1)
{
return(new BigFloat(isNeg, 0, 0, sigSize, expSize));
}
binSig = binSig.Substring(posFirstOne, posLastOne - posFirstOne + 1);
BIM bias = two_n(expSize - 1) - 1;
BIM upperBound = 2 * bias + 1;
BIM newExp = 4 * oldExp + bias + (posDec - posFirstOne - 1);
if (newExp <= 0)
{
if (-newExp <= (sigSize - 1) - binSig.Length)
{
binSig = new string('0', (int)-newExp) + binSig;
newExp = 0;
}
}
else
{
binSig = binSig.Substring(1);
}
if (newExp < 0 || newExp >= upperBound)
{
throw new FormatException("The given exponent cannot fit in the bit size " + expSize);
}
binSig = binSig.PadRight(sigSize - 1, '0');
if (binSig.Length > sigSize - 1)
{
throw new FormatException("The given significand cannot fit in the bit size " + (sigSize - 1));
}
BIM newSig = 0;
foreach (char b in binSig)
{
if (b != '.')
{
newSig <<= 1;
newSig += b - '0';
}
}
return(new BigFloat(isNeg, newSig, newExp, sigSize, expSize));
}
////////////////////////////////////////////////////////////////////////////
// Conversion operations
// ``floor`` rounds towards negative infinity (like SMT-LIBv2's to_int).
/// <summary>
/// Computes the floor and ceiling of this BigDec. Note the choice of rounding towards negative
/// infinity rather than zero for floor is because SMT-LIBv2's to_int function floors this way.
/// </summary>
/// <param name="floor">The Floor (rounded towards negative infinity)</param>
/// <param name="ceiling">Ceiling (rounded towards positive infinity)</param>
public void FloorCeiling(out BIM floor, out BIM ceiling) {
BIM n = this.mantissa;
int e = this.exponent;
if (n.IsZero) {
floor = ceiling = n;
} else if (0 <= e) {
// it's an integer
for (; 0 < e; e--) {
n = n * ten;
}
floor = ceiling = n;
} else {
// it's a non-zero integer, so the ceiling is one more than the floor
for (; e < 0 && !n.IsZero; e++) {
n = n / ten; // Division rounds towards negative infinity
}
if (this.mantissa >= 0) {
floor = n;
ceiling = n + 1;
} else {
ceiling = n;
floor = n - 1;
}
}
Debug.Assert(floor <= ceiling, "Invariant was not maintained");
}
////////////////////////////////////////////////////////////////////////////
// Conversion operations
// ``floor`` rounds towards negative infinity (like SMT-LIBv2's to_int).
/// <summary>
/// Computes the floor and ceiling of this BigFloat. Note the choice of rounding towards negative
/// infinity rather than zero for floor is because SMT-LIBv2's to_int function floors this way.
/// </summary>
/// <param name="floor">Floor (rounded towards negative infinity)</param>
/// <param name="ceiling">Ceiling (rounded towards positive infinity)</param>
public void FloorCeiling(out BIM floor, out BIM ceiling)
{
Contract.Requires(value == "");
BIM sig = significand;
BIM exp = exponent;
BIM hiddenBitPow = BIM.Pow(2, significandSize - 1);
if (exponent > 0)
{
sig += hiddenBitPow;
}
else
{
++exp;
}
exp -= (BIM.Pow(2, exponentSize - 1) - 1) + (significandSize - 1);
if (exp >= BIM.Zero)
{
while (exp >= int.MaxValue)
{
sig <<= int.MaxValue;
exp -= int.MaxValue;
}
sig <<= (int)exp;
floor = ceiling = (isSignBitSet ? -sig : sig);
}
else
{
exp = -exp;
if (exp > significandSize)
{
if (sig == 0)
{
floor = ceiling = 0;
}
else
{
ceiling = isSignBitSet ? 0 : 1;
floor = ceiling - 1;
}
}
else
{
BIM frac = sig & ((BIM.One << (int)exp) - 1);
sig >>= (int)exp; //Guaranteed to fit in a 32-bit integer
if (frac == 0)
{
floor = ceiling = (isSignBitSet ? -sig : sig);
}
else
{
ceiling = isSignBitSet ? -sig : sig + 1;
floor = ceiling - 1;
}
}
}
}
