private static int Math_Frexp(ILuaState lua) { double d = lua.L_CheckNumber(1); // Translate the double into sign, exponent and mantissa. long bits = BitConverter.DoubleToInt64Bits(d); // Note that the shift is sign-extended, hence the test against -1 not 1 bool negative = (bits < 0); int exponent = (int)((bits >> 52) & 0x7ffL); long mantissa = bits & 0xfffffffffffffL; // Subnormal numbers; exponent is effectively one higher, // but there's no extra normalisation bit in the mantissa if (exponent == 0) { exponent++; } // Normal numbers; leave exponent as it is but add extra // bit to the front of the mantissa else { mantissa = mantissa | (1L << 52); } // Bias the exponent. It's actually biased by 1023, but we're // treating the mantissa as m.0 rather than 0.m, so we need // to subtract another 52 from it. exponent -= 1075; if (mantissa == 0) { lua.PushNumber(0.0); lua.PushNumber(0.0); return(2); } /* Normalize */ while ((mantissa & 1) == 0) { /* i.e., Mantissa is even */ mantissa >>= 1; exponent++; } double m = (double)mantissa; double e = (double)exponent; while (m >= 1) { m /= 2.0; e += 1.0; } if (negative) { m = -m; } lua.PushNumber(m); lua.PushNumber(e); return(2); }
public void Randomize(double num) { int num1 = _seed; int num2 = !BitConverter.IsLittleEndian ? BitConverter.ToInt32(BitConverter.GetBytes(num), 0) : BitConverter.ToInt32(BitConverter.GetBytes(num), 4); int num3 = (num2 & (int)ushort.MaxValue ^ num2 >> 16) << 8; int num4 = num1 & -16776961 | num3; _seed = num4; }
/// <summary> /// Writes a value of the specified type to this buffer. /// </summary> /// <param name="value">DOUBLE value to be written.</param> /// <exception cref="System.IndexOutOfRangeException"/> public void Write(double value) { byte[] bytes = BitConverter.GetBytes(value); for (int i = 0; i < bytes.Length; i++) { memory[iterator++] = bytes[i]; } iterator = (iterator + fastAlign) & fastAlignNot; }
public void WriteRecord(Record record, long index) { Stream.Position = index * _pageSize; Stream.Write(BC.GetBytes(record.Radius), 0, sizeof(double)); Stream.Write(BC.GetBytes(record.Angle), 0, sizeof(short)); Stream.Flush(); DiskOperations++; }
/// <summary> /// A representation of the Double bits formatted for easy readability /// </summary> /// <param name="bits"></param> /// <returns></returns> public string ToString(long bits) { double x = BitConverter.Int64BitsToDouble(bits); string numStr = HexConverter.ConvertAny2Any(bits.ToString(), 10, 2); string padStr = "0000000000000000000000000000000000000000000000000000000000000000" + numStr; string bitStr = padStr.Substring(padStr.Length - 64); string str = bitStr.Substring(0, 1) + " " + bitStr.Substring(1, 12) + "(exp) " + bitStr.Substring(12) + " [ " + x + " ]"; return(str); }
public void Randomize() { System.DateTime now = System.DateTime.Now; float timer = (float)checked ((60 * now.Hour + now.Minute) * 60 + now.Second) + (float)now.Millisecond / 1000f; int num1 = _seed; int num2 = BitConverter.ToInt32(BitConverter.GetBytes(timer), 0); int num3 = (num2 & (int)ushort.MaxValue ^ num2 >> 16) << 8; int num4 = num1 & -16776961 | num3; _seed = num4; }
public Record ReadRecord(long index) { var record = new byte[_pageSize]; Stream.Position = index * _pageSize; Stream.Read(record, 0, _pageSize); DiskOperations++; return(new Record(BC.ToDouble(record, 0), BC.ToInt16(record, 8))); }
public static ushort ReadUInt16BE(byte[] bytes, int offset) { if (SysBitConverter.IsLittleEndian) { var v = ((ushort)bytes[offset] << 8) | ((ushort)bytes[offset + 1]); return((ushort)v); } return(SysBitConverter.ToUInt16(bytes, offset)); }
public static ulong ReadUInt32BE(byte[] bytes, int offset) { if (SysBitConverter.IsLittleEndian) { return(((uint)bytes[offset] << 24) | ((uint)bytes[offset + 1] << 16) | ((uint)bytes[offset + 2] << 8) | (uint)bytes[offset + 3]); } return(SysBitConverter.ToUInt64(bytes, offset)); }
public float VBNext(float num) { int num1 = _seed; if ((double)num != 0.0) { if ((double)num < 0.0) { long num2 = (long)BitConverter.ToInt32(BitConverter.GetBytes(num), 0) & (long)uint.MaxValue; num1 = checked ((int)(num2 + (num2 >> 24) & 16777215L)); } num1 = checked ((int)((long)num1 * 1140671485L + 12820163L & 16777215L)); } _seed = num1; return((float)num1 / 1.677722E+07f); }
/// <summary> /// /// </summary> /// <param name="num"></param> public void Add(double num) { long numBits = BitConverter.DoubleToInt64Bits(num); if (isFirst) { commonBits = numBits; commonSignExp = SignExpBits(commonBits); isFirst = false; return; } long numSignExp = SignExpBits(numBits); if (numSignExp != commonSignExp) { commonBits = 0; return; } commonMantissaBitsCount = NumCommonMostSigMantissaBits(commonBits, numBits); commonBits = ZeroLowerBits(commonBits, 64 - (12 + commonMantissaBitsCount)); }
/// <summary> /// Reads the value of the specified type from the buffer. /// </summary> /// <param name="value">The OUT variable to store the DOUBLE value in.</param> /// <exception cref="System.ArgumentException"/> /// <exception cref="System.ArgumentNullException"/> /// <exception cref="System.ArgumentOutOfRangeException"/> public void Read(out double value) { value = BitConverter.ToUInt16(memory, iterator); iterator = (iterator + (int)BufferTypeSize.Double + fastAlign) & fastAlignNot; }
/// <summary> /// Reads the value of the specified type from the buffer. /// </summary> /// <param name="value">The OUT variable to store the FLOAT value in.</param> /// <exception cref="System.ArgumentException"/> /// <exception cref="System.ArgumentNullException"/> /// <exception cref="System.ArgumentOutOfRangeException"/> public void Read(out float value) { value = BitConverter.ToSingle(memory, iterator); iterator = (iterator + (int)BufferTypeSize.Single + fastAlign) & fastAlignNot; }
public HttpStatusCode Upload(FileInfo mediaFile, string message, string keyword, string username, string twitter_id, ref string content) { // Message必須 if (string.IsNullOrEmpty(message)) { throw new ArgumentException("'Message' is required."); } // Check filetype and size if (Array.IndexOf(multimediaExt, mediaFile.Extension.ToLower()) > -1) { if (mediaFile.Length > TwitVideo.MaxMultiMediaFileSize) { throw new ArgumentException("File is too large."); } } else if (Array.IndexOf(pictureExt, mediaFile.Extension.ToLower()) > -1) { if (mediaFile.Length > TwitVideo.MaxPictureFileSize) { throw new ArgumentException("File is too large."); } } else { throw new ArgumentException("Service don't support this filetype."); } // Endpoint(URI+Token) const string URLBASE = "http://api.twitvideo.jp/oauth/upload/"; byte[] data = Encoding.ASCII.GetBytes(ApplicationSettings.TwitVideoConsumerKey.Substring(0, 9) + username); byte[] bHash; using (MD5CryptoServiceProvider md5provider = new MD5CryptoServiceProvider()) { bHash = md5provider.ComputeHash(data); } string url = URLBASE + BitConverter.ToString(bHash).ToLower().Replace("-", ""); // Parameters Dictionary <string, string> param = new Dictionary <string, string>(); param.Add("username", username); if (!string.IsNullOrEmpty(twitter_id)) { param.Add("twitter_id", twitter_id); } if (!string.IsNullOrEmpty(keyword)) { param.Add("keyword", keyword); } param.Add("type", "xml"); param.Add("message", message); List <KeyValuePair <string, FileInfo> > binary = new List <KeyValuePair <string, FileInfo> >(); binary.Add(new KeyValuePair <string, FileInfo>("media", mediaFile)); this.InstanceTimeout = 60000; // タイムアウト60秒 HttpWebRequest req = this.CreateRequest(HttpConnection.PostMethod, new Uri(url), param, binary, false); return(this.GetResponse(req, out content, null, false)); }
/// <summary> /// Reads the value of the specified type from the buffer. /// </summary> /// <param name="value">The OUT variable to store the INT value in.</param> /// <exception cref="System.ArgumentException"/> /// <exception cref="System.ArgumentNullException"/> /// <exception cref="System.ArgumentOutOfRangeException"/> public void Read(out int value) { value = BitConverter.ToInt32(memory, iterator); iterator = (iterator + (int)BufferTypeSize.Int32 + fastAlign) & fastAlignNot; }
internal static int GetShort(byte[] memory, int index) { return(BitConverter.ToInt16(memory, index)); }
public virtual ResStringPool ReadResStringPool(ResStringPool_header header) { var pool = new ResStringPool { Header = header, StringData = new List <string>(), StyleData = new List <List <ResStringPool_span> >() }; // Offsets of the string data, relative to header.StringStart var stringIndices = new List <uint>(); for (int i = 0; i < header.StringCount; i++) { stringIndices.Add(ReadUInt32()); } // Offset of the style data, relative to header.StylesStart var styleIndices = new List <uint>(); for (int i = 0; i < header.StyleCount; i++) { styleIndices.Add(ReadUInt32()); } // Keep track of how many bytes are left, to prevent us // from reading invalid data. long bytesLeft = header.Header.Size; bytesLeft -= header.Header.HeaderSize; bytesLeft -= 4 * header.StringCount; bytesLeft -= 4 * header.StyleCount; // Fetch the block which contains the string. If a styles section is // present, the strings block ends there; otherwise, it runs to the end // of this entry. uint stringsEnd = header.StyleCount > 0 ? header.StylesStart : header.Header.Size; byte[] rawStringData = ReadBytes((int)stringsEnd - (int)header.StringStart); bytesLeft -= rawStringData.Length; bool isUtf8 = (header.Flags & StringPoolFlags.UTF8_FLAG) == StringPoolFlags.UTF8_FLAG; foreach (uint startingIndex in stringIndices) { // The starting index specifies where the string starts. // We can now read the string in either UTF8 or UTF16 format. uint pos = startingIndex; if (isUtf8) { uint charLen = Helper.DecodeLengthUtf8(rawStringData, ref pos); uint byteLen = Helper.DecodeLengthUtf8(rawStringData, ref pos); string item = Encoding.UTF8.GetString(rawStringData, (int)pos, (int)byteLen); if (item.Length != charLen) { #if !CORECLR Debug.WriteLine("Warning: UTF-8 string length ({0}) not matching specified length ({1}).", item.Length, charLen); #endif } pool.StringData.Add(item); } else { uint charLen = Helper.DecodeLengthUtf16(rawStringData, ref pos); uint byteLen = charLen * 2; string item = Encoding.Unicode.GetString(rawStringData, (int)pos, (int)byteLen); pool.StringData.Add(item); } } // If styles are present, we should read them, too. if (header.StyleCount > 0) { byte[] rawStyleData = ReadBytes((int)header.Header.Size - (int)header.StylesStart); foreach (uint startingIndex in styleIndices) { // At startingIndex, there are N entries defining the individual tags (b, i,...) // that style the string at index i // They are terminated by a value with value END (0xFFFFFFFF) List <ResStringPool_span> styleData = new List <ResStringPool_span>(); int pos = (int)startingIndex; while (true) { var index = BitConverter.ToUInt32(rawStyleData, pos); var firstChar = BitConverter.ToUInt32(rawStyleData, pos + 4); var lastChar = BitConverter.ToUInt32(rawStringData, pos + 8); var span = new ResStringPool_span { Name = new ResStringPool_ref() { Index = index == 0xFFFFFFFFu ? (uint?)null : index }, FirstChar = firstChar, LastChar = lastChar, }; styleData.Add(span); if (span.IsEnd) { break; } pos += 12; } pool.StyleData.Add(styleData); } bytesLeft -= rawStyleData.Length; } // Make sure we didn't go out of bounds. if (bytesLeft < 0) { throw new InvalidDataException("The length of the content exceeds the ResStringPool block boundary."); } if (bytesLeft > 0) { // Padding: data is always aligned to 4 bytes. #if !CORECLR Debug.WriteLine("Warning: Garbage at the end of the StringPool block. Padding?"); #endif ReadBytes((int)bytesLeft); } return(pool); }