Hi PDHB,
Not sure what you mean by "native support" for complex numbers, but I have
written an app or 2 that uses complex numbers, and even a class for working
with complex numbers. The class is a sort of "catch-all," as I prefer to
dispense with the overhead in most cases, and just do the math myself.
Still, manipulating complex numbers isn't a whole lot more difficult than
working with real numbers
For example, I did a Mandelbrot Set visualizer awhile back. Here's the code:
public enum ColorScheme : int
{
DefaultGradient = 0,
GrayScale = 1
}
public struct Settings
{
public int Width;
public int Height;
public double MinX;
public double MaxX;
public double MinY;
public double MaxY;
public int MaxIterations;
public Fractal.ColorScheme ColorScheme;
public Settings(int w, int h)
{
Width = w;
Height = h;
MinX = -2.25d;
MaxX = 0.75d;
MinY = -1.5d;
MaxY = 1.5d;
MaxIterations = 2048;
ColorScheme = ColorScheme.DefaultGradient;
}
public Settings(int w, int h, double mnx, double mxx,
double mny, double mxy, int maxit)
{
Width = w;
Height = h;
MinX = mnx;
MaxX = mxx;
MinY = mny;
MaxY = mxy;
MaxIterations = maxit;
ColorScheme = ColorScheme.DefaultGradient;
}
}
/// <summary>
/// Class for visualizing the Mandelbrot set
/// </summary>
public class MandelbrotSet
{
private int _MaxIterations = 500;
private System.Drawing.Color _SetColor = System.Drawing.Color.Black;
public System.Drawing.Color SetColor
{
get
{
return _SetColor;
}
set
{
_SetColor = value;
}
}
public event ProgressArgsEventHandler ImageProgress;
public Settings Settings;
public Bitmap CreateImage()
{
Bitmap b = null;
int stride;
BitmapData bmData;
System.IntPtr Scan0;
try
{
b = new Bitmap(Settings.Width, Settings.Height,
PixelFormat.Format24bppRgb);
bmData = b.LockBits(new Rectangle(0,0, Settings.Width, Settings.Height),
ImageLockMode.WriteOnly, b.PixelFormat);
stride = bmData.Stride;
Scan0 = bmData.Scan0;
unsafe
{
byte * p = (byte *)(void *)Scan0;
int nOffset = stride - Settings.Width*3;
int nWidth = Settings.Width * 3;
for(int y=0;y<Settings.Height;++y)
{
for(int x=0; x < Settings.Width; ++x )
{
// Calculate color for this pixel
System.Drawing.Color c = ResolveZ(GetComplexCoord(x,y));
p[0] = c.B; // Reverse byte order in bmp
p[1] = c.G;
p[2] = c.R;
p += 3;
}
if (ImageProgress != null)
ImageProgress(this, new ProgressArgs(y, Settings.Height));
p += nOffset;
}
}
b.UnlockBits(bmData);
return b;
}
catch (Exception ex)
{
Utilities.HandleError(ex);
throw(ex);
}
}
/// <summary>
/// Gets the Complex Coordinate values of an xy coordinate in the image
/// </summary>
/// <param name="x">x coordinate in the image</param>
/// <param name="y">y coordinate in the image</param>
/// <returns>Complex Coordinate at that point</returns>
public Complex GetComplexCoord(int x, int y)
{
double xdist = Settings.MaxX - Settings.MinX; // distance between
MinRx and MaxRx
double ydist = Settings.MaxY - Settings.MinY; // distance between
MinIy and MaxIy
double xratio = (double)Settings.Width / xdist; // distance per pixel
double yratio = (double)Settings.Height / ydist; // distance per pixel
double real = Settings.MinX + ((double)x / xratio);
double imaginary = Settings.MaxY - ((double)y / yratio); // Reverse from
bottom to top
return new Complex(real, imaginary);
}
public System.Drawing.Color ResolveZ(Complex C)
{
return ResolveZ(C, new Complex(0,0), 0);
}
public System.Drawing.Color ResolveZ(Complex C, Complex Z, int iteration)
{
if (iteration == Settings.MaxIterations)
return _SetColor;
int interval = (int)(Settings.MaxIterations / 12);
// Zn + 1 = ZnSquared + C
double real = (Z.real * Z.real) - (Z.imaginary * Z.imaginary) + C.real;
double imaginary = 2 * Z.real * Z.imaginary + C.imaginary;
Complex resultZ = new Complex(real, imaginary);
if ( 4 < ((Z.real * Z.real) + (Z.imaginary * Z.imaginary)))
{
switch(Settings.ColorScheme)
{
case ColorScheme.DefaultGradient:
if (iteration < 64) // Interval = 1 (0 to 64) (64 its)
return System.Drawing.Color.FromArgb(0,0, 64 + (iteration * 3));
else if (iteration < 320) // Interval = 5 (64 to 320) (256 its)
return System.Drawing.Color.FromArgb(iteration - 64, 0, 255);
else if(iteration < 512) // Interval = 8 (320 to 512) (128 its)
return System.Drawing.Color.FromArgb(255,
iteration - 320, 512 - iteration);
else if(iteration < 640) // Interval = 10 (512 to 640) (128 its)
return System.Drawing.Color.FromArgb(255,
iteration - 384, 640 - iteration);
else if (iteration < 768) // Iteration = 12 (640 to 768) (128 its)
return System.Drawing.Color.FromArgb(255, 255, (iteration - 640) *
2);
else
return System.Drawing.Color.White;
case ColorScheme.GrayScale:
double ratio = (double)Settings.MaxIterations/192d;
int i = (int)(((double)iteration / ratio)) + 64;
return System.Drawing.Color.FromArgb(i, i, i);
}
}
return ResolveZ(C, resultZ, iteration + 1);
}
public MandelbrotSet()
{
Settings = new Settings(400, 400);
}
public MandelbrotSet(int width, int height, double minrx,
double maxrx, double miniy, double maxiy)
{
Settings = new Settings(width, height, minrx, maxrx, miniy, maxiy, 2048);
}
}
BTW, you can find quite a bit in the Microsoft Managed DirectX class
libraries as well.
--
HTH,
Kevin Spencer
Microsoft MVP
..Net Developer
Big things are made up of
lots of little things.
.NET is a platform, not a set