diff --git a/uppsrc/Core/Core.h b/uppsrc/Core/Core.h
index 230ef88..74f54a2 100644
--- a/uppsrc/Core/Core.h
+++ b/uppsrc/Core/Core.h
@@ -168,6 +168,7 @@
 
 #include <algorithm>
 #include <string>
+#include <complex>
 
 // fix MSC8 beta problem....
 #ifdef COMPILER_MSC
diff --git a/uppsrc/Core/Defs.h b/uppsrc/Core/Defs.h
index e41e407..34767ff 100644
--- a/uppsrc/Core/Defs.h
+++ b/uppsrc/Core/Defs.h
@@ -247,6 +247,8 @@ typedef long long unsigned uint64;
 
 typedef uint64             qword;
 
+typedef std::complex<double> cdouble;
+
 #ifdef COMPILER_MSC
 	#define I64(c) ((int64)COMBINE(c, i64))
 #else
diff --git a/uppsrc/Core/Stream.cpp b/uppsrc/Core/Stream.cpp
index d2eddd0..95bb29d 100644
--- a/uppsrc/Core/Stream.cpp
+++ b/uppsrc/Core/Stream.cpp
@@ -670,6 +670,13 @@ Stream& Stream::operator%(uint64& d)
 	return *this;
 }
 
+Stream& Stream::operator%(cdouble& d) {
+	double r,i;
+	if(IsStoring()) { r = d.real(); i = d.imag(); }
+	(*this) % r % i;
+	if(IsLoading()) { d = cdouble(r,i); }
+	return *this;
+}
 
 Stream& Stream::operator%(String& s) {
 	if(IsError()) return *this;
diff --git a/uppsrc/Core/Stream.h b/uppsrc/Core/Stream.h
index 11b31d2..e1f41e9 100644
--- a/uppsrc/Core/Stream.h
+++ b/uppsrc/Core/Stream.h
@@ -204,6 +204,7 @@ public:
 	Stream&   operator%(double& d);
 	Stream&   operator%(int64& d);
 	Stream&   operator%(uint64& d);
+	Stream&   operator%(cdouble& d);
 
 	Stream&   operator%(String& s);
 	Stream&   operator/(String& s);
diff --git a/uppsrc/Core/String.h b/uppsrc/Core/String.h
index ab03d05..48f26ff 100644
--- a/uppsrc/Core/String.h
+++ b/uppsrc/Core/String.h
@@ -781,6 +781,7 @@ template<> inline String AsString(const char& a)            { return String(a, 1
 template<> inline String AsString(const signed char& a)     { return String(a, 1); }
 template<> inline String AsString(const unsigned char& a)   { return String(a, 1); }
 template<> inline String AsString(const bool& a)            { return a ? "true" : "false"; }
+template<> inline String AsString(const cdouble& x)         { return String().Cat() << "C(" << x.real() << "," << x.imag() << ")"; }
 
 unsigned ctoi(int c);
 
diff --git a/uppsrc/Core/Topt.h b/uppsrc/Core/Topt.h
index eda7cda..da3c17c 100644
--- a/uppsrc/Core/Topt.h
+++ b/uppsrc/Core/Topt.h
@@ -391,6 +391,7 @@ template<> inline unsigned GetHashValue(const wchar_t& a)        { return (const
 
 template<> inline unsigned GetHashValue(const int64& a)          { return CombineHash((unsigned)a, (unsigned)(a >> 32)); }
 template<> inline unsigned GetHashValue(const uint64& a)         { return GetHashValue((int64)a); }
+template<> inline unsigned GetHashValue(const cdouble& x)       { return CombineHash(x.real(), x.imag()); }
 
 unsigned GetHashValue0(const double& a);
 
diff --git a/uppsrc/Core/Value.cpp b/uppsrc/Core/Value.cpp
index 314d658..2226afb 100644
--- a/uppsrc/Core/Value.cpp
+++ b/uppsrc/Core/Value.cpp
@@ -58,6 +58,7 @@ Value::Value(double d)         { ptr = new RichValueRep<double>(d); }
 Value::Value(bool b)           { ptr = new RichValueRep<bool>(b); }
 Value::Value(Date d)           { ptr = new RichValueRep<Date>(d); }
 Value::Value(Time t)           { ptr = new RichValueRep<Time>(t); }
+Value::Value(cdouble c)        { ptr = new RichValueRep<cdouble>(c); }
 Value::Value(const Nuller&)    { ptr = new RichValueRep<int>(Null); }
 
 Value::operator String() const
@@ -121,6 +122,12 @@ Value::operator bool() const
 	return operator int();
 }
 
+Value::operator cdouble() const
+{
+	if(!Is<cdouble>()) return Null;
+	return RichValue<cdouble>::Extract(*this);
+}
+
 VectorMap<dword, Value::Void *(*)(Stream& s)>& Value::Typemap()
 {
 	static VectorMap<dword, Value::Void *(*)(Stream& s)> x;
@@ -154,6 +161,7 @@ static void sRegisterStd()
 		RichValue<Time>::Register();
 		Value::Register(VALUEARRAY_V, ValueArrayDataCreate);
 		Value::Register(VALUEMAP_V, ValueMapDataCreate);
+		RichValue<cdouble>::Register();
 	};
 }
 
diff --git a/uppsrc/Core/Value.h b/uppsrc/Core/Value.h
index 969daeb..264417b 100644
--- a/uppsrc/Core/Value.h
+++ b/uppsrc/Core/Value.h
@@ -49,6 +49,7 @@ public:
 	operator int64() const              { return INT64_NULL; }
 	operator double() const             { return DOUBLE_NULL; }
 	operator bool() const               { return false; }
+	operator cdouble() const            { return cdouble(DOUBLE_NULL, DOUBLE_NULL); }
 
 	Nuller() {}
 };
@@ -65,6 +66,7 @@ template<> inline bool  IsNull(const double& r)  { return r < DOUBLE_NULL_LIM; }
 template<> inline bool  IsNull(const bool& r  )  { return false; }
 template<> inline bool  IsNull(const Date& d)    { return d.year == -32768; }
 template<> inline bool  IsNull(const Time& t)    { return t.year == -32768; }
+template<> inline bool  IsNull(const cdouble& r) { return r.real() < DOUBLE_NULL_LIM || r.imag() < DOUBLE_NULL_LIM; }
 
 inline const String&  Nvl(const String& a, const String& b)    { return IsNull(a) ? b : a; }
 inline int            Nvl(int a, int b)                        { return IsNull(a) ? b : a; }
@@ -77,6 +79,8 @@ inline int            Nvl(int a)                               { return Nvl(a, 0
 inline int64          Nvl(int64 a)                             { return Nvl(a, (int64)0); }
 inline double         Nvl(double a)                            { return Nvl(a, 0.0); }
 
+inline const cdouble& Nvl(const cdouble& a, const cdouble& b)  { return IsNull(a) ? b : a; }
+
 const dword VOID_V    = 0;
 
 const dword INT_V     = 1;
@@ -98,6 +102,8 @@ const dword BOOL_V   = 11;
 
 const dword VALUEMAP_V   = 12;
 
+const dword COMPLEX_V   = 20;
+
 const dword UNKNOWN_V = (dword)0xffffffff;
 
 class Value : Moveable<Value> {
@@ -150,6 +156,7 @@ public:
 	operator int() const;
 	operator int64() const;
 	operator bool() const;
+	operator cdouble() const;
 
 	Value(const String& s);
 	Value(const WString& s);
@@ -160,6 +167,7 @@ public:
 	Value(bool b);
 	Value(Date d);
 	Value(Time t);
+	Value(cdouble c);
 	Value(const Nuller&);
 
 	bool operator==(const Value& v) const;
@@ -195,6 +203,7 @@ VALUE_COMPARE(Date)
 VALUE_COMPARE(Time)
 VALUE_COMPARE(String)
 VALUE_COMPARE(WString)
+//VALUE_COMPARE(cdouble)
 
 inline bool operator==(const Value& v, const char *x)   { return (String)v == x; }
 inline bool operator==(const char *x, const Value& v)   { return (String)v == x; }
@@ -282,6 +291,7 @@ template<> inline dword ValueTypeNo(const String*)  { return STRING_V; }
 template<> inline dword ValueTypeNo(const WString*) { return WSTRING_V; }
 template<> inline dword ValueTypeNo(const Date*)    { return DATE_V; }
 template<> inline dword ValueTypeNo(const Time*)    { return TIME_V; }
+template<> inline dword ValueTypeNo(const cdouble*) { return COMPLEX_V; }
 
 template <class T, dword type, class B = EmptyClass>
 class AssignValueTypeNo : public B {
@@ -758,3 +768,8 @@ public:
 	Value operator++()                           { return Get(); }
 	virtual ~ValueGen() {}
 };
+
+inline bool operator==(const Value& v, cdouble x)   { return RichValue<cdouble>::Extract(v) == x; }
+inline bool operator==(cdouble x, const Value& v)   { return RichValue<cdouble>::Extract(v) == x; }
+inline bool operator!=(const Value& v, cdouble x)   { return RichValue<cdouble>::Extract(v) != x; }
+inline bool operator!=(cdouble x, const Value& v)   { return RichValue<cdouble>::Extract(v) != x; }