Sign In
Eric Fleegal's WebLog
. . . .
Options
Email Blog Author
RSS for posts
Atom
RSS for comments
OK
Search Blogs
Advanced search options...
Search In:
Everything
Blogs
Forums
People
Groups
Places
Pages
Date range:
All Time
Last Year
Last 6 Months
Last 3 Months
Last Month
Last Week
Last Two Days
Tags
C++ Programming
VC++ floating-point
Archive
Archives
October 2008
(1)
April 2008
(4)
September 2007
(1)
August 2006
(1)
September 2005
(1)
December 2004
(3)
July 2004
(5)
June 2004
(2)
May 2004
(5)
MSDN Blogs
>
Eric Fleegal's WebLog
Posts
Subscribe via RSS
Sort by:
Most Recent
|
Most Views
|
Most Comments
Excerpt View
|
Full Post View
Eric Fleegal's WebLog
Performance as a Design Consideration
Posted
over 4 years ago
by
Eric Fleegal1
1
Comments
For many years now I've been frustrated by industry development practices that approach software performance in an ad hoc manner rather than as a design issue. Every time I argue in favor of considering a feature’s potential performance issues up front...
Eric Fleegal's WebLog
Simplifying C++ NULL terminated string handling
Posted
over 4 years ago
by
Eric Fleegal1
1
Comments
I wrote the following short article several years ago. I've reproduced it here by request Once of the curious features of the C language is its lack of an integrated string type. Most programming languages developed in the 1960/70s included a basic...
Eric Fleegal's WebLog
How to do Object Properties in C++
Posted
over 4 years ago
by
Eric Fleegal1
0
Comments
One of the many useful features of modern languages like C# are object properties , as they provide a higher level of encapsulation than public fields. The field-like syntax is far easier to read and write than traditional C++ Get XXX and Set XXX functions...
Eric Fleegal's WebLog
#pragma once
Posted
over 4 years ago
by
Eric Fleegal1
2
Comments
Most C++ compilers now support the non-standard #pragma once compiler directive. This directive instructs the compiler to #include the file only once in a single compiland, and replaces the old C-style header sentinels (often called #include guards )...
Eric Fleegal's WebLog
Eschew Obfuscation
Posted
over 4 years ago
by
Eric Fleegal1
1
Comments
While some may think that naming conventions are much ado about nothing , no other subject of coding standards evokes as much fervent discourse. When I first started programming for Windows back in college ( ca 1990), I was baffled that all these...
Eric Fleegal's WebLog
The trouble with long double
Posted
over 5 years ago
by
Eric Fleegal1
0
Comments
Back in ‘04 I made a prediction that 80 bit floating point values would likely be supported in some future version of the VC++ compiler (just like we did in the 16bit version of the compiler!). Alas, it’s now ’07 and much to my disappointment this will...
Eric Fleegal's WebLog
Typesafe method of interfacing to DirectX shaders
Posted
over 6 years ago
by
Eric Fleegal1
0
Comments
I thought this idea might be of interest to DirectX C++ programmers. Typesafety is perhaps the most critical feature of higher programming languages, and yet so often application programming interfaces introduce non-typesafe constructs. This is frequently...
Eric Fleegal's WebLog
Stanley110 asks...
Posted
over 7 years ago
by
Eric Fleegal1
0
Comments
Sorry I haven't had time to post in quite a while. I’ve been developing the new Xbox Live Arcade for the upcoming Xbox 360, a project that has taken considerable time and effort. Stanley110 asks: A) Excel uses double precision. What benefit with...
Eric Fleegal's WebLog
Visual Studio 2005 Beta
Posted
over 8 years ago
by
Eric Fleegal1
0
Comments
Several people have sent technical support questions to me. I'm not ignoring you; I am interested in your comments. However, I don't have time to answer technical support questions in my blog. I would refer readers to http://lab.msdn.microsoft.com/vs2005...
Eric Fleegal's WebLog
Single Vs. Double ...
Posted
over 8 years ago
by
Eric Fleegal1
0
Comments
It’s almost Christmas as evidenced by how dead the office is; it’s pretty common for people at Microsoft to take-off the week of Christmas, and sometimes the following week. MS is fairly generous with holidays, giving us both Christmas Eve and Christmas...
Eric Fleegal's WebLog
Fused Multiply Add Question
Posted
over 8 years ago
by
Eric Fleegal1
1
Comments
Sergey asks "Is there any chance that in MSVC++ 2005 Fused Multiply Add (FMA) function will be available as a part of runtime library on all supported platforms?" To my knowledge FMAs won't be supported on all platforms since not all platforms have FMA...
Eric Fleegal's WebLog
Method for getting /Op like consistency in MS C++ 14.0
Posted
over 8 years ago
by
Eric Fleegal1
1
Comments
(From Microsoft Visual C++ Floating-Point Optimization ) Many C++ compilers offer a "consistency" floating-point model (through a /Op or /fltconsistency switch) that enables a developer to create programs compliant with strict floating-point...
Eric Fleegal's WebLog
Method for retaining intermediate results in extended precision
Posted
over 8 years ago
by
Eric Fleegal1
1
Comments
I thought I’d post a brief entry on how to retain intermediate results in extended precision. Consider the following direct summation algorithm: double sum(double[] a, int c) { 1: double result = 0.0; 2: for (int i=0; i<c;...
Eric Fleegal's WebLog
Overloading the semantics of the register keyword (followup)
Posted
over 8 years ago
by
Eric Fleegal1
0
Comments
John Albert asks two questions: What would "register float" mean? How would this work under fp:fast? The basic guideline is that "intermediate expressions will be computed in as high as precision as is practical". For instance, suppose for a...
Eric Fleegal's WebLog
No inline assembly on AMD64
Posted
over 8 years ago
by
Eric Fleegal1
2
Comments
Igor Abramov wrote: “Well, I was in desperate need for 80-bit long doubles. Now I coded this type as set of asm inlines and application prototype shipped in such form. But the production version will be done for amd64, in 64-bit mode for performance...
Eric Fleegal's WebLog
Confused about VC++ version numbers? Me too...
Posted
over 8 years ago
by
Eric Fleegal1
0
Comments
So I may have been confusing people when I talk about VC8.0. When I refer to VC8.0, I'm referring to Visual C++ in Visual Studio 2005. The product version is 8.0, but the compiler itself (i.e. cl.exe) is “version 14“. I'll try to be...
Eric Fleegal's WebLog
Are long doubles 64 or 80 bit?
Posted
over 8 years ago
by
Eric Fleegal1
6
Comments
Dmitriy Zaslavskiy has asked a very good question: “How come VC8 doesn't distinguish long double and double? I thought VC7 did. Have to go back and check.” The short answer is: The types are distinct, but the sizes are the same...
Eric Fleegal's WebLog
Overloading the semantics of the register keyword.
Posted
over 8 years ago
by
Eric Fleegal1
2
Comments
I often think about what I would change in C++ were I given carte blanche to update the language. One thing in particular has been on mind in recent months—the register keyword. The register keyword was originally intended to allow C programmers...
Eric Fleegal's WebLog
FP Whitepaper Addition: Setting the floating-point semantic mode on a function-by-function basis in VC8.0
Posted
over 8 years ago
by
Eric Fleegal1
2
Comments
The command-line switches -fp:precise, -fp:strict etc. are simply shorthand for setting the four different floating-point options (these are explained in the whitepaper). To explicitly select a particular floating-point semantic mode on a function-by...
Eric Fleegal's WebLog
FP Whitepaper Errata: The float_control Pragma in VC8.0
Posted
over 8 years ago
by
Eric Fleegal1
0
Comments
The /fp:precise, /fp:fast, /fp:strict and /fp:except switches control floating-point semantics on a file-by-file basis. The float_control pragma combined with the fenv_access and fp_contract pragmas allow such control on a function-by-function basis....
Eric Fleegal's WebLog
Changes to the floating-point whitepaper
Posted
over 8 years ago
by
Eric Fleegal1
0
Comments
There are several changes to the floating-point whitepaper that won’t make it onto msdn.com until later this month. The copyists and editors and MSDN are working hard, but their pipeline is quite full. In the interim I’ll post revisions here...
Eric Fleegal's WebLog
Microsoft Visual C++ Floating-Point Optimization
Posted
over 8 years ago
by
Eric Fleegal1
0
Comments
MSDN recently published one of my papers : Microsoft Visual C++ Floating-Point Optimization Compiler optimizers have long been the bane of numerical algorithms. Either they generate fast code at the expense of floating-point correctness or they generate...
Eric Fleegal's WebLog
Introductions...
Posted
over 8 years ago
by
Eric Fleegal1
1
Comments
I work for the Visual C++ group at Microsoft where I am responsible for determining the quality of floating-point code generation. My interests include validated numerical computing and generative programming. My most recent research involves validating...
Page 1 of 1 (23 items)