commit 6d2a372d6aa38f64570c972b3a5e69d68cd28f87
Author: Robin Haberkorn <robin.haberkorn@googlemail.com>
Date:   Fri Aug 31 18:24:30 2012 +0200

    preliminary 64-bit fix of arrays (HACK)
    
    Chuck_Array4 is a one-word array, Chuck_Array8 a two-word array, etc.
    appears to work but it should be revised: use one Chuck_Array class per ChucK type (e.g. using templates)

diff --git a/chuck_emit.cpp b/chuck_emit.cpp
index 24ca50f..1b35275 100644
--- a/chuck_emit.cpp
+++ b/chuck_emit.cpp
@@ -1837,7 +1837,7 @@ t_CKBOOL emit_engine_emit_op( Chuck_Emitter * emit, ae_Operator op, a_Exp lhs, a
 
         case te_array:
             // check size
-            emit->append( instr = new Chuck_Instr_Array_Append( t_left->array_type->size ) );
+            emit->append( instr = new Chuck_Instr_Array_Append( t_left->array_type->words() ) );
             break;
 
         default: break;
@@ -3065,7 +3065,7 @@ t_CKBOOL emit_engine_emit_exp_array( Chuck_Emitter * emit, a_Exp_Array array )
         return FALSE;
 
     // make sure
-    if( type->size != 4 && type->size != 8 && type->size != 16 ) // ISSUE: 64-bit
+    if( type->words() != 1 && type->words() != 2 && type->words() != 4 )
     {
         EM_error2( array->linepos,
             "(emit): internal error: array with datasize of %i...", type->size );
@@ -3083,7 +3083,7 @@ t_CKBOOL emit_engine_emit_exp_array( Chuck_Emitter * emit, a_Exp_Array array )
 
         if( isa( exp->type, &t_string ) )
         {
-            emit->append( new Chuck_Instr_Array_Map_Access( type->size, want_var ) );
+            emit->append( new Chuck_Instr_Array_Map_Access( type->words(), want_var ) );
         }
         else
         {
@@ -3091,9 +3091,9 @@ t_CKBOOL emit_engine_emit_exp_array( Chuck_Emitter * emit, a_Exp_Array array )
 
             if( exp->next == NULL || isa( exp->next->type, &t_string ) ) {
                 if( depth == 1 )
-                    emit->append( new Chuck_Instr_Array_Access( type->size, want_var ) );
+                    emit->append( new Chuck_Instr_Array_Access( type->words(), want_var ) );
                 else
-                    emit->append( new Chuck_Instr_Array_Access_Multi( depth, type->size, want_var ) );
+                    emit->append( new Chuck_Instr_Array_Access_Multi( depth, type->words(), want_var ) );
 
                 depth = 0;
             }
diff --git a/chuck_instr.cpp b/chuck_instr.cpp
index e7e542e..6f9cf01 100644
--- a/chuck_instr.cpp
+++ b/chuck_instr.cpp
@@ -3774,10 +3774,11 @@ void Chuck_Instr_Array_Init::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
     t_CKUINT *& reg_sp = (t_CKUINT *&)shred->reg->sp;
 
     // allocate the array
-    if( m_type_ref->size == 4 ) // ISSUE: 64-bit
+    if( m_type_ref->words() == 1 )
     {
+    	t_CK1WORD *& sp = (t_CK1WORD *&)reg_sp;
         // pop the values
-        pop_( reg_sp, m_length );
+        pop_( sp, m_length );
         // instantiate array
         Chuck_Array4 * array = new Chuck_Array4( m_is_obj, m_length );
         // problem
@@ -3788,47 +3789,45 @@ void Chuck_Instr_Array_Init::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
         array->set_size( m_length );
         // fill array
         for( t_CKINT i = 0; i < m_length; i++ )
-            array->set( i, *(reg_sp + i) );
+            array->set( i, sp[i] );
         // push the pointer
         push_( reg_sp, (t_CKUINT)array );
     }
-    else if( m_type_ref->size == 8 ) // ISSUE: 64-bit
+    else if( m_type_ref->words() == 2 )
     {
+        t_CK2WORD *& sp = (t_CK2WORD *&)reg_sp;
         // pop the values
-        pop_( reg_sp, 2 * m_length );
+        pop_( sp, m_length );
         // instantiate array
         Chuck_Array8 * array = new Chuck_Array8( m_length );
         // problem
         if( !array ) goto out_of_memory;
-        // fill array
-        t_CKFLOAT * sp = (t_CKFLOAT *)reg_sp;
         // intialize object
         initialize_object( array, &t_array );
         // set size
         array->set_size( m_length );
         // fill array
         for( t_CKINT i = 0; i < m_length; i++ )
-            array->set( i, *(sp + i) );
+            array->set( i, sp[i] );
         // push the pointer
         push_( reg_sp, (t_CKUINT)array );
     }
-    else if( m_type_ref->size == 16 ) // ISSUE: 64-bit
+    else if( m_type_ref->words() == 4 )
     {
+        t_CK4WORD *& sp = (t_CK4WORD *&)reg_sp;
         // pop the values
-        pop_( reg_sp, 4 * m_length );
+        pop_( sp, m_length );
         // instantiate array
         Chuck_Array16 * array = new Chuck_Array16( m_length );
         // problem
         if( !array ) goto out_of_memory;
-        // fill array
-        t_CKCOMPLEX * sp = (t_CKCOMPLEX *)reg_sp;
         // intialize object
         initialize_object( array, &t_array );
         // set size
         array->set_size( m_length );
         // fill array
         for( t_CKINT i = 0; i < m_length; i++ )
-            array->set( i, *(sp + i) );
+            array->set( i, sp[i] );
         // push the pointer
         push_( reg_sp, (t_CKUINT)array );
     }
@@ -3908,7 +3907,7 @@ Chuck_Instr_Array_Alloc::~Chuck_Instr_Array_Alloc()
 // desc: ...
 //-----------------------------------------------------------------------------
 Chuck_Object * do_alloc_array( t_CKINT * capacity, const t_CKINT * top,
-                               t_CKUINT size, t_CKBOOL is_obj,
+                               t_CKUINT words, t_CKBOOL is_obj,
                                t_CKUINT * objs, t_CKINT & index )
 {
     // not top level
@@ -3923,7 +3922,7 @@ Chuck_Object * do_alloc_array( t_CKINT * capacity, const t_CKINT * top,
     if( capacity >= top )
     {
         // check size
-        if( size == 4 ) // ISSUE: 64-bit
+        if( words == 1 )
         {
             Chuck_Array4 * base = new Chuck_Array4( is_obj, *capacity );
             if( !base ) goto out_of_memory;
@@ -3943,7 +3942,7 @@ Chuck_Object * do_alloc_array( t_CKINT * capacity, const t_CKINT * top,
             initialize_object( base, &t_array );
             return base;
         }
-        else if( size == 8 ) // ISSUE: 64-bit
+        else if( words == 2 )
         {
             Chuck_Array8 * base = new Chuck_Array8( *capacity );
             if( !base ) goto out_of_memory;
@@ -3952,7 +3951,7 @@ Chuck_Object * do_alloc_array( t_CKINT * capacity, const t_CKINT * top,
             initialize_object( base, &t_array );
             return base;
         }
-        else if( size == 16 ) // ISSUE: 64-bit
+        else if( words == 4 )
         {
             Chuck_Array16 * base = new Chuck_Array16( *capacity );
             if( !base ) goto out_of_memory;
@@ -3974,11 +3973,11 @@ Chuck_Object * do_alloc_array( t_CKINT * capacity, const t_CKINT * top,
     for( i = 0; i < *capacity; i++ )
     {
         // the next
-        next = do_alloc_array( capacity+1, top, size, is_obj, objs, index );
+        next = do_alloc_array( capacity+1, top, words, is_obj, objs, index );
         // error if NULL
         if( !next ) goto error;
         // set that, with ref count
-        base->set( i, (t_CKUINT)next );
+        base->set( i, (t_CK1WORD)next );
     }
 
     // initialize object
@@ -4020,8 +4019,6 @@ void Chuck_Instr_Array_Alloc::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
     t_CKUINT num_obj = 0;
     // the index to pass to the arrays
     t_CKINT index = 0;
-    // number
-    t_CKFLOAT num = 1.0;
     // array
     t_CKUINT * obj_array = NULL;
     // size
@@ -4034,15 +4031,13 @@ void Chuck_Instr_Array_Alloc::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
         t_CKINT * top = (t_CKINT *)(reg_sp - 1);
 
         num_obj = 1;
-        num = 1.0;
         // product of all dims
         while( curr <= top )
         {
-            num_obj *= *(curr);
-
             // overflow
-            num *= (t_CKFLOAT)(*(curr));
-            if( num > (t_CKFLOAT)INT_MAX ) goto overflow;
+            if ( *curr && num_obj * *curr < num_obj ) goto overflow;
+
+            num_obj *= *(curr);
 
             curr++;
         }
@@ -4076,7 +4071,7 @@ void Chuck_Instr_Array_Alloc::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
     ref = (t_CKUINT)do_alloc_array( 
         (t_CKINT *)(reg_sp - m_depth),
         (t_CKINT *)(reg_sp - 1),
-        m_type_ref->size,
+        m_type_ref->words(),
         m_is_obj,
         obj_array, index 
     );
@@ -4139,11 +4134,6 @@ void Chuck_Instr_Array_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
     t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp;
     // UNUSED: t_CKUINT *& reg_sp = sp;
     t_CKINT i = 0;
-    t_CKUINT val = 0;
-    t_CKFLOAT fval = 0;
-    t_CKCOMPLEX cval;
-    cval.re = 0;
-    cval.im = 0;
 
     // pop
     pop_( sp, 2 );
@@ -4151,8 +4141,7 @@ void Chuck_Instr_Array_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
     // check pointer
     if( !(*sp) ) goto null_pointer;
 
-    // 4 or 8 or 16
-    if( m_size == 4 ) // ISSUE: 64-bit
+    if( m_words == 1 )
     {
         // get array
         Chuck_Array4 * arr = (Chuck_Array4 *)(*sp);
@@ -4160,6 +4149,7 @@ void Chuck_Instr_Array_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
         i = (t_CKINT)(*(sp+1));
         // check if writing
         if( m_emit_addr ) {
+            t_CKUINT val;
             // get the addr
             val = arr->addr( i );
             // exception
@@ -4167,14 +4157,15 @@ void Chuck_Instr_Array_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
             // push the addr
             push_( sp, val );
         } else {
+            t_CK1WORD val;
             // get the value
             if( !arr->get( i, &val ) )
                 goto array_out_of_bound;
             // push the value
-            push_( sp, val );
+            push_( sp, (t_CKUINT)val );
         }
     }
-    else if( m_size == 8 ) // ISSUE: 64-bit
+    else if( m_words == 2 )
     {
         // get array
         Chuck_Array8 * arr = (Chuck_Array8 *)(*sp);
@@ -4182,6 +4173,7 @@ void Chuck_Instr_Array_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
         i = (t_CKINT)(*(sp+1));
         // check if writing
         if( m_emit_addr ) {
+            t_CKUINT val;
             // get the addr
             val = arr->addr( i );
             // exception
@@ -4189,14 +4181,15 @@ void Chuck_Instr_Array_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
             // push the addr
             push_( sp, val );
         } else {
+            t_CK2WORD val;
             // get the value
-            if( !arr->get( i, &fval ) )
+            if( !arr->get( i, &val ) )
                 goto array_out_of_bound;
             // push the value
-            push_( ((t_CKFLOAT *&)sp), fval );
+            push_( ((t_CK2WORD *&)sp), val );
         }
     }
-    else if( m_size == 16 ) // ISSUE: 64-bit
+    else if( m_words == 4 )
     {
         // get array
         Chuck_Array16 * arr = (Chuck_Array16 *)(*sp);
@@ -4204,6 +4197,7 @@ void Chuck_Instr_Array_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
         i = (t_CKINT)(*(sp+1));
         // check if writing
         if( m_emit_addr ) {
+            t_CKUINT val;
             // get the addr
             val = arr->addr( i );
             // exception
@@ -4211,11 +4205,12 @@ void Chuck_Instr_Array_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
             // push the addr
             push_( sp, val );
         } else {
+            t_CK4WORD val;
             // get the value
-            if( !arr->get( i, &cval ) )
+            if( !arr->get( i, &val ) )
                 goto array_out_of_bound;
             // push the value
-            push_( ((t_CKCOMPLEX *&)sp), cval );
+            push_( ((t_CK4WORD *&)sp), val );
         }
     }
     else
@@ -4256,11 +4251,6 @@ void Chuck_Instr_Array_Map_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shre
     // reg stack pointer
     t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp;
     Chuck_String * key = NULL;
-    t_CKUINT val = 0;
-    t_CKFLOAT fval = 0;
-    t_CKCOMPLEX cval;
-    cval.re = 0;
-    cval.im = 0;
 
     // pop
     pop_( sp, 2 );
@@ -4268,8 +4258,7 @@ void Chuck_Instr_Array_Map_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shre
     // check pointer
     if( !(*sp) ) goto null_pointer;
 
-    // 4 or 8 or 16
-    if( m_size == 4 ) // ISSUE: 64-bit
+    if( m_words == 1 )
     {
         // get array
         Chuck_Array4 * arr = (Chuck_Array4 *)(*sp);
@@ -4277,6 +4266,7 @@ void Chuck_Instr_Array_Map_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shre
         key = (Chuck_String *)(*(sp+1));
         // check if writing
         if( m_emit_addr ) {
+            t_CKUINT val;
             // get the addr
             val = arr->addr( key->str );
             // exception
@@ -4284,14 +4274,15 @@ void Chuck_Instr_Array_Map_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shre
             // push the addr
             push_( sp, val );
         } else {
+            t_CK1WORD val;
             // get the value
             if( !arr->get( key->str, &val ) )
                 goto error;
             // push the value
-            push_( sp, val );
+            push_( sp, (t_CKUINT)val );
         }
     }
-    else if( m_size == 8 ) // ISSUE: 64-bit
+    else if( m_words == 2 )
     {
         // get array
         Chuck_Array8 * arr = (Chuck_Array8 *)(*sp);
@@ -4299,6 +4290,7 @@ void Chuck_Instr_Array_Map_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shre
         key = (Chuck_String *)(*(sp+1));
         // check if writing
         if( m_emit_addr ) {
+            t_CKUINT val;
             // get the addr
             val = arr->addr( key->str );
             // exception
@@ -4306,14 +4298,15 @@ void Chuck_Instr_Array_Map_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shre
             // push the addr
             push_( sp, val );
         } else {
+            t_CK2WORD val;
             // get the value
-            if( !arr->get( key->str, &fval ) )
+            if( !arr->get( key->str, &val ) )
                 goto error;
             // push the value
-            push_( ((t_CKFLOAT *&)sp), fval );
+            push_( ((t_CK2WORD *&)sp), val );
         }
     }
-    else if( m_size == 16 ) // ISSUE: 64-bit
+    else if( m_words == 4 )
     {
         // get array
         Chuck_Array16 * arr = (Chuck_Array16 *)(*sp);
@@ -4321,6 +4314,7 @@ void Chuck_Instr_Array_Map_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shre
         key = (Chuck_String *)(*(sp+1));
         // check if writing
         if( m_emit_addr ) {
+            t_CKUINT val;
             // get the addr
             val = arr->addr( key->str );
             // exception
@@ -4328,11 +4322,12 @@ void Chuck_Instr_Array_Map_Access::execute( Chuck_VM * vm, Chuck_VM_Shred * shre
             // push the addr
             push_( sp, val );
         } else {
+            t_CK4WORD val;
             // get the value
-            if( !arr->get( key->str, &cval ) )
+            if( !arr->get( key->str, &val ) )
                 goto error;
             // push the value
-            push_( ((t_CKCOMPLEX *&)sp), cval );
+            push_( ((t_CK4WORD *&)sp), val );
         }
     }
     else
@@ -4371,14 +4366,9 @@ void Chuck_Instr_Array_Access_Multi::execute( Chuck_VM * vm, Chuck_VM_Shred * sh
 {
     // reg stack pointer
     t_CKUINT *& sp = (t_CKUINT *&)shred->reg->sp;
-    t_CKINT i = 0;
-    t_CKUINT val = 0, j;
-    t_CKFLOAT fval = 0;
-    t_CKCOMPLEX cval;
+    t_CKINT i = 0, j;
     t_CKINT * ptr = NULL;
     t_CKUINT index = 0;
-    cval.re = 0;
-    cval.im = 0;
 
     // pop all indices then array
     pop_( sp, m_depth + 1 );
@@ -4395,6 +4385,7 @@ void Chuck_Instr_Array_Access_Multi::execute( Chuck_VM * vm, Chuck_VM_Shred * sh
     // loop through indices
     for( j = 0; j < (m_depth-1); j++ )
     {
+    	t_CK1WORD val;
         // get index
         i = *ptr++;
         // get the array
@@ -4411,8 +4402,7 @@ void Chuck_Instr_Array_Access_Multi::execute( Chuck_VM * vm, Chuck_VM_Shred * sh
         }
     }
 
-    // 4 or 8 or 16
-    if( m_size == 4 ) // ISSUE: 64-bit
+    if( m_words == 1 )
     {
         // get arry
         Chuck_Array4 * arr = base;
@@ -4420,6 +4410,7 @@ void Chuck_Instr_Array_Access_Multi::execute( Chuck_VM * vm, Chuck_VM_Shred * sh
         i = (t_CKINT)(*ptr);
         // check if writing
         if( m_emit_addr ) {
+            t_CKUINT val;
             // get the addr
             val = arr->addr( i );
             // exception
@@ -4427,14 +4418,15 @@ void Chuck_Instr_Array_Access_Multi::execute( Chuck_VM * vm, Chuck_VM_Shred * sh
             // push the addr
             push_( sp, val );
         } else {
+            t_CK1WORD val;
             // get the value
             if( !arr->get( i, &val ) )
                 goto array_out_of_bound;
             // push the value
-            push_( sp, val );
+            push_( sp, (t_CKUINT)val );
         }
     }
-    else if( m_size == 8 ) // ISSUE: 64-bit
+    else if( m_words == 2 )
     {
         // get array
         Chuck_Array8 * arr = (Chuck_Array8 *)(base);
@@ -4442,6 +4434,7 @@ void Chuck_Instr_Array_Access_Multi::execute( Chuck_VM * vm, Chuck_VM_Shred * sh
         i = (t_CKINT)(*ptr);
         // check if writing
         if( m_emit_addr ) {
+            t_CKUINT val;
             // get the addr
             val = arr->addr( i );
             // exception
@@ -4449,14 +4442,15 @@ void Chuck_Instr_Array_Access_Multi::execute( Chuck_VM * vm, Chuck_VM_Shred * sh
             // push the addr
             push_( sp, val );
         } else {
+            t_CK2WORD val;
             // get the value
-            if( !arr->get( i, &fval ) )
+            if( !arr->get( i, &val ) )
                 goto array_out_of_bound;
             // push the value
-            push_( ((t_CKFLOAT *&)sp), fval );
+            push_( ((t_CK2WORD *&)sp), val );
         }
     }
-    else if( m_size == 16 ) // ISSUE: 64-bit
+    else if( m_words == 4 )
     {
         // get array
         Chuck_Array16 * arr = (Chuck_Array16 *)(base);
@@ -4464,6 +4458,7 @@ void Chuck_Instr_Array_Access_Multi::execute( Chuck_VM * vm, Chuck_VM_Shred * sh
         i = (t_CKINT)(*ptr);
         // check if writing
         if( m_emit_addr ) {
+            t_CKUINT val;
             // get the addr
             val = arr->addr( i );
             // exception
@@ -4471,11 +4466,12 @@ void Chuck_Instr_Array_Access_Multi::execute( Chuck_VM * vm, Chuck_VM_Shred * sh
             // push the addr
             push_( sp, val );
         } else {
+            t_CK4WORD val;
             // get the value
-            if( !arr->get( i, &cval ) )
+            if( !arr->get( i, &val ) )
                 goto array_out_of_bound;
             // push the value
-            push_( ((t_CKCOMPLEX *&)sp), cval );
+            push_( ((t_CK4WORD *&)sp), val );
         }
     }
     else
@@ -4536,38 +4532,40 @@ void Chuck_Instr_Array_Append::execute( Chuck_VM * vm, Chuck_VM_Shred * shred )
     cval.im = 0;
 
     // pop
-    pop_( sp, 1+(m_val/4) );
+    pop_( sp, 1+m_val );
 
     // check pointer
     if( !(*sp) ) goto null_pointer;
 
-    // 4 or 8 or 16
-    if( m_val == 4 ) // ISSUE: 64-bit
+    if( m_val == 1 )
     {
+    	t_CK1WORD val;
         // get array
         Chuck_Array4 * arr = (Chuck_Array4 *)(*sp);
         // get value
-        val = (t_CKINT)(*(sp+1));
+        val = (t_CK1WORD)(*(sp+1));
         // append
         arr->push_back( val );
     }
-    else if( m_val == 8 ) // ISSUE: 64-bit
+    else if( m_val == 2 )
     {
+    	t_CK2WORD val;
         // get array
         Chuck_Array8 * arr = (Chuck_Array8 *)(*sp);
         // get value
-        fval = (*(t_CKFLOAT *)(sp+1));
+        val = (*(t_CK2WORD *)(sp+1));
         // append
-        arr->push_back( fval );
+        arr->push_back( val );
     }
-    else if( m_val == 16 ) // ISSUE: 64-bit
+    else if( m_val == 4 )
     {
+    	t_CK4WORD val;
         // get array
         Chuck_Array16 * arr = (Chuck_Array16 *)(*sp);
         // get value
-        cval = (*(t_CKCOMPLEX *)(sp+1));
+        val = (*(t_CK4WORD *)(sp+1));
         // append
-        arr->push_back( cval );
+        arr->push_back( val );
     }
     else
         assert( FALSE );
diff --git a/chuck_instr.h b/chuck_instr.h
index dbb2799..9bc6682 100644
--- a/chuck_instr.h
+++ b/chuck_instr.h
@@ -2212,7 +2212,7 @@ struct Chuck_Instr_Array_Prepend : public Chuck_Instr_Unary_Op
 //-----------------------------------------------------------------------------
 struct Chuck_Instr_Array_Append : public Chuck_Instr_Unary_Op
 {
-    Chuck_Instr_Array_Append( t_CKUINT size ) { set( size ); }
+    Chuck_Instr_Array_Append( t_CKUINT words ) { set( words ); }
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     // virtual const char * params() const;
 };
@@ -2564,20 +2564,20 @@ protected:
 struct Chuck_Instr_Array_Access : public Chuck_Instr
 {
 public:
-    Chuck_Instr_Array_Access( t_CKUINT size, t_CKUINT emit_addr, 
+    Chuck_Instr_Array_Access( t_CKUINT words, t_CKUINT emit_addr, 
         t_CKUINT istr = FALSE )
-    { m_size = size; m_emit_addr = emit_addr; m_istr = istr; }
+    { m_words = words; m_emit_addr = emit_addr; m_istr = istr; }
 
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
     { static char buffer[256];
-      sprintf( buffer, "size=%ld, emit_addr=%ld istr=%ld", 
-               m_size, m_emit_addr, m_istr );
+      sprintf( buffer, "words=%ld, emit_addr=%ld istr=%ld", 
+               m_words, m_emit_addr, m_istr );
       return buffer; }
 
 protected:
-    t_CKUINT m_size;
+    t_CKUINT m_words;
     t_CKUINT m_emit_addr;
     t_CKUINT m_istr;
 };
@@ -2592,18 +2592,18 @@ protected:
 struct Chuck_Instr_Array_Map_Access : public Chuck_Instr
 {
 public:
-    Chuck_Instr_Array_Map_Access( t_CKUINT size, t_CKUINT emit_addr )
-    { m_size = size; m_emit_addr = emit_addr; }
+    Chuck_Instr_Array_Map_Access( t_CKUINT words, t_CKUINT emit_addr )
+    { m_words = words; m_emit_addr = emit_addr; }
 
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
     { static char buffer[256];
-      sprintf( buffer, "size=%ld, emit_addr=%ld", m_size, m_emit_addr );
+      sprintf( buffer, "words=%ld, emit_addr=%ld", m_words, m_emit_addr );
       return buffer; }
 
 protected:
-    t_CKUINT m_size;
+    t_CKUINT m_words;
     t_CKUINT m_emit_addr;
 };
 
@@ -2617,19 +2617,19 @@ protected:
 struct Chuck_Instr_Array_Access_Multi : public Chuck_Instr
 {
 public:
-    Chuck_Instr_Array_Access_Multi( t_CKUINT depth, t_CKUINT size, t_CKUINT emit_addr )
-    { m_size = size; m_depth = depth; m_emit_addr = emit_addr; }
+    Chuck_Instr_Array_Access_Multi( t_CKUINT depth, t_CKUINT words, t_CKUINT emit_addr )
+    { m_words = words; m_depth = depth; m_emit_addr = emit_addr; }
 
 public:
     virtual void execute( Chuck_VM * vm, Chuck_VM_Shred * shred );
     virtual const char * params() const
     { static char buffer[256];
-      sprintf( buffer, "depth=%ld, size=%ld, emit_addr=%ld", m_depth, m_size, m_emit_addr );
+      sprintf( buffer, "depth=%ld, words=%ld, emit_addr=%ld", m_depth, m_words, m_emit_addr );
       return buffer; }
 
 protected:
     t_CKUINT m_depth;
-    t_CKUINT m_size;
+    t_CKUINT m_words;
     t_CKUINT m_emit_addr;
 };
 
diff --git a/chuck_lang.cpp b/chuck_lang.cpp
index 4084274..4298bd0 100644
--- a/chuck_lang.cpp
+++ b/chuck_lang.cpp
@@ -2093,14 +2093,14 @@ CK_DLL_MFUN( uana_fval )
     t_CKINT i = GET_NEXT_INT(ARGS);
     // get the fvals array
     Chuck_UAnaBlobProxy * blob = (Chuck_UAnaBlobProxy *)OBJ_MEMBER_INT(SELF, uana_offset_blob);
-    Chuck_Array8 & fvals = blob->fvals();
+    Chuck_ArrayF & fvals = blob->fvals();
     // check caps
     if( i < 0 || fvals.size() <= i ) RETURN->v_float = 0;
     else
     {
         // get
         t_CKFLOAT val;
-        fvals.get( i, &val );
+        fvals.get( i, (t_CKFLOATARRAY *)&val );
         RETURN->v_float = val;
     }
 }
@@ -2111,7 +2111,7 @@ CK_DLL_MFUN( uana_cval )
     t_CKINT i = GET_NEXT_INT(ARGS);
     // get the fvals array
     Chuck_UAnaBlobProxy * blob = (Chuck_UAnaBlobProxy *)OBJ_MEMBER_INT(SELF, uana_offset_blob);
-    Chuck_Array16 & cvals = blob->cvals();
+    Chuck_ArrayC & cvals = blob->cvals();
     // check caps
     if( i < 0 || cvals.size() <= i ) RETURN->v_complex.re = RETURN->v_complex.im = 0;
     else
@@ -2165,20 +2165,20 @@ t_CKTIME & Chuck_UAnaBlobProxy::when()
     return OBJ_MEMBER_TIME(m_blob, uanablob_offset_when);
 }
 
-Chuck_Array8 & Chuck_UAnaBlobProxy::fvals()
+Chuck_ArrayF & Chuck_UAnaBlobProxy::fvals()
 {
     // TODO: DANGER: is this actually returning correct reference?!
-    Chuck_Array8 * arr8 = (Chuck_Array8 *)OBJ_MEMBER_INT(m_blob, uanablob_offset_fvals);
-    assert( arr8 != NULL );
-    return *arr8;
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)OBJ_MEMBER_INT(m_blob, uanablob_offset_fvals);
+    assert( arr != NULL );
+    return *arr;
 }
 
-Chuck_Array16 & Chuck_UAnaBlobProxy::cvals()
+Chuck_ArrayC & Chuck_UAnaBlobProxy::cvals()
 {
     // TODO: DANGER: is this actually returning correct reference?!
-    Chuck_Array16 * arr16 = (Chuck_Array16 *)OBJ_MEMBER_INT(m_blob, uanablob_offset_cvals);
-    assert( arr16 != NULL );
-    return *arr16;
+    Chuck_ArrayC * arr = (Chuck_ArrayC *)OBJ_MEMBER_INT(m_blob, uanablob_offset_cvals);
+    assert( arr != NULL );
+    return *arr;
 }
 
 // get proxy
@@ -2193,32 +2193,32 @@ CK_DLL_CTOR( uanablob_ctor )
     // when
     OBJ_MEMBER_TIME(SELF, uanablob_offset_when) = 0;
     // fvals
-    Chuck_Array8 * arr8 = new Chuck_Array8( 8 );
-    initialize_object( arr8, &t_array );
+    Chuck_ArrayF * arrf = new Chuck_ArrayF();
+    initialize_object( arrf, &t_array );
     // TODO: check out of memory
-    arr8->add_ref();
-    OBJ_MEMBER_INT(SELF, uanablob_offset_fvals) = (t_CKINT)arr8;
+    arrf->add_ref();
+    OBJ_MEMBER_INT(SELF, uanablob_offset_fvals) = (t_CKINT)arrf;
     // cvals
-    Chuck_Array16 * arr16 = new Chuck_Array16( 8 );
-    initialize_object( arr16, &t_array );
+    Chuck_ArrayC * arrc = new Chuck_ArrayC( 8 );
+    initialize_object( arrc, &t_array );
     // TODO: check out of memory
-    arr16->add_ref();
-    OBJ_MEMBER_INT(SELF, uanablob_offset_cvals) = (t_CKINT)arr16;
+    arrc->add_ref();
+    OBJ_MEMBER_INT(SELF, uanablob_offset_cvals) = (t_CKINT)arrc;
 }
 
 // dtor
 CK_DLL_DTOR( uanablob_dtor )
 {
     // get array
-    Chuck_Array8 * arr8 = (Chuck_Array8 *)OBJ_MEMBER_INT(SELF, uanablob_offset_fvals);
+    Chuck_ArrayF * arrf = (Chuck_ArrayF *)OBJ_MEMBER_INT(SELF, uanablob_offset_fvals);
     // release it
-    arr8->release();
+    arrf->release();
     OBJ_MEMBER_INT(SELF, uanablob_offset_fvals) = 0;
     
     // get array
-    Chuck_Array16 * arr16 = (Chuck_Array16 *)OBJ_MEMBER_INT(SELF, uanablob_offset_cvals);
+    Chuck_ArrayC * arrc = (Chuck_ArrayC *)OBJ_MEMBER_INT(SELF, uanablob_offset_cvals);
     // release it
-    arr16->release();
+    arrc->release();
     OBJ_MEMBER_INT(SELF, uanablob_offset_cvals) = 0;
     
     OBJ_MEMBER_TIME(SELF, uanablob_offset_when) = 0;
@@ -2233,7 +2233,7 @@ CK_DLL_MFUN( uanablob_when )
 CK_DLL_MFUN( uanablob_fvals )
 {
     // set return
-    RETURN->v_object = (Chuck_Array8 *)OBJ_MEMBER_INT(SELF, uanablob_offset_fvals);
+    RETURN->v_object = (Chuck_ArrayF *)OBJ_MEMBER_INT(SELF, uanablob_offset_fvals);
 }
 
 CK_DLL_MFUN( uanablob_fval )
@@ -2241,14 +2241,14 @@ CK_DLL_MFUN( uanablob_fval )
     // get index
     t_CKINT i = GET_NEXT_INT(ARGS);
     // get the fvals array
-    Chuck_Array8 * fvals = (Chuck_Array8 *)OBJ_MEMBER_INT(SELF, uanablob_offset_fvals);
+    Chuck_ArrayF * fvals = (Chuck_ArrayF *)OBJ_MEMBER_INT(SELF, uanablob_offset_fvals);
     // check caps
     if( i < 0 || fvals->size() <= i ) RETURN->v_float = 0;
     else
     {
         // get
         t_CKFLOAT val;
-        fvals->get( i, &val );
+        fvals->get( i, (t_CKFLOATARRAY *)&val );
         RETURN->v_float = val;
     }
 }
@@ -2258,7 +2258,7 @@ CK_DLL_MFUN( uanablob_cval )
     // get index
     t_CKINT i = GET_NEXT_INT(ARGS);
     // get the fvals array
-    Chuck_Array16 * cvals = (Chuck_Array16 *)OBJ_MEMBER_INT(SELF, uanablob_offset_cvals);
+    Chuck_ArrayC * cvals = (Chuck_ArrayC *)OBJ_MEMBER_INT(SELF, uanablob_offset_cvals);
     // check caps
     if( i < 0 || cvals->size() <= i ) RETURN->v_complex.re = RETURN->v_complex.im = 0;
     else
@@ -2273,7 +2273,7 @@ CK_DLL_MFUN( uanablob_cval )
 CK_DLL_MFUN( uanablob_cvals )
 {
     // set return
-    RETURN->v_object = (Chuck_Array16 *)OBJ_MEMBER_INT(SELF, uanablob_offset_cvals);
+    RETURN->v_object = (Chuck_ArrayC *)OBJ_MEMBER_INT(SELF, uanablob_offset_cvals);
 }
 
 // ctor
@@ -3100,12 +3100,12 @@ CK_DLL_MFUN( array_push_back )
 {
     Chuck_Array * array = (Chuck_Array *)SELF;
     // TODO: make this safe!
-    if( array->data_type_size() == CHUCK_ARRAY4_DATASIZE )
-        RETURN->v_int = ((Chuck_Array4 *)array)->push_back( GET_NEXT_UINT( ARGS ) );
-    else if( array->data_type_size() == CHUCK_ARRAY8_DATASIZE )
-        RETURN->v_int = ((Chuck_Array8 *)array)->push_back( GET_NEXT_FLOAT( ARGS ) );
-    else if( array->data_type_size() == CHUCK_ARRAY16_DATASIZE )
-        RETURN->v_int = ((Chuck_Array16 *)array)->push_back( GET_NEXT_COMPLEX( ARGS ) );
+    if( array->data_type_size() == sizeof(t_CK1WORD) )
+        RETURN->v_int = ((Chuck_Array4 *)array)->push_back( *(t_CK1WORD *)ARGS );
+    else if( array->data_type_size() == sizeof(t_CK2WORD) )
+        RETURN->v_int = ((Chuck_Array8 *)array)->push_back( *(t_CK2WORD *)ARGS );
+    else if( array->data_type_size() == sizeof(t_CK4WORD) )
+        RETURN->v_int = ((Chuck_Array16 *)array)->push_back( *(t_CK4WORD *)ARGS );
     else
         assert( FALSE );
 }
@@ -3115,11 +3115,11 @@ CK_DLL_MFUN( array_pop_back )
 {
     Chuck_Array * array = (Chuck_Array *)SELF;
     // TODO: make this safe!
-    if( array->data_type_size() == CHUCK_ARRAY4_DATASIZE )
+    if( array->data_type_size() == sizeof(t_CK1WORD) )
         RETURN->v_int = ((Chuck_Array4 *)array)->pop_back( );
-    else if( array->data_type_size() == CHUCK_ARRAY8_DATASIZE )
+    else if( array->data_type_size() == sizeof(t_CK2WORD) )
         RETURN->v_int = ((Chuck_Array8 *)array)->pop_back( );
-    else if( array->data_type_size() == CHUCK_ARRAY16_DATASIZE )
+    else if( array->data_type_size() == sizeof(t_CK4WORD) )
         RETURN->v_int = ((Chuck_Array16 *)array)->pop_back( );
     else
         assert( FALSE );
diff --git a/chuck_lang.h b/chuck_lang.h
index 37ee336..c7fa79c 100644
--- a/chuck_lang.h
+++ b/chuck_lang.h
@@ -135,8 +135,8 @@ public:
 
 public:
     t_CKTIME & when();
-    Chuck_Array8 & fvals();
-    Chuck_Array16 & cvals();
+    Chuck_ArrayF & fvals();
+    Chuck_ArrayC & cvals();
 
 public:
     Chuck_Object * realblob() { return m_blob; }
diff --git a/chuck_oo.cpp b/chuck_oo.cpp
index afcb86c..a151783 100644
--- a/chuck_oo.cpp
+++ b/chuck_oo.cpp
@@ -402,7 +402,7 @@ t_CKUINT Chuck_Array4::addr( const string & key )
 // name: get()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array4::get( t_CKINT i, t_CKUINT * val )
+t_CKINT Chuck_Array4::get( t_CKINT i, t_CK1WORD * val )
 {
     // bound check
     if( i < 0 || i >= m_vector.capacity() )
@@ -422,12 +422,12 @@ t_CKINT Chuck_Array4::get( t_CKINT i, t_CKUINT * val )
 // name: get()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array4::get( const string & key, t_CKUINT * val )
+t_CKINT Chuck_Array4::get( const string & key, t_CK1WORD * val )
 {
     // set to zero
-    *val = 0;
+    *val = zero_CK1WORD;
     // find
-    map<string, t_CKUINT>::iterator iter = m_map.find( key );
+    map<string, t_CK1WORD>::iterator iter = m_map.find( key );
     // check
     if( iter != m_map.end() ) *val = (*iter).second;
 
@@ -442,13 +442,13 @@ t_CKINT Chuck_Array4::get( const string & key, t_CKUINT * val )
 // name: set()
 // desc: include ref counting
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array4::set( t_CKINT i, t_CKUINT val )
+t_CKINT Chuck_Array4::set( t_CKINT i, t_CK1WORD val )
 {
     // bound check
     if( i < 0 || i >= m_vector.capacity() )
         return 0;
 
-    t_CKUINT v = m_vector[i];
+    t_CK1WORD v = m_vector[i];
 
     // if obj
     if( m_is_obj && v ) ((Chuck_Object *)v)->release();
@@ -471,9 +471,9 @@ t_CKINT Chuck_Array4::set( t_CKINT i, t_CKUINT val )
 // name: set()
 // desc: include ref counting
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array4::set( const string & key, t_CKUINT val )
+t_CKINT Chuck_Array4::set( const string & key, t_CK1WORD val )
 {
-    map<string, t_CKUINT>::iterator iter = m_map.find( key );
+    map<string, t_CK1WORD>::iterator iter = m_map.find( key );
 
     // if obj
     if( m_is_obj && iter != m_map.end() ) 
@@ -510,7 +510,7 @@ t_CKINT Chuck_Array4::find( const string & key )
 //-----------------------------------------------------------------------------
 t_CKINT Chuck_Array4::erase( const string & key )
 {
-    map<string, t_CKUINT>::iterator iter = m_map.find( key );
+    map<string, t_CK1WORD>::iterator iter = m_map.find( key );
     t_CKINT v = iter != m_map.end();
 
     // if obj
@@ -530,7 +530,7 @@ t_CKINT Chuck_Array4::erase( const string & key )
 // name: push_back()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array4::push_back( t_CKUINT val )
+t_CKINT Chuck_Array4::push_back( t_CK1WORD val )
 {
     // TODO: is this right?
 
@@ -566,7 +566,7 @@ t_CKINT Chuck_Array4::pop_back( )
     }
     
     // zero
-    m_vector[m_vector.size()-1] = 0;
+    m_vector[m_vector.size()-1] = zero_CK1WORD;
     // add to vector
     m_vector.pop_back();
     
@@ -580,7 +580,7 @@ t_CKINT Chuck_Array4::pop_back( )
 // name: back()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array4::back( t_CKUINT * val ) const
+t_CKINT Chuck_Array4::back( t_CK1WORD * val ) const
 {
     // check
     if( m_vector.size() == 0 )
@@ -684,7 +684,7 @@ void Chuck_Array4::zero( t_CKUINT start, t_CKUINT end )
             if( v )
             {
                 v->release();
-                m_vector[i] = 0;
+                m_vector[i] = zero_CK1WORD;
             }
         }
     }
@@ -693,7 +693,7 @@ void Chuck_Array4::zero( t_CKUINT start, t_CKUINT end )
         for( t_CKUINT i = start; i < end; i++ )
         {
             // zero
-            m_vector[i] = 0;
+            m_vector[i] = zero_CK1WORD;
         }
     }
 }
@@ -764,7 +764,7 @@ t_CKUINT Chuck_Array8::addr( const string & key )
 // name: get()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array8::get( t_CKINT i, t_CKFLOAT * val )
+t_CKINT Chuck_Array8::get( t_CKINT i, t_CK2WORD * val )
 {
     // bound check
     if( i < 0 || i >= m_vector.capacity() )
@@ -784,13 +784,13 @@ t_CKINT Chuck_Array8::get( t_CKINT i, t_CKFLOAT * val )
 // name: get()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array8::get( const string & key, t_CKFLOAT * val )
+t_CKINT Chuck_Array8::get( const string & key, t_CK2WORD * val )
 {
     // set to zero
-    *val = 0.0;
+    *val = zero_CK2WORD;
 
     // iterator
-    map<string, t_CKFLOAT>::iterator iter = m_map.find( key );
+    map<string, t_CK2WORD>::iterator iter = m_map.find( key );
 
     // check
     if( iter != m_map.end() )
@@ -810,7 +810,7 @@ t_CKINT Chuck_Array8::get( const string & key, t_CKFLOAT * val )
 // name: set()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array8::set( t_CKINT i, t_CKFLOAT val )
+t_CKINT Chuck_Array8::set( t_CKINT i, t_CK2WORD val )
 {
     // bound check
     if( i < 0 || i >= m_vector.capacity() )
@@ -830,11 +830,11 @@ t_CKINT Chuck_Array8::set( t_CKINT i, t_CKFLOAT val )
 // name: set()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array8::set( const string & key, t_CKFLOAT val )
+t_CKINT Chuck_Array8::set( const string & key, t_CK2WORD val )
 {
-    map<string, t_CKFLOAT>::iterator iter = m_map.find( key );
+    map<string, t_CK2WORD>::iterator iter = m_map.find( key );
 
-    if( !val ) m_map.erase( key );
+    if( !memcmp( &val, &zero_CK2WORD, sizeof(val) ) ) m_map.erase( key );
     else m_map[key] = val;
 
     // return good
@@ -871,7 +871,7 @@ t_CKINT Chuck_Array8::erase( const string & key )
 // name: push_back()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array8::push_back( t_CKFLOAT val )
+t_CKINT Chuck_Array8::push_back( t_CK2WORD val )
 {
     // add to vector
     m_vector.push_back( val );
@@ -893,7 +893,7 @@ t_CKINT Chuck_Array8::pop_back( )
         return 0;
 
     // zero
-    m_vector[m_vector.size()-1] = 0.0;
+    m_vector[m_vector.size()-1] = zero_CK2WORD;
     // add to vector
     m_vector.pop_back();
     
@@ -907,7 +907,7 @@ t_CKINT Chuck_Array8::pop_back( )
 // name: back()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array8::back( t_CKFLOAT * val ) const
+t_CKINT Chuck_Array8::back( t_CK2WORD * val ) const
 {
     // check
     if( m_vector.size() == 0 )
@@ -1002,7 +1002,7 @@ void Chuck_Array8::zero( t_CKUINT start, t_CKUINT end )
     for( t_CKUINT i = start; i < end; i++ )
     {
         // zero
-        m_vector[i] = 0.0;
+        m_vector[i] = zero_CK2WORD;
     }
 }
 
@@ -1072,7 +1072,7 @@ t_CKUINT Chuck_Array16::addr( const string & key )
 // name: get()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array16::get( t_CKINT i, t_CKCOMPLEX * val )
+t_CKINT Chuck_Array16::get( t_CKINT i, t_CK4WORD * val )
 {
     // bound check
     if( i < 0 || i >= m_vector.capacity() )
@@ -1092,14 +1092,13 @@ t_CKINT Chuck_Array16::get( t_CKINT i, t_CKCOMPLEX * val )
 // name: get()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array16::get( const string & key, t_CKCOMPLEX * val )
+t_CKINT Chuck_Array16::get( const string & key, t_CK4WORD * val )
 {
     // set to zero
-    val->re = 0.0;
-    val->im = 0.0;
+    *val = zero_CK4WORD;
 
     // iterator
-    map<string, t_CKCOMPLEX>::iterator iter = m_map.find( key );
+    map<string, t_CK4WORD>::iterator iter = m_map.find( key );
 
     // check
     if( iter != m_map.end() )
@@ -1119,7 +1118,7 @@ t_CKINT Chuck_Array16::get( const string & key, t_CKCOMPLEX * val )
 // name: set()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array16::set( t_CKINT i, t_CKCOMPLEX val )
+t_CKINT Chuck_Array16::set( t_CKINT i, t_CK4WORD val )
 {
     // bound check
     if( i < 0 || i >= m_vector.capacity() )
@@ -1139,11 +1138,11 @@ t_CKINT Chuck_Array16::set( t_CKINT i, t_CKCOMPLEX val )
 // name: set()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array16::set( const string & key, t_CKCOMPLEX val )
+t_CKINT Chuck_Array16::set( const string & key, t_CK4WORD val )
 {
-    map<string, t_CKCOMPLEX>::iterator iter = m_map.find( key );
+    map<string, t_CK4WORD>::iterator iter = m_map.find( key );
 
-    if( val.re == 0 && val.im == 0 ) m_map.erase( key );
+    if( !memcmp( &val, &zero_CK4WORD, sizeof(val) ) ) m_map.erase( key );
     else m_map[key] = val;
 
     // return good
@@ -1180,7 +1179,7 @@ t_CKINT Chuck_Array16::erase( const string & key )
 // name: push_back()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array16::push_back( t_CKCOMPLEX val )
+t_CKINT Chuck_Array16::push_back( t_CK4WORD val )
 {
     // add to vector
     m_vector.push_back( val );
@@ -1202,8 +1201,7 @@ t_CKINT Chuck_Array16::pop_back( )
         return 0;
 
     // zero
-    m_vector[m_vector.size()-1].re = 0.0;
-    m_vector[m_vector.size()-1].im = 0.0;
+    m_vector[m_vector.size()-1] = zero_CK4WORD;
     // add to vector
     m_vector.pop_back();
     
@@ -1217,7 +1215,7 @@ t_CKINT Chuck_Array16::pop_back( )
 // name: back()
 // desc: ...
 //-----------------------------------------------------------------------------
-t_CKINT Chuck_Array16::back( t_CKCOMPLEX * val ) const
+t_CKINT Chuck_Array16::back( t_CK4WORD * val ) const
 {
     // check
     if( m_vector.size() == 0 )
@@ -1312,8 +1310,7 @@ void Chuck_Array16::zero( t_CKUINT start, t_CKUINT end )
     for( t_CKUINT i = start; i < end; i++ )
     {
         // zero
-        m_vector[i].re = 0.0;
-        m_vector[i].im = 0.0;
+        m_vector[i] = zero_CK4WORD;
     }
 }
 
diff --git a/chuck_oo.h b/chuck_oo.h
index 6bedcc2..9e80fb8 100644
--- a/chuck_oo.h
+++ b/chuck_oo.h
@@ -33,14 +33,14 @@
 #ifndef __CHUCK_OO_H__
 #define __CHUCK_OO_H__
 
-#include "chuck_def.h"
+#include "chuck_def.h"
 #include <string>
 #include <vector>
 #include <map>
 #include <queue>
 #include <fstream>
 #include "util_thread.h" // added 1.3.0.0
-
+
 
 #ifndef __PLATFORM_WIN32__
   #include <dirent.h>
@@ -168,9 +168,6 @@ public:
 
 
 
-#define CHUCK_ARRAY4_DATASIZE 4
-#define CHUCK_ARRAY8_DATASIZE 8
-#define CHUCK_ARRAY16_DATASIZE 16
 //-----------------------------------------------------------------------------
 // name: struct Chuck_Array
 // desc: native ChucK arrays ( virtual base class )
@@ -203,19 +200,19 @@ public:
 struct Chuck_Array4 : Chuck_Array
 {
 public:
-    Chuck_Array4( t_CKBOOL is_obj, t_CKINT capacity = 8 );
+    Chuck_Array4( t_CKBOOL is_obj = FALSE, t_CKINT capacity = 8 );
     virtual ~Chuck_Array4();
 
 public:
     t_CKUINT addr( t_CKINT i );
     t_CKUINT addr( const std::string & key );
-    t_CKINT get( t_CKINT i, t_CKUINT * val );
-    t_CKINT get( const std::string & key, t_CKUINT * val );
-    t_CKINT set( t_CKINT i, t_CKUINT val );
-    t_CKINT set( const std::string & key, t_CKUINT val );
-    t_CKINT push_back( t_CKUINT val );
+    t_CKINT get( t_CKINT i, t_CK1WORD * val );
+    t_CKINT get( const std::string & key, t_CK1WORD * val );
+    t_CKINT set( t_CKINT i, t_CK1WORD val );
+    t_CKINT set( const std::string & key, t_CK1WORD val );
+    t_CKINT push_back( t_CK1WORD val );
     t_CKINT pop_back( );
-    t_CKINT back( t_CKUINT * val ) const;
+    t_CKINT back( t_CK1WORD * val ) const;
     void    zero( t_CKUINT start, t_CKUINT end );
 
     virtual void    clear( );
@@ -225,11 +222,11 @@ public:
     virtual t_CKINT set_capacity( t_CKINT capacity );
     virtual t_CKINT find( const std::string & key );
     virtual t_CKINT erase( const std::string & key );
-    virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY4_DATASIZE; } 
+    virtual t_CKINT data_type_size( ) { return sizeof(t_CK1WORD); } 
 
 public:
-    std::vector<t_CKUINT> m_vector;
-    std::map<std::string, t_CKUINT> m_map;
+    std::vector<t_CK1WORD> m_vector;
+    std::map<std::string, t_CK1WORD> m_map;
     t_CKBOOL m_is_obj;
     // t_CKINT m_size;
     // t_CKINT m_capacity;
@@ -251,13 +248,13 @@ public:
 public:
     t_CKUINT addr( t_CKINT i );
     t_CKUINT addr( const std::string & key );
-    t_CKINT get( t_CKINT i, t_CKFLOAT * val );
-    t_CKINT get( const std::string & key, t_CKFLOAT * val );
-    t_CKINT set( t_CKINT i, t_CKFLOAT val );
-    t_CKINT set( const std::string & key, t_CKFLOAT val );
-    t_CKINT push_back( t_CKFLOAT val );
+    t_CKINT get( t_CKINT i, t_CK2WORD * val );
+    t_CKINT get( const std::string & key, t_CK2WORD * val );
+    t_CKINT set( t_CKINT i, t_CK2WORD val );
+    t_CKINT set( const std::string & key, t_CK2WORD val );
+    t_CKINT push_back( t_CK2WORD val );
     t_CKINT pop_back( );
-    t_CKINT back( t_CKFLOAT * val ) const;
+    t_CKINT back( t_CK2WORD * val ) const;
     void    zero( t_CKUINT start, t_CKUINT end );
 
     virtual void    clear( );
@@ -267,11 +264,11 @@ public:
     virtual t_CKINT set_capacity( t_CKINT capacity );
     virtual t_CKINT find( const std::string & key );
     virtual t_CKINT erase( const std::string & key );
-    virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY8_DATASIZE; }
+    virtual t_CKINT data_type_size( ) { return sizeof(t_CK2WORD); }
 
 public:
-    std::vector<t_CKFLOAT> m_vector;
-    std::map<std::string, t_CKFLOAT> m_map;
+    std::vector<t_CK2WORD> m_vector;
+    std::map<std::string, t_CK2WORD> m_map;
     // t_CKINT m_size;
     // t_CKINT m_capacity;
 };
@@ -292,13 +289,13 @@ public:
 public:
     t_CKUINT addr( t_CKINT i );
     t_CKUINT addr( const std::string & key );
-    t_CKINT get( t_CKINT i, t_CKCOMPLEX * val );
-    t_CKINT get( const std::string & key, t_CKCOMPLEX * val );
-    t_CKINT set( t_CKINT i, t_CKCOMPLEX val );
-    t_CKINT set( const std::string & key, t_CKCOMPLEX val );
-    t_CKINT push_back( t_CKCOMPLEX val );
+    t_CKINT get( t_CKINT i, t_CK4WORD * val );
+    t_CKINT get( const std::string & key, t_CK4WORD * val );
+    t_CKINT set( t_CKINT i, t_CK4WORD val );
+    t_CKINT set( const std::string & key, t_CK4WORD val );
+    t_CKINT push_back( t_CK4WORD val );
     t_CKINT pop_back( );
-    t_CKINT back( t_CKCOMPLEX * val ) const;
+    t_CKINT back( t_CK4WORD * val ) const;
     void    zero( t_CKUINT start, t_CKUINT end );
 
     virtual void    clear( );
@@ -308,16 +305,27 @@ public:
     virtual t_CKINT set_capacity( t_CKINT capacity );
     virtual t_CKINT find( const std::string & key );
     virtual t_CKINT erase( const std::string & key );
-    virtual t_CKINT data_type_size( ) { return CHUCK_ARRAY16_DATASIZE; }
+    virtual t_CKINT data_type_size( ) { return sizeof(t_CK4WORD); }
 
 public:
-    std::vector<t_CKCOMPLEX> m_vector;
-    std::map<std::string, t_CKCOMPLEX> m_map;
+    std::vector<t_CK4WORD> m_vector;
+    std::map<std::string, t_CK4WORD> m_map;
     // t_CKINT m_size;
     // t_CKINT m_capacity;
 };
 
+#ifdef CK32BIT
+#define Chuck_ArrayF		Chuck_Array8
+#define Chuck_ArrayC		Chuck_Array16
+#define t_CKFLOATARRAY		t_CK2WORD
+#define t_CKCOMPLEXARRAY	t_CK4WORD
+#elif defined(CK64BIT)
+#define Chuck_ArrayF		Chuck_Array4
+#define Chuck_ArrayC		Chuck_Array8
+#define t_CKFLOATARRAY		t_CK1WORD
+#define t_CKCOMPLEXARRAY	t_CK2WORD
 
+#endif
 
 
 //-----------------------------------------------------------------------------
diff --git a/uana_extract.cpp b/uana_extract.cpp
index e4b0677..2d20eac 100644
--- a/uana_extract.cpp
+++ b/uana_extract.cpp
@@ -378,12 +378,12 @@ CK_DLL_TOCK( FeatureCollector_tock )
             // sanity check
             assert( BLOB_IN != NULL );
             // count number of features from this UAna
-            Chuck_Array8 & these_fvals = BLOB_IN->fvals();
+            Chuck_ArrayF & these_fvals = BLOB_IN->fvals();
             num_feats += these_fvals.size();
         }
 
         // get fvals of output BLOB
-        Chuck_Array8 & fvals = BLOB->fvals();
+        Chuck_ArrayF & fvals = BLOB->fvals();
         if( fvals.size() != num_feats )
             fvals.set_size( num_feats );
 
@@ -392,12 +392,12 @@ CK_DLL_TOCK( FeatureCollector_tock )
         {
             // get next blob
             Chuck_UAnaBlobProxy * BLOB_IN = UANA->getIncomingBlob( i );
-            Chuck_Array8 & these_fvals = BLOB_IN->fvals();
+            Chuck_ArrayF & these_fvals = BLOB_IN->fvals();
             t_CKINT num_these = these_fvals.size();
             for( j = 0; j < num_these; j++ )
             {
                 t_CKFLOAT v;
-                these_fvals.get( j, &v );
+                these_fvals.get( j, (t_CKFLOATARRAY *)&v );
                 fvals.set( next_index, v);
                 next_index++;
             }
@@ -416,7 +416,7 @@ CK_DLL_PMSG( FeatureCollector_pmsg )
     return TRUE;
 }
 
-static t_CKFLOAT compute_centroid( Chuck_Array8 & buffer, t_CKUINT size )
+static t_CKFLOAT compute_centroid( Chuck_ArrayF & buffer, t_CKUINT size )
 {
     t_CKFLOAT m0 = 0.0;
     t_CKFLOAT m1 = 0.0;
@@ -427,7 +427,7 @@ static t_CKFLOAT compute_centroid( Chuck_Array8 & buffer, t_CKUINT size )
     // Compute centroid using moments
     for( i = 0; i < size; i++ )
     {
-        buffer.get( i, &v );
+        buffer.get( i, (t_CKFLOATARRAY *)&v );
         m1 += (i * v);
         m0 += v;
     }
@@ -459,7 +459,7 @@ CK_DLL_TOCK( Centroid_tock )
         // sanity check
         assert( BLOB_IN != NULL );
         // get the array
-        Chuck_Array8 & mag = BLOB_IN->fvals();
+        Chuck_ArrayF & mag = BLOB_IN->fvals();
         // compute centroid
         result = compute_centroid( mag, mag.size() );
     }
@@ -471,7 +471,7 @@ CK_DLL_TOCK( Centroid_tock )
     }
 
     // get fvals of output BLOB
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure size == resulting size
     if( fvals.size() != 1 )
         fvals.set_size( 1 );
@@ -490,7 +490,7 @@ CK_DLL_PMSG( Centroid_pmsg )
 CK_DLL_SFUN( Centroid_compute )
 {
     // get array
-    Chuck_Array8 * array = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * array = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // sanity check
     if( !array )
     {
@@ -508,8 +508,8 @@ CK_DLL_SFUN( Centroid_compute )
 // Flux state
 struct StateOfFlux
 {
-    Chuck_Array8 prev;
-    Chuck_Array8 norm;
+    Chuck_ArrayF prev;
+    Chuck_ArrayF norm;
     t_CKBOOL initialized;
 
     StateOfFlux()
@@ -520,7 +520,7 @@ struct StateOfFlux
 
 
 // compute norm rms
-static void compute_norm_rms( Chuck_Array8 & curr, Chuck_Array8 & norm )
+static void compute_norm_rms( Chuck_ArrayF & curr, Chuck_ArrayF & norm )
 {
     t_CKUINT i;
     t_CKFLOAT energy = 0.0;
@@ -533,7 +533,7 @@ static void compute_norm_rms( Chuck_Array8 & curr, Chuck_Array8 & norm )
     // get energy
     for( i = 0; i < curr.size(); i++ )
     {
-        curr.get( i, &v );
+        curr.get( i, (t_CKFLOATARRAY *)&v );
         energy += v * v;
     }
 
@@ -549,7 +549,7 @@ static void compute_norm_rms( Chuck_Array8 & curr, Chuck_Array8 & norm )
     
     for( i = 0; i < curr.size(); i++ )
     {
-        curr.get( i, & v );
+        curr.get( i, (t_CKFLOATARRAY *)&v );
         if( v > 0.0) 
             norm.set( i, v / energy );
         else
@@ -558,7 +558,7 @@ static void compute_norm_rms( Chuck_Array8 & curr, Chuck_Array8 & norm )
 }
 
 // compute flux
-static t_CKFLOAT compute_flux( Chuck_Array8 & curr, Chuck_Array8 & prev, Chuck_Array8 * write )
+static t_CKFLOAT compute_flux( Chuck_ArrayF & curr, Chuck_ArrayF & prev, Chuck_ArrayF * write )
 {
     // sanity check
     assert( curr.size() == prev.size() );
@@ -571,8 +571,8 @@ static t_CKFLOAT compute_flux( Chuck_Array8 & curr, Chuck_Array8 & prev, Chuck_A
     t_CKFLOAT v, w, result = 0.0;
     for( t_CKUINT i = 0; i < curr.size(); i++ )
     {
-        curr.get( i, &v );
-        prev.get( i, &w );
+        curr.get( i, (t_CKFLOATARRAY *)&v );
+        prev.get( i, (t_CKFLOATARRAY *)&w );
         // accumulate into flux
         result += (v - w)*(v - w);
         // copy to write
@@ -584,7 +584,7 @@ static t_CKFLOAT compute_flux( Chuck_Array8 & curr, Chuck_Array8 & prev, Chuck_A
 }
 
 // compute flux
-static t_CKFLOAT compute_flux( Chuck_Array8 & curr, StateOfFlux & sof )
+static t_CKFLOAT compute_flux( Chuck_ArrayF & curr, StateOfFlux & sof )
 {
     // flux
     t_CKFLOAT result = 0.0;
@@ -611,7 +611,7 @@ static t_CKFLOAT compute_flux( Chuck_Array8 & curr, StateOfFlux & sof )
     for( t_CKUINT i = 0; i < curr.size(); i++ )
     {
         // get the value
-        sof.norm.get( i, &v );
+        sof.norm.get( i, (t_CKFLOATARRAY *)&v );
         // set it
         sof.prev.set( i, v );
     }
@@ -662,7 +662,7 @@ CK_DLL_TOCK( Flux_tock )
         // sanity check
         assert( BLOB_IN != NULL );
         // get the array
-        Chuck_Array8 & mag = BLOB_IN->fvals();
+        Chuck_ArrayF & mag = BLOB_IN->fvals();
         // compute flux
         result = compute_flux( mag, *state );
     }
@@ -674,7 +674,7 @@ CK_DLL_TOCK( Flux_tock )
     }
 
     // get fvals of output BLOB
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure size == resulting size
     if( fvals.size() != 1 )
         fvals.set_size( 1 );
@@ -701,8 +701,8 @@ CK_DLL_MFUN( Flux_ctrl_reset )
 CK_DLL_SFUN( Flux_compute )
 {
     // get inputs
-    Chuck_Array8 * lhs = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
-    Chuck_Array8 * rhs = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * lhs = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * rhs = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
 
     // verify
     if( !lhs || !rhs )
@@ -731,9 +731,9 @@ CK_DLL_SFUN( Flux_compute )
 CK_DLL_SFUN( Flux_compute2 )
 {
     // get inputs
-    Chuck_Array8 * lhs = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
-    Chuck_Array8 * rhs = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
-    Chuck_Array8 * diff = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * lhs = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * rhs = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * diff = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
 
     // verify
     if( !lhs || !rhs )
@@ -760,7 +760,7 @@ CK_DLL_SFUN( Flux_compute2 )
 }
 
 
-static t_CKFLOAT compute_rms( Chuck_Array8 & buffer, t_CKUINT size )
+static t_CKFLOAT compute_rms( Chuck_ArrayF & buffer, t_CKUINT size )
 {
     t_CKFLOAT rms = 0.0;
     t_CKFLOAT v;
@@ -769,7 +769,7 @@ static t_CKFLOAT compute_rms( Chuck_Array8 & buffer, t_CKUINT size )
     // get sum of squares
     for( i = 0; i < size; i++ )
     {
-        buffer.get( i, &v );
+        buffer.get( i, (t_CKFLOATARRAY *)&v );
         rms += (v * v);
     }
 
@@ -799,7 +799,7 @@ CK_DLL_TOCK( RMS_tock )
         // sanity check
         assert( BLOB_IN != NULL );
         // get the array
-        Chuck_Array8 & mag = BLOB_IN->fvals();
+        Chuck_ArrayF & mag = BLOB_IN->fvals();
         // compute centroid
         result = compute_rms( mag, mag.size() );
     }
@@ -811,7 +811,7 @@ CK_DLL_TOCK( RMS_tock )
     }
 
     // get fvals of output BLOB
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure size == resulting size
     if( fvals.size() != 1 )
         fvals.set_size( 1 );
@@ -830,7 +830,7 @@ CK_DLL_PMSG( RMS_pmsg )
 CK_DLL_SFUN( RMS_compute )
 {
     // get array
-    Chuck_Array8 * array = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * array = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // sanity check
     if( !array )
     {
@@ -845,7 +845,7 @@ CK_DLL_SFUN( RMS_compute )
 }
 
 
-static t_CKFLOAT compute_rolloff( Chuck_Array8 & buffer, t_CKUINT size, t_CKFLOAT percent )
+static t_CKFLOAT compute_rolloff( Chuck_ArrayF & buffer, t_CKUINT size, t_CKFLOAT percent )
 {
     t_CKFLOAT sum = 0.0, v, target;
     t_CKINT i;
@@ -856,7 +856,7 @@ static t_CKFLOAT compute_rolloff( Chuck_Array8 & buffer, t_CKUINT size, t_CKFLOA
     // iterate
     for( i = 0; i < size; i++ )
     {
-        buffer.get( i, &v );
+        buffer.get( i, (t_CKFLOATARRAY *)&v );
         sum += v;
     }
 
@@ -867,7 +867,7 @@ static t_CKFLOAT compute_rolloff( Chuck_Array8 & buffer, t_CKUINT size, t_CKFLOA
     // iterate
     for( i = 0; i < size; i++ )
     {
-        buffer.get( i, &v );
+        buffer.get( i, (t_CKFLOATARRAY *)&v );
         sum += v;
         if( sum >= target ) break;
     }
@@ -906,7 +906,7 @@ CK_DLL_TOCK( RollOff_tock )
         // sanity check
         assert( BLOB_IN != NULL );
         // get the array
-        Chuck_Array8 & mag = BLOB_IN->fvals();
+        Chuck_ArrayF & mag = BLOB_IN->fvals();
         // compute rolloff
         result = compute_rolloff( mag, mag.size(), percent );
     }
@@ -918,7 +918,7 @@ CK_DLL_TOCK( RollOff_tock )
     }
 
     // get fvals of output BLOB
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure size == resulting size
     if( fvals.size() != 1 )
         fvals.set_size( 1 );
@@ -956,7 +956,7 @@ CK_DLL_CGET( RollOff_cget_percent )
 CK_DLL_SFUN( RollOff_compute )
 {
     // get array
-    Chuck_Array8 * array = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * array = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // get percent
     t_CKFLOAT percent = GET_NEXT_FLOAT(ARGS);
 
@@ -1097,8 +1097,8 @@ struct Corr_Object
 Corr_Object * Corr_Object::ourCorr = NULL;
 
 // compute correlation
-static void compute_corr( Corr_Object * corr, Chuck_Array8 & f, t_CKINT fs, 
-                          Chuck_Array8 & g, t_CKINT gs, Chuck_Array8 & buffy )
+static void compute_corr( Corr_Object * corr, Chuck_ArrayF & f, t_CKINT fs, 
+                          Chuck_ArrayF & g, t_CKINT gs, Chuck_ArrayF & buffy )
 {
     t_CKINT i;
     t_CKFLOAT v;
@@ -1110,12 +1110,12 @@ static void compute_corr( Corr_Object * corr, Chuck_Array8 & f, t_CKINT fs,
     // copy into buffers
     for( i = 0; i < fs; i++ )
     {
-        f.get( i, &v );
+        f.get( i, (t_CKFLOATARRAY *)&v );
         corr->fbuf[i] = v;
     }
     for( i = 0; i < gs; i++ )
     {
-        g.get( i, &v );
+        g.get( i, (t_CKFLOATARRAY *)&v );
         corr->gbuf[i] = v;
     }
 
@@ -1173,9 +1173,9 @@ CK_DLL_TOCK( AutoCorr_tock )
         // sanity check
         assert( BLOB_IN != NULL );
         // get the array
-        Chuck_Array8 & mag = BLOB_IN->fvals();
+        Chuck_ArrayF & mag = BLOB_IN->fvals();
         // get fvals of output BLOB
-        Chuck_Array8 & fvals = BLOB->fvals();
+        Chuck_ArrayF & fvals = BLOB->fvals();
         // compute autocorr
         compute_corr( ac, mag, mag.size(), mag, mag.size(), fvals );
     }
@@ -1183,7 +1183,7 @@ CK_DLL_TOCK( AutoCorr_tock )
     else
     {
         // get fvals of output BLOB
-        Chuck_Array8 & fvals = BLOB->fvals();
+        Chuck_ArrayF & fvals = BLOB->fvals();
         // resize
         fvals.set_size( 0 );
     }
@@ -1218,11 +1218,11 @@ CK_DLL_CGET( AutoCorr_cget_normalize )
 CK_DLL_SFUN( AutoCorr_compute )
 {
     // get input
-    Chuck_Array8 * input = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * input = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // get normalize flag
     t_CKINT normalize = GET_NEXT_INT(ARGS) != 0;
     // get input
-    Chuck_Array8 * output = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * output = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
 
     // set normalize
     Corr_Object::getOurObject()->normalize = normalize;
@@ -1267,10 +1267,10 @@ CK_DLL_TOCK( XCorr_tock )
         // sanity check
         assert( BLOB_F != NULL && BLOB_G != NULL );
         // get the array
-        Chuck_Array8 & mag_f = BLOB_F->fvals();
-        Chuck_Array8 & mag_g = BLOB_G->fvals();
+        Chuck_ArrayF & mag_f = BLOB_F->fvals();
+        Chuck_ArrayF & mag_g = BLOB_G->fvals();
         // get fvals of output BLOB
-        Chuck_Array8 & fvals = BLOB->fvals();
+        Chuck_ArrayF & fvals = BLOB->fvals();
         // compute xcorr
         compute_corr( xc, mag_f, mag_f.size(), mag_g, mag_g.size(), fvals );
     }
@@ -1278,7 +1278,7 @@ CK_DLL_TOCK( XCorr_tock )
     else
     {
         // get fvals of output BLOB
-        Chuck_Array8 & fvals = BLOB->fvals();
+        Chuck_ArrayF & fvals = BLOB->fvals();
         // resize
         fvals.set_size( 0 );
     }
@@ -1313,12 +1313,12 @@ CK_DLL_CGET( XCorr_cget_normalize )
 CK_DLL_SFUN( XCorr_compute )
 {
     // get input
-    Chuck_Array8 * f = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
-    Chuck_Array8 * g = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * f = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * g = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // get normalize flag
     t_CKINT normalize = GET_NEXT_INT(ARGS) != 0;
     // get output
-    Chuck_Array8 * output = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * output = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
 
     // set normalize
     Corr_Object::getOurObject()->normalize = normalize;
@@ -1389,16 +1389,16 @@ void xcorr_normalize( SAMPLE * buffy, t_CKINT size, SAMPLE * f, t_CKINT fs, SAMP
 
 // ZeroX
 #define __SGN(x)  (x >= 0.0f ? 1.0f : -1.0f )
-static t_CKINT compute_zerox( Chuck_Array8 & buffer, t_CKUINT size )
+static t_CKINT compute_zerox( Chuck_ArrayF & buffer, t_CKUINT size )
 {
     t_CKUINT i, xings = 0;
     t_CKFLOAT v = 0, p = 0;
-    buffer.get( 0, &p );
+    buffer.get( 0, (t_CKFLOATARRAY *)&p );
 
     // Compute centroid using moments
     for( i = 0; i < size; i++ )
     {
-        buffer.get( i, &v );
+        buffer.get( i, (t_CKFLOATARRAY *)&v );
         xings += __SGN(v) != __SGN(p);
         p = v;
     }
@@ -1439,7 +1439,7 @@ CK_DLL_TOCK( ZeroX_tock )
         // sanity check
         assert( BLOB_IN != NULL );
         // get the array
-        Chuck_Array8 & mag = BLOB_IN->fvals();
+        Chuck_ArrayF & mag = BLOB_IN->fvals();
         // compute ZeroX
         result = (t_CKFLOAT)( compute_zerox( mag, mag.size() ) + .5 );
     }
@@ -1451,7 +1451,7 @@ CK_DLL_TOCK( ZeroX_tock )
     }
 
     // get fvals of output BLOB
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure size == resulting size
     if( fvals.size() != 1 )
         fvals.set_size( 1 );
@@ -1470,7 +1470,7 @@ CK_DLL_PMSG( ZeroX_pmsg )
 CK_DLL_SFUN( ZeroX_compute )
 {
     // get array
-    Chuck_Array8 * array = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * array = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // sanity check
     if( !array )
     {
diff --git a/uana_xform.cpp b/uana_xform.cpp
index 2ac1d48..6ef918d 100644
--- a/uana_xform.cpp
+++ b/uana_xform.cpp
@@ -148,7 +148,7 @@ CK_DLL_SFUN( Windowing_blackmanHarris );
 CK_DLL_SFUN( Windowing_rectangle );
 CK_DLL_SFUN( Windowing_triangle );
 // static array
-static Chuck_Array8 * Windowing_array = NULL;
+static Chuck_ArrayF * Windowing_array = NULL;
 static FLOAT * float_array = NULL;
 static t_CKINT float_array_size = 0;
 
@@ -278,7 +278,7 @@ DLL_QUERY xform_query( Chuck_DL_Query * QUERY )
     QUERY->end_class( QUERY );
 
     // initialize static data
-    Windowing_array = new Chuck_Array8();
+    Windowing_array = new Chuck_ArrayF();
     initialize_object( Windowing_array, &t_array );
     // TODO: yes? reference count
     Windowing_array->add_ref();
@@ -478,10 +478,10 @@ public:
     
 public:
     t_CKBOOL resize( t_CKINT size );
-    t_CKBOOL window( Chuck_Array8 * window, t_CKINT win_size );
+    t_CKBOOL window( Chuck_ArrayF * window, t_CKINT win_size );
     void transform( );
-    void transform( Chuck_Array8 * frame );
-    void copyTo( Chuck_Array16 * cmp );
+    void transform( Chuck_ArrayF * frame );
+    void copyTo( Chuck_ArrayC * cmp );
 
 public:
     // size of FFT
@@ -598,7 +598,7 @@ t_CKBOOL FFT_object::resize( t_CKINT size )
 // name: window()
 // desc: set window
 //-----------------------------------------------------------------------------
-t_CKBOOL FFT_object::window( Chuck_Array8 * win, t_CKINT win_size )
+t_CKBOOL FFT_object::window( Chuck_ArrayF * win, t_CKINT win_size )
 {
     // sanity check
     assert( win_size >= 0 );
@@ -632,7 +632,7 @@ t_CKBOOL FFT_object::window( Chuck_Array8 * win, t_CKINT win_size )
         for( t_CKINT i = 0; i < win_size; i++ )
         {
             // get
-            win->get( i, &sample );
+            win->get( i, (t_CKFLOATARRAY *)&sample );
             // set
             m_window[i] = (SAMPLE)sample;
         }
@@ -696,7 +696,7 @@ void FFT_object::transform( )
 // name: transform()
 // desc: ...
 //-----------------------------------------------------------------------------
-void FFT_object::transform( Chuck_Array8 * frame )
+void FFT_object::transform( Chuck_ArrayF * frame )
 {
     // convert to right type
     t_CKINT amount = ck_min( frame->size(), m_size );
@@ -705,7 +705,7 @@ void FFT_object::transform( Chuck_Array8 * frame )
     for( t_CKINT i = 0; i < amount; i++ )
     {
         // real and imag
-        frame->get( i, &v );
+        frame->get( i, (t_CKFLOATARRAY *)&v );
         m_buffer[i] = v;
     }
     // zero pad
@@ -723,7 +723,7 @@ void FFT_object::transform( Chuck_Array8 * frame )
 // name: copyTo()
 // desc: ...
 //-----------------------------------------------------------------------------
-void FFT_object::copyTo( Chuck_Array16 * cmp )
+void FFT_object::copyTo( Chuck_ArrayC * cmp )
 {
     // buffer could be null
     if( m_buffer == NULL && m_spectrum == NULL )
@@ -837,7 +837,7 @@ CK_DLL_TOCK( FFT_tock )
     t_CKINT i;
 
     // get cvals of output BLOB
-    Chuck_Array16 & cvals = BLOB->cvals();
+    Chuck_ArrayC & cvals = BLOB->cvals();
     // ensure capacity == resulting size
     if( cvals.size() != fft->m_size/2 )
         cvals.set_size( fft->m_size/2 );
@@ -846,7 +846,7 @@ CK_DLL_TOCK( FFT_tock )
         cvals.set( i, fft->m_spectrum[i] );
 
     // get fvals of output BLOB; fill with magnitude spectrum
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure size == resulting size
     if( fvals.size() != fft->m_size/2 )
         fvals.set_size( fft->m_size/2 );
@@ -867,7 +867,7 @@ CK_DLL_MFUN( FFT_transform )
     // get object
     FFT_object * fft = (FFT_object *)OBJ_MEMBER_UINT(SELF, FFT_offset_data);
     // get array
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // do it
     fft->transform( arr );
 }
@@ -882,7 +882,7 @@ CK_DLL_CTRL( FFT_ctrl_window )
     // get object
     FFT_object * fft = (FFT_object *)OBJ_MEMBER_UINT(SELF, FFT_offset_data);
     // get window (can be NULL)
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // set it
     fft->window( arr, arr != NULL ? arr->size() : 0 );
     // return it through
@@ -973,7 +973,7 @@ CK_DLL_MFUN( FFT_spectrum )
     // get object
     FFT_object * fft = (FFT_object *)OBJ_MEMBER_UINT(SELF, FFT_offset_data);
     // get array
-    Chuck_Array16 * arr = (Chuck_Array16 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayC * arr = (Chuck_ArrayC *)GET_NEXT_OBJECT(ARGS);
     // check for null
     if( !arr )
     {
@@ -1001,10 +1001,10 @@ public:
     
 public:
     t_CKBOOL resize( t_CKINT size );
-    t_CKBOOL window( Chuck_Array8 * window, t_CKINT win_size );
+    t_CKBOOL window( Chuck_ArrayF * window, t_CKINT win_size );
     void transform( );
-    void transform( Chuck_Array16 * cmp );
-    void copyTo( Chuck_Array8 * samples );
+    void transform( Chuck_ArrayC * cmp );
+    void copyTo( Chuck_ArrayF * samples );
 
 public:
     // size of IFFT
@@ -1119,7 +1119,7 @@ t_CKBOOL IFFT_object::resize( t_CKINT size )
 // name: window()
 // desc: set window
 //-----------------------------------------------------------------------------
-t_CKBOOL IFFT_object::window( Chuck_Array8 * win, t_CKINT win_size )
+t_CKBOOL IFFT_object::window( Chuck_ArrayF * win, t_CKINT win_size )
 {
     // sanity check
     assert( win_size >= 0 );
@@ -1153,7 +1153,7 @@ t_CKBOOL IFFT_object::window( Chuck_Array8 * win, t_CKINT win_size )
         for( t_CKINT i = 0; i < win_size; i++ )
         {
             // get
-            win->get( i, &sample );
+            win->get( i, (t_CKFLOATARRAY *)&sample );
             // set
             m_window[i] = (SAMPLE)sample;
         }
@@ -1207,7 +1207,7 @@ void IFFT_object::transform( )
 // name: transform()
 // desc: ...
 //-----------------------------------------------------------------------------
-void IFFT_object::transform( Chuck_Array16 * cmp )
+void IFFT_object::transform( Chuck_ArrayC * cmp )
 {
     // convert to right type
     t_CKINT amount = ck_min( cmp->size(), m_size/2 );
@@ -1235,7 +1235,7 @@ void IFFT_object::transform( Chuck_Array16 * cmp )
 // name: copyTo()
 // desc: ...
 //-----------------------------------------------------------------------------
-void IFFT_object::copyTo( Chuck_Array8 * samples )
+void IFFT_object::copyTo( Chuck_ArrayF * samples )
 {
     // buffer could be null
     if( m_buffer == NULL && m_inverse == NULL )
@@ -1329,7 +1329,7 @@ CK_DLL_TOCK( IFFT_tock )
         // sanity check
         assert( BLOB_IN != NULL );
         // get the array
-        Chuck_Array16 & cmp = BLOB_IN->cvals();
+        Chuck_ArrayC & cmp = BLOB_IN->cvals();
         // resize if necessary
         if( cmp.size()*2 > ifft->m_size )
             ifft->resize( cmp.size()*2 );
@@ -1358,7 +1358,7 @@ CK_DLL_TOCK( IFFT_tock )
     }
 
     // get fvals of output BLOB
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure size == resulting size
     if( fvals.size() != ifft->m_size )
         fvals.set_size( ifft->m_size );
@@ -1379,7 +1379,7 @@ CK_DLL_MFUN( IFFT_transform )
     // get object
     IFFT_object * ifft = (IFFT_object *)OBJ_MEMBER_UINT(SELF, IFFT_offset_data);
     // get complex array
-    Chuck_Array16 * cmp = (Chuck_Array16 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayC * cmp = (Chuck_ArrayC *)GET_NEXT_OBJECT(ARGS);
     // sanity
     if( cmp == NULL ) goto null_pointer;
     // resize if bigger
@@ -1415,7 +1415,7 @@ CK_DLL_CTRL( IFFT_ctrl_window )
     // get object
     IFFT_object * ifft = (IFFT_object *)OBJ_MEMBER_UINT(SELF, IFFT_offset_data );
     // get win (can be NULL)
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // set it
     ifft->window( arr, arr != NULL ? arr->size() : 0 );
     // return
@@ -1506,7 +1506,7 @@ CK_DLL_MFUN( IFFT_inverse )
     // get object
     IFFT_object * ifft = (IFFT_object *)OBJ_MEMBER_UINT(SELF, IFFT_offset_data);
     // get array
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // check for null
     if( !arr )
     {
@@ -1711,10 +1711,10 @@ public:
     
 public:
     t_CKBOOL resize( t_CKINT size );
-    t_CKBOOL window( Chuck_Array8 * window, t_CKINT win_size );
+    t_CKBOOL window( Chuck_ArrayF * window, t_CKINT win_size );
     void transform( );
-    void transform( Chuck_Array8 * frame );
-    void copyTo( Chuck_Array8 * val );
+    void transform( Chuck_ArrayF * frame );
+    void copyTo( Chuck_ArrayF * val );
 
 public:
     // buffer
@@ -1818,7 +1818,7 @@ t_CKBOOL Flip_object::resize( t_CKINT size )
 // name: window()
 // desc: set window
 //-----------------------------------------------------------------------------
-t_CKBOOL Flip_object::window( Chuck_Array8 * win, t_CKINT win_size )
+t_CKBOOL Flip_object::window( Chuck_ArrayF * win, t_CKINT win_size )
 {
     // sanity check
     assert( win_size >= 0 );
@@ -1852,7 +1852,7 @@ t_CKBOOL Flip_object::window( Chuck_Array8 * win, t_CKINT win_size )
         for( t_CKINT i = 0; i < win_size; i++ )
         {
             // get
-            win->get( i, &sample );
+            win->get( i, (t_CKFLOATARRAY *)&sample );
             // set
             m_window[i] = (SAMPLE)sample;
         }
@@ -1906,7 +1906,7 @@ void Flip_object::transform( )
 // name: transform()
 // desc: ...
 //-----------------------------------------------------------------------------
-void Flip_object::transform( Chuck_Array8 * frame )
+void Flip_object::transform( Chuck_ArrayF * frame )
 {
     // convert to right type
     t_CKINT amount = ck_min( frame->size(), m_size );
@@ -1915,7 +1915,7 @@ void Flip_object::transform( Chuck_Array8 * frame )
     for( t_CKINT i = 0; i < amount; i++ )
     {
         // real and imag
-        frame->get( i, &v );
+        frame->get( i, (t_CKFLOATARRAY *)&v );
         m_buffer[i] = v;
     }
     // zero pad
@@ -1933,7 +1933,7 @@ void Flip_object::transform( Chuck_Array8 * frame )
 // name: copyTo()
 // desc: ...
 //-----------------------------------------------------------------------------
-void Flip_object::copyTo( Chuck_Array8 * val )
+void Flip_object::copyTo( Chuck_ArrayF * val )
 {
     // buffer could be null
     if( m_buffer == NULL )
@@ -2021,7 +2021,7 @@ CK_DLL_TOCK( Flip_tock )
     t_CKINT i;
 
     // get fvals of output BLOB
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure capacity == resulting size
     if( fvals.size() != flip->m_size )
         fvals.set_size( flip->m_size );
@@ -2042,7 +2042,7 @@ CK_DLL_MFUN( Flip_take )
     // get object
     Flip_object * flip = (Flip_object *)OBJ_MEMBER_UINT(SELF, Flip_offset_data);
     // get array
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // do it
     flip->transform( arr );
 }
@@ -2057,7 +2057,7 @@ CK_DLL_CTRL( Flip_ctrl_window )
     // get object
     Flip_object * flip = (Flip_object *)OBJ_MEMBER_UINT(SELF, Flip_offset_data);
     // get window (can be NULL)
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // set it
     flip->window( arr, arr != NULL ? arr->size() : 0 );
     // return it through
@@ -2148,7 +2148,7 @@ CK_DLL_MFUN( Flip_output )
     // get object
     Flip_object * flip = (Flip_object *)OBJ_MEMBER_UINT(SELF, Flip_offset_data);
     // get array
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // check for null
     if( !arr )
     {
@@ -2176,10 +2176,10 @@ public:
     
 public:
     t_CKBOOL resize( t_CKINT size );
-    t_CKBOOL window( Chuck_Array8 * window, t_CKINT win_size );
+    t_CKBOOL window( Chuck_ArrayF * window, t_CKINT win_size );
     void transform( );
-    void transform( Chuck_Array8 * val );
-    void copyTo( Chuck_Array8 * samples );
+    void transform( Chuck_ArrayF * val );
+    void copyTo( Chuck_ArrayF * samples );
 
 public:
     // size of IFFT
@@ -2281,7 +2281,7 @@ t_CKBOOL UnFlip_object::resize( t_CKINT size )
 // name: window()
 // desc: set window
 //-----------------------------------------------------------------------------
-t_CKBOOL UnFlip_object::window( Chuck_Array8 * win, t_CKINT win_size )
+t_CKBOOL UnFlip_object::window( Chuck_ArrayF * win, t_CKINT win_size )
 {
     // sanity check
     assert( win_size >= 0 );
@@ -2315,7 +2315,7 @@ t_CKBOOL UnFlip_object::window( Chuck_Array8 * win, t_CKINT win_size )
         for( t_CKINT i = 0; i < win_size; i++ )
         {
             // get
-            win->get( i, &sample );
+            win->get( i, (t_CKFLOATARRAY *)&sample );
             // set
             m_window[i] = (SAMPLE)sample;
         }
@@ -2365,7 +2365,7 @@ void UnFlip_object::transform( )
 // name: transform()
 // desc: ...
 //-----------------------------------------------------------------------------
-void UnFlip_object::transform( Chuck_Array8 * val )
+void UnFlip_object::transform( Chuck_ArrayF * val )
 {
     // convert to right type
     t_CKINT amount = ck_min( val->size(), m_size );
@@ -2374,7 +2374,7 @@ void UnFlip_object::transform( Chuck_Array8 * val )
     for( t_CKINT i = 0; i < amount; i++ )
     {
         // real and imag
-        val->get( i, &v );
+        val->get( i, (t_CKFLOATARRAY *)&v );
         m_buffer[i] = v;
     }
     // zero pad
@@ -2392,7 +2392,7 @@ void UnFlip_object::transform( Chuck_Array8 * val )
 // name: copyTo()
 // desc: ...
 //-----------------------------------------------------------------------------
-void UnFlip_object::copyTo( Chuck_Array8 * samples )
+void UnFlip_object::copyTo( Chuck_ArrayF * samples )
 {
     // buffer could be null
     if( m_buffer == NULL )
@@ -2482,7 +2482,7 @@ CK_DLL_TOCK( UnFlip_tock )
         // sanity check
         assert( BLOB_IN != NULL );
         // get the array
-        Chuck_Array8 & val = BLOB_IN->fvals();
+        Chuck_ArrayF & val = BLOB_IN->fvals();
         // resize if necessary
         if( val.size() > unflip->m_size )
             unflip->resize( val.size() );
@@ -2493,7 +2493,7 @@ CK_DLL_TOCK( UnFlip_tock )
         for( t_CKINT i = 0; i < unflip->m_size; i++ )
         {
             // copy value in
-            val.get( i, &v );
+            val.get( i, (t_CKFLOATARRAY *)&v );
             unflip->m_buffer[i] = v;
         }
 
@@ -2509,7 +2509,7 @@ CK_DLL_TOCK( UnFlip_tock )
     }
 
     // get fvals of output BLOB
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure size == resulting size
     if( fvals.size() != unflip->m_size )
         fvals.set_size( unflip->m_size );
@@ -2530,7 +2530,7 @@ CK_DLL_MFUN( UnFlip_take )
     // get object
     UnFlip_object * unflip = (UnFlip_object *)OBJ_MEMBER_UINT(SELF, UnFlip_offset_data);
     // get complex array
-    Chuck_Array8 * val = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * val = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // sanity
     if( val == NULL ) goto null_pointer;
     // resize if bigger
@@ -2566,7 +2566,7 @@ CK_DLL_CTRL( UnFlip_ctrl_window )
     // get object
     UnFlip_object * unflip = (UnFlip_object *)OBJ_MEMBER_UINT(SELF, UnFlip_offset_data );
     // get win (can be NULL)
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // set it
     unflip->window( arr, arr != NULL ? arr->size() : 0 );
     // return
@@ -2657,7 +2657,7 @@ CK_DLL_MFUN( UnFlip_output )
     // get object
     UnFlip_object * unflip = (UnFlip_object *)OBJ_MEMBER_UINT(SELF, UnFlip_offset_data);
     // get array
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // check for null
     if( !arr )
     {
@@ -2685,10 +2685,10 @@ public:
     
 public:
     t_CKBOOL resize( t_CKINT size );
-    t_CKBOOL window( Chuck_Array8 * window, t_CKINT win_size );
+    t_CKBOOL window( Chuck_ArrayF * window, t_CKINT win_size );
     void transform( );
     void transform( const t_CKFLOAT * in, t_CKCOMPLEX * out );
-    void copyTo( Chuck_Array8 * frame );
+    void copyTo( Chuck_ArrayF * frame );
 
 public:
     // size of DCT
@@ -2810,7 +2810,7 @@ t_CKBOOL DCT_object::resize( t_CKINT size )
 // name: window()
 // desc: set window
 //-----------------------------------------------------------------------------
-t_CKBOOL DCT_object::window( Chuck_Array8 * win, t_CKINT win_size )
+t_CKBOOL DCT_object::window( Chuck_ArrayF * win, t_CKINT win_size )
 {
     // sanity check
     assert( win_size >= 0 );
@@ -2844,7 +2844,7 @@ t_CKBOOL DCT_object::window( Chuck_Array8 * win, t_CKINT win_size )
         for( t_CKINT i = 0; i < win_size; i++ )
         {
             // get
-            win->get( i, &sample );
+            win->get( i, (t_CKFLOATARRAY *)&sample );
             // set
             m_window[i] = (SAMPLE)sample;
         }
@@ -2900,7 +2900,7 @@ void DCT_object::transform( )
 // name: copyTo()
 // desc: ...
 //-----------------------------------------------------------------------------
-void DCT_object::copyTo( Chuck_Array8 * frame )
+void DCT_object::copyTo( Chuck_ArrayF * frame )
 {
     // buffer could be null
     if( m_buffer == NULL && m_spectrum == NULL )
@@ -3014,7 +3014,7 @@ CK_DLL_TOCK( DCT_tock )
     t_CKINT i;
 
     // get cvals of output BLOB
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure capacity == resulting size
     if( fvals.size() != dct->m_size )
         fvals.set_size( dct->m_size );
@@ -3035,7 +3035,7 @@ CK_DLL_MFUN( DCT_transform )
     // get object
 //    DCT_object * dct = (DCT_object *)OBJ_MEMBER_UINT(SELF, DCT_offset_data);
     // get array
-//    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+//    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
 }
 
 
@@ -3048,7 +3048,7 @@ CK_DLL_CTRL( DCT_ctrl_window )
     // get object
     DCT_object * dct = (DCT_object *)OBJ_MEMBER_UINT(SELF, DCT_offset_data);
     // get window (can be NULL)
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // set it
     dct->window( arr, arr != NULL ? arr->size() : 0 );
 }
@@ -3135,7 +3135,7 @@ CK_DLL_MFUN( DCT_spectrum )
     // get object
     DCT_object * dct = (DCT_object *)OBJ_MEMBER_UINT(SELF, DCT_offset_data);
     // get array
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // check for null
     if( !arr )
     {
@@ -3163,10 +3163,10 @@ public:
     
 public:
     t_CKBOOL resize( t_CKINT size );
-    t_CKBOOL window( Chuck_Array8 * window, t_CKINT win_size );
+    t_CKBOOL window( Chuck_ArrayF * window, t_CKINT win_size );
     void transform( );
-    void transform( Chuck_Array8 * frame );
-    void copyTo( Chuck_Array8 * samples );
+    void transform( Chuck_ArrayF * frame );
+    void copyTo( Chuck_ArrayF * samples );
 
 public:
     // size of IDCT
@@ -3285,7 +3285,7 @@ t_CKBOOL IDCT_object::resize( t_CKINT size )
 // name: window()
 // desc: set window
 //-----------------------------------------------------------------------------
-t_CKBOOL IDCT_object::window( Chuck_Array8 * win, t_CKINT win_size )
+t_CKBOOL IDCT_object::window( Chuck_ArrayF * win, t_CKINT win_size )
 {
     // sanity check
     assert( win_size >= 0 );
@@ -3319,7 +3319,7 @@ t_CKBOOL IDCT_object::window( Chuck_Array8 * win, t_CKINT win_size )
         for( t_CKINT i = 0; i < win_size; i++ )
         {
             // get
-            win->get( i, &sample );
+            win->get( i, (t_CKFLOATARRAY *)&sample );
             // set
             m_window[i] = (SAMPLE)sample;
         }
@@ -3371,7 +3371,7 @@ void IDCT_object::transform( )
 // name: transform()
 // desc: ...
 //-----------------------------------------------------------------------------
-void IDCT_object::transform( Chuck_Array8 * frame )
+void IDCT_object::transform( Chuck_ArrayF * frame )
 {
     // convert to right type
     t_CKINT amount = ck_min( frame->size(), m_size );
@@ -3380,7 +3380,7 @@ void IDCT_object::transform( Chuck_Array8 * frame )
     for( t_CKINT i = 0; i < amount; i++ )
     {
         // real and imag
-        frame->get( i, &v );
+        frame->get( i, (t_CKFLOATARRAY *)&v );
         m_buffer[i] = v;
     }
     // zero pad
@@ -3398,7 +3398,7 @@ void IDCT_object::transform( Chuck_Array8 * frame )
 // name: copyTo()
 // desc: ...
 //-----------------------------------------------------------------------------
-void IDCT_object::copyTo( Chuck_Array8 * samples )
+void IDCT_object::copyTo( Chuck_ArrayF * samples )
 {
     // buffer could be null
     if( m_buffer == NULL && m_inverse == NULL )
@@ -3491,7 +3491,7 @@ CK_DLL_TOCK( IDCT_tock )
         // sanity check
         assert( BLOB_IN != NULL );
         // get the array
-        Chuck_Array16 & cmp = BLOB_IN->cvals();
+        Chuck_ArrayC & cmp = BLOB_IN->cvals();
         // resize if necessary
         if( cmp.size()*2 > idct->m_size )
             idct->resize( cmp.size()*2 );
@@ -3520,7 +3520,7 @@ CK_DLL_TOCK( IDCT_tock )
     }
 
     // get fvals of output BLOB
-    Chuck_Array8 & fvals = BLOB->fvals();
+    Chuck_ArrayF & fvals = BLOB->fvals();
     // ensure size == resulting size
     if( fvals.size() != idct->m_size )
         fvals.set_size( idct->m_size );
@@ -3541,7 +3541,7 @@ CK_DLL_MFUN( IDCT_transform )
     // get object
     IDCT_object * idct = (IDCT_object *)OBJ_MEMBER_UINT(SELF, IDCT_offset_data);
     // get complex array
-    Chuck_Array8 * frame = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * frame = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // sanity
     if( frame == NULL ) goto null_pointer;
     // resize if bigger
@@ -3577,7 +3577,7 @@ CK_DLL_CTRL( IDCT_ctrl_window )
     // get object
     IDCT_object * idct = (IDCT_object *)OBJ_MEMBER_UINT(SELF, IDCT_offset_data );
     // get win (can be NULL)
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // set it
     idct->window( arr, arr != NULL ? arr->size() : 0 );
 }
@@ -3664,7 +3664,7 @@ CK_DLL_MFUN( IDCT_inverse )
     // get object
     IDCT_object * idct = (IDCT_object *)OBJ_MEMBER_UINT(SELF, IDCT_offset_data);
     // get array
-    Chuck_Array8 * arr = (Chuck_Array8 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayF * arr = (Chuck_ArrayF *)GET_NEXT_OBJECT(ARGS);
     // check for null
     if( !arr )
     {
diff --git a/ugen_osc.cpp b/ugen_osc.cpp
index 2d5f473..fb89dfb 100644
--- a/ugen_osc.cpp
+++ b/ugen_osc.cpp
@@ -1195,7 +1195,7 @@ CK_DLL_CTRL( gen5_coeffs )
     t_CKINT i = 0, j, k, l, size;
     t_CKFLOAT wmax, xmax=0.0, c, amp2, amp1, coeffs[genX_MAX_COEFFS];
     
-    Chuck_Array8 * in_args = (Chuck_Array8 *)GET_CK_OBJECT(ARGS);
+    Chuck_ArrayF * in_args = (Chuck_ArrayF *)GET_CK_OBJECT(ARGS);
     
     // fprintf(stdout, "calling gen10coeffs, %d\n", weights);
     if(in_args<0) return;
@@ -1204,7 +1204,7 @@ CK_DLL_CTRL( gen5_coeffs )
     
     t_CKFLOAT v;
     for(t_CKUINT ii = 0; ii<size; ii++) {
-        in_args->get(ii, &v);
+        in_args->get(ii, (t_CKFLOATARRAY *)&v);
         // fprintf( stdout, "weight %d = %f...\n", ii, v );
         coeffs[ii] = v;
     }
@@ -1250,7 +1250,7 @@ CK_DLL_CTRL( gen7_coeffs )
     t_CKINT i=0, j, k, l, size;
     t_CKFLOAT wmax, xmax = 0.0, amp2, amp1, coeffs[genX_MAX_COEFFS];
     
-    Chuck_Array8 * in_args = (Chuck_Array8 *)GET_CK_OBJECT(ARGS);
+    Chuck_ArrayF * in_args = (Chuck_ArrayF *)GET_CK_OBJECT(ARGS);
     
     // fprintf(stdout, "calling gen10coeffs, %d\n", weights);
     if(in_args<0) return;
@@ -1259,7 +1259,7 @@ CK_DLL_CTRL( gen7_coeffs )
     
     t_CKFLOAT v;
     for(t_CKUINT ii = 0; ii<size; ii++) {
-        in_args->get(ii, &v);
+        in_args->get(ii, (t_CKFLOATARRAY *)&v);
         // fprintf( stdout, "weight %d = %f...\n", ii, v );
         coeffs[ii] = v;
     }
@@ -1303,7 +1303,7 @@ CK_DLL_CTRL( gen9_coeffs )
     t_CKDOUBLE wmax, xmax=0.0;
     t_CKFLOAT coeffs[genX_MAX_COEFFS];
     
-    Chuck_Array8 * weights = (Chuck_Array8 *)GET_CK_OBJECT(ARGS);
+    Chuck_ArrayF * weights = (Chuck_ArrayF *)GET_CK_OBJECT(ARGS);
     
     // fprintf(stdout, "calling gen10coeffs, %d\n", weights);
     if(weights<0) return;
@@ -1313,7 +1313,7 @@ CK_DLL_CTRL( gen9_coeffs )
     
     t_CKFLOAT v;
     for(t_CKUINT ii = 0; ii<size; ii++) {
-        weights->get(ii, &v);
+        weights->get(ii, (t_CKFLOATARRAY *)&v);
         // fprintf( stdout, "weight %d = %f...\n", ii, v );
         coeffs[ii] = v;
     }
@@ -1353,7 +1353,7 @@ CK_DLL_CTRL( gen10_coeffs )
     t_CKINT i, j, size;
     t_CKDOUBLE wmax, xmax=0.0;
     
-    Chuck_Array8 * weights = (Chuck_Array8 *)GET_CK_OBJECT(ARGS);
+    Chuck_ArrayF * weights = (Chuck_ArrayF *)GET_CK_OBJECT(ARGS);
     
     // fprintf(stdout, "calling gen10coeffs, %d\n", weights);
     if(weights<0) return;
@@ -1362,7 +1362,7 @@ CK_DLL_CTRL( gen10_coeffs )
     
     t_CKFLOAT v;
     for(t_CKUINT ii = 0; ii<size; ii++) {
-        weights->get(ii, &v);
+        weights->get(ii, (t_CKFLOATARRAY *)&v);
         // fprintf( stdout, "weight %d = %f...\n", ii, v );
         d->coeffs[ii] = v;
     }
@@ -1404,7 +1404,7 @@ CK_DLL_CTRL( gen17_coeffs )
     t_CKDOUBLE Tn, Tn1, Tn2, dg, x, wmax = 0.0, xmax = 0.0;
     t_CKFLOAT coeffs[genX_MAX_COEFFS];
     
-    Chuck_Array8 * weights = (Chuck_Array8 *)GET_CK_OBJECT(ARGS);
+    Chuck_ArrayF * weights = (Chuck_ArrayF *)GET_CK_OBJECT(ARGS);
     
     // fprintf(stdout, "calling gen17coeffs, %d\n", weights);
     if(weights<0) return;
@@ -1415,7 +1415,7 @@ CK_DLL_CTRL( gen17_coeffs )
     
     t_CKFLOAT v;
     for(t_CKUINT ii = 0; ii<size; ii++) {
-        weights->get(ii, &v);
+        weights->get(ii, (t_CKFLOATARRAY *)&v);
         // fprintf( stdout, "weight %d = %f...\n", ii, v );
         coeffs[ii] = v;
     }
@@ -1465,7 +1465,7 @@ CK_DLL_CTRL( curve_coeffs )
     t_CKUINT ii = 0;
     t_CKFLOAT v = 0.0;
     
-    Chuck_Array8 * weights = (Chuck_Array8 *)GET_CK_OBJECT(ARGS);
+    Chuck_ArrayF * weights = (Chuck_ArrayF *)GET_CK_OBJECT(ARGS);
     
     // fprintf(stdout, "calling gen17coeffs, %d\n", weights);
     if(weights<0) goto done;
@@ -1481,7 +1481,7 @@ CK_DLL_CTRL( curve_coeffs )
     }
     
     for(ii = 0; ii<nargs; ii++) {
-        weights->get(ii, &v);
+        weights->get(ii, (t_CKFLOATARRAY *)&v);
         // fprintf( stdout, "weight %d = %f...\n", ii, v );
         coeffs[ii] = v;
     }
@@ -1568,7 +1568,7 @@ CK_DLL_CTRL( warp_coeffs )
     t_CKFLOAT k_sym  = 1.; 
 
     // gewang:
-    Chuck_Array8 * weights = (Chuck_Array8 *)GET_CK_OBJECT(ARGS);
+    Chuck_ArrayF * weights = (Chuck_ArrayF *)GET_CK_OBJECT(ARGS);
     // check for size
     if( weights->size() != 2 )
     {
@@ -1577,8 +1577,8 @@ CK_DLL_CTRL( warp_coeffs )
         goto done;
     }
 
-    weights->get( 0, &k_asym ); // (t_CKDOUBLE) GET_NEXT_FLOAT(ARGS);
-    weights->get( 1, &k_sym ); // (t_CKDOUBLE) GET_NEXT_FLOAT(ARGS);
+    weights->get( 0, (t_CKFLOATARRAY *)&k_asym ); // (t_CKDOUBLE) GET_NEXT_FLOAT(ARGS);
+    weights->get( 1, (t_CKFLOATARRAY *)&k_sym ); // (t_CKDOUBLE) GET_NEXT_FLOAT(ARGS);
 
     for (i = 0; i < genX_tableSize; i++) {
         t_CKDOUBLE inval = (t_CKDOUBLE) i/(genX_tableSize - 1);
diff --git a/ulib_math.cpp b/ulib_math.cpp
index 4dea9d6..451eb85 100644
--- a/ulib_math.cpp
+++ b/ulib_math.cpp
@@ -585,8 +585,8 @@ CK_DLL_SFUN( phase_impl )
 CK_DLL_SFUN( rtop_impl )
 {
     // get array
-    Chuck_Array16 * from = (Chuck_Array16 *)GET_NEXT_OBJECT(ARGS);
-    Chuck_Array16 * to = (Chuck_Array16 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayC * from = (Chuck_ArrayC *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayC * to = (Chuck_ArrayC *)GET_NEXT_OBJECT(ARGS);
 
     // make sure not null
     if( !from || !to )
@@ -624,8 +624,8 @@ CK_DLL_SFUN( rtop_impl )
 CK_DLL_SFUN( ptor_impl )
 {
     // get array
-    Chuck_Array16 * from = (Chuck_Array16 *)GET_NEXT_OBJECT(ARGS);
-    Chuck_Array16 * to = (Chuck_Array16 *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayC * from = (Chuck_ArrayC *)GET_NEXT_OBJECT(ARGS);
+    Chuck_ArrayC * to = (Chuck_ArrayC *)GET_NEXT_OBJECT(ARGS);
 
     // make sure not null
     if( !from || !to )
