commit 4b860361cdd7adcf5af26b87489ea2ef6d4c4164
Author: leszek <leszek@koltunski.pl>
Date:   Mon Dec 1 15:14:31 2025 +0100

    Completely remove any mention of java.util

diff --git a/src/main/java/org/distorted/library/type/Dynamic.kt b/src/main/java/org/distorted/library/type/Dynamic.kt
index f92af8e..42f93cc 100644
--- a/src/main/java/org/distorted/library/type/Dynamic.kt
+++ b/src/main/java/org/distorted/library/type/Dynamic.kt
@@ -22,7 +22,6 @@ package org.distorted.library.type
 
 import org.distorted.library.main.DistortedLibrary
 import kotlin.random.Random
-import java.util.Vector
 import kotlin.math.sqrt
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -172,7 +171,7 @@ abstract class Dynamic
         }
     }
 
-    protected var vn: Vector<VectorNoise>? = null
+    protected var vn: MutableList<VectorNoise>? = null
     protected lateinit var mFactor: FloatArray
     protected lateinit var mNoise: FloatArray
     protected lateinit var baseV: Array<FloatArray>
@@ -194,7 +193,7 @@ abstract class Dynamic
         var path_ratio: FloatArray = FloatArray(NUM_RATIO)
     }
 
-    protected var vc: Vector<VectorCache>? = null
+    protected var vc: MutableList<VectorCache>? = null
     protected var mConvexity: Float = 0f
 
     private lateinit var buf: FloatArray
@@ -209,7 +208,7 @@ abstract class Dynamic
     ///////////////////////////////////////////////////////////////////////////////////////////////
     protected constructor(duration: Int, count: Float, dimension: Int)
     {
-        vc = Vector()
+        vc = mutableListOf()
         vn = null
         numPoints = 0
         cacheDirty = false
@@ -713,6 +712,7 @@ abstract class Dynamic
     * @param mode [Dynamic.SPEED_MODE_SMOOTH] or [Dynamic.SPEED_MODE_SEGMENT_CONSTANT] or
     * [Dynamic.SPEED_MODE_GLOBALLY_CONSTANT]
     */
+    @Synchronized
     fun setSpeedMode(mode: Int)
     {
         if (mSpeedMode!=mode)
diff --git a/src/main/java/org/distorted/library/type/Dynamic1D.kt b/src/main/java/org/distorted/library/type/Dynamic1D.kt
index 7466e68..43f96b6 100644
--- a/src/main/java/org/distorted/library/type/Dynamic1D.kt
+++ b/src/main/java/org/distorted/library/type/Dynamic1D.kt
@@ -20,7 +20,6 @@
 
 package org.distorted.library.type
 
-import java.util.Vector
 import kotlin.math.sqrt
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -29,7 +28,7 @@ import kotlin.math.sqrt
 */
 class Dynamic1D : Dynamic, Data1D
 {
-    private val vv: Vector<Static1D>
+    private val vv: MutableList<Static1D>
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // no array bounds checking!
@@ -126,7 +125,7 @@ class Dynamic1D : Dynamic, Data1D
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////
-    constructor() : super(0,0.5f,1) { vv = Vector() }
+    constructor() : super(0,0.5f,1) { vv = mutableListOf() }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     /** Constructor setting the speed of interpolation and the number of revolutions.
@@ -137,7 +136,7 @@ class Dynamic1D : Dynamic, Data1D
     * @param duration number of milliseconds it takes to do one revolution.
     * @param count number of revolutions we will do. Count<=0 means 'infinite'.
     */
-    constructor(duration: Int, count: Float) : super(duration,count,1) { vv = Vector() }
+    constructor(duration: Int, count: Float) : super(duration,count,1) { vv = mutableListOf() }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     /** Returns the Static1D at index.
@@ -161,12 +160,8 @@ class Dynamic1D : Dynamic, Data1D
         if (index in 0..<numPoints)
         {
             val curr = vv.elementAt(index)
-
-            if (curr!=null)
-            {
-                curr.set0(x)
-                cacheDirty = true
-            }
+            curr.set0(x)
+            cacheDirty = true
         }
     }
 
@@ -267,7 +262,7 @@ class Dynamic1D : Dynamic, Data1D
             when (numPoints)
             {
                 0, 1, 2 -> {}
-                3       -> vc!!.removeAllElements()
+                3       -> vc!!.clear()
                 else    ->
                     {
                         vc!!.removeAt(n)
@@ -294,14 +289,14 @@ class Dynamic1D : Dynamic, Data1D
     {
         if (index in 0..<numPoints)
         {
-            vv.removeElementAt(index)
+            vv.removeAt(index)
             vn?.removeAt(0)
 
             when (numPoints)
             {
                 0, 1, 2 -> {}
-                3       -> vc!!.removeAllElements()
-                else    -> vc!!.removeElementAt(index)
+                3       -> vc!!.clear()
+                else    -> vc!!.removeAt(index)
             }
 
             numPoints--
@@ -319,10 +314,10 @@ class Dynamic1D : Dynamic, Data1D
     fun removeAll()
     {
         numPoints = 0
-        vv.removeAllElements()
-        vc!!.removeAllElements()
+        vv.clear()
+        vc!!.clear()
         cacheDirty = false
-        vn?.removeAllElements()
+        vn?.clear()
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -339,8 +334,8 @@ class Dynamic1D : Dynamic, Data1D
     {
         if (vn==null)
         {
-            vn = Vector()
-            for (i in 0..<numPoints) vn!!.add(VectorNoise())
+            vn = mutableListOf()
+            repeat (numPoints) { vn!!.add(VectorNoise()) }
             if (dimension>=2) mFactor = FloatArray(dimension-1)
             mNoise = FloatArray(dimension)
         }
diff --git a/src/main/java/org/distorted/library/type/Dynamic2D.kt b/src/main/java/org/distorted/library/type/Dynamic2D.kt
index cbc244a..c4728d1 100644
--- a/src/main/java/org/distorted/library/type/Dynamic2D.kt
+++ b/src/main/java/org/distorted/library/type/Dynamic2D.kt
@@ -20,7 +20,6 @@
 
 package org.distorted.library.type
 
-import java.util.Vector
 import kotlin.math.sqrt
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -28,7 +27,7 @@ import kotlin.math.sqrt
 */
 class Dynamic2D : Dynamic, Data2D
 {
-    private val vv: Vector<Static2D>
+    private val vv: MutableList<Static2D>
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // no array bounds checking!
@@ -158,7 +157,7 @@ class Dynamic2D : Dynamic, Data2D
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////
-    constructor() : super(0, 0.5f, 2) { vv = Vector() }
+    constructor() : super(0, 0.5f, 2) { vv = mutableListOf() }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     /** Constructor setting the speed of interpolation and the number of revolutions.
@@ -169,7 +168,7 @@ class Dynamic2D : Dynamic, Data2D
     * @param duration number of milliseconds it takes to do one revolution.
     * @param count number of revolutions we will do. Count<=0 means 'infinite'.
     */
-    constructor(duration: Int, count: Float) : super(duration, count, 2) { vv = Vector() }
+    constructor(duration: Int, count: Float) : super(duration, count, 2) { vv = mutableListOf() }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     /** Returns the index'th Static2D.
@@ -196,12 +195,8 @@ class Dynamic2D : Dynamic, Data2D
         if (index in 0..<numPoints)
         {
             val curr = vv.elementAt(index)
-
-            if (curr!=null)
-            {
-                curr.set(x,y)
-                cacheDirty = true
-            }
+            curr.set(x,y)
+            cacheDirty = true
         }
     }
 
@@ -294,7 +289,7 @@ class Dynamic2D : Dynamic, Data2D
             when (numPoints)
             {
                 0, 1, 2 -> {}
-                3       -> vc!!.removeAllElements()
+                3       -> vc!!.clear()
                 else    -> vc!!.removeAt(n)
             }
 
@@ -319,14 +314,14 @@ class Dynamic2D : Dynamic, Data2D
     {
         if (index in 0..<numPoints)
         {
-            vv.removeElementAt(index)
+            vv.removeAt(index)
             vn?.removeAt(0)
 
             when (numPoints)
             {
                 0, 1, 2 -> {}
-                3       -> vc!!.removeAllElements()
-                else    -> vc!!.removeElementAt(index)
+                3       -> vc!!.clear()
+                else    -> vc!!.removeAt(index)
             }
 
             numPoints--
@@ -344,10 +339,10 @@ class Dynamic2D : Dynamic, Data2D
     fun removeAll()
     {
         numPoints = 0
-        vv.removeAllElements()
-        vc!!.removeAllElements()
+        vv.clear()
+        vc!!.clear()
         cacheDirty = false
-        vn?.removeAllElements()
+        vn?.clear()
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -364,8 +359,8 @@ class Dynamic2D : Dynamic, Data2D
     {
         if (vn==null)
         {
-            vn = Vector()
-            for (i in 0..<numPoints) vn!!.add(VectorNoise())
+            vn = mutableListOf()
+            repeat (numPoints) { vn!!.add(VectorNoise()) }
             if (dimension >= 2) mFactor = FloatArray(dimension-1)
             mNoise = FloatArray(dimension)
         }
diff --git a/src/main/java/org/distorted/library/type/Dynamic3D.kt b/src/main/java/org/distorted/library/type/Dynamic3D.kt
index a3d2b41..56aada5 100644
--- a/src/main/java/org/distorted/library/type/Dynamic3D.kt
+++ b/src/main/java/org/distorted/library/type/Dynamic3D.kt
@@ -20,7 +20,6 @@
 
 package org.distorted.library.type
 
-import java.util.Vector
 import kotlin.math.sqrt
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -28,7 +27,7 @@ import kotlin.math.sqrt
 */
 class Dynamic3D : Dynamic, Data3D
 {
-    private val vv: Vector<Static3D>
+    private val vv: MutableList<Static3D>
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // no array bounds checking!
@@ -181,7 +180,7 @@ class Dynamic3D : Dynamic, Data3D
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////
-    constructor() : super(0, 0.5f, 3) { vv = Vector() }
+    constructor() : super(0, 0.5f, 3) { vv = mutableListOf() }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     /** Constructor setting the speed of interpolation and the number of revolutions.
@@ -192,7 +191,7 @@ class Dynamic3D : Dynamic, Data3D
     * @param duration number of milliseconds it takes to do one revolution.
     * @param count number of revolutions we will do. Count<=0 means 'infinite'.
     */
-    constructor(duration: Int, count: Float) : super(duration, count, 3) { vv = Vector() }
+    constructor(duration: Int, count: Float) : super(duration, count, 3) { vv = mutableListOf() }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     /** Returns the index'th Static3D.
@@ -218,12 +217,8 @@ class Dynamic3D : Dynamic, Data3D
         if (index in 0..<numPoints)
         {
             val curr = vv.elementAt(index)
-
-            if (curr != null)
-            {
-                curr.set(x,y,z)
-                cacheDirty = true
-            }
+            curr.set(x,y,z)
+            cacheDirty = true
         }
     }
 
@@ -317,7 +312,7 @@ class Dynamic3D : Dynamic, Data3D
             {
                 0, 1, 2 -> {}
                 3 -> {
-                        vc!!.removeAllElements()
+                        vc!!.clear()
                         computeOrthonormalBase2(vv.elementAt(0), vv.elementAt(1))
                      }
 
@@ -345,18 +340,18 @@ class Dynamic3D : Dynamic, Data3D
     {
         if (index in 0..<numPoints)
         {
-            vv.removeElementAt(index)
+            vv.removeAt(index)
             vn?.removeAt(0)
 
             when (numPoints)
             {
                 0, 1, 2 -> {}
                 3 -> {
-                        vc!!.removeAllElements()
+                        vc!!.clear()
                         computeOrthonormalBase2(vv.elementAt(0), vv.elementAt(1))
                      }
 
-                else -> vc!!.removeElementAt(index)
+                else -> vc!!.removeAt(index)
             }
 
             numPoints--
@@ -374,10 +369,10 @@ class Dynamic3D : Dynamic, Data3D
     fun removeAll()
     {
         numPoints = 0
-        vv.removeAllElements()
-        vc!!.removeAllElements()
+        vv.clear()
+        vc!!.clear()
         cacheDirty = false
-        vn?.removeAllElements()
+        vn?.clear()
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -394,8 +389,8 @@ class Dynamic3D : Dynamic, Data3D
     {
         if (vn == null)
         {
-            vn = Vector()
-            for (i in 0..<numPoints) vn!!.add(VectorNoise())
+            vn = mutableListOf()
+            repeat (numPoints) { vn!!.add(VectorNoise()) }
             if (dimension>=2) mFactor = FloatArray(dimension-1)
             mNoise = FloatArray(dimension)
         }
diff --git a/src/main/java/org/distorted/library/type/Dynamic4D.kt b/src/main/java/org/distorted/library/type/Dynamic4D.kt
index e472354..1be0d9a 100644
--- a/src/main/java/org/distorted/library/type/Dynamic4D.kt
+++ b/src/main/java/org/distorted/library/type/Dynamic4D.kt
@@ -20,7 +20,6 @@
 
 package org.distorted.library.type
 
-import java.util.Vector
 import kotlin.math.sqrt
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -28,7 +27,7 @@ import kotlin.math.sqrt
 */
 class Dynamic4D : Dynamic, Data4D
 {
-    private val vv: Vector<Static4D>
+    private val vv: MutableList<Static4D>
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // no array bounds checking!
@@ -204,7 +203,7 @@ class Dynamic4D : Dynamic, Data4D
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////
-    constructor() : super(0, 0.5f, 4) { vv = Vector() }
+    constructor() : super(0, 0.5f, 4) { vv = mutableListOf() }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     /** Constructor setting the speed of interpolation and the number of revolutions.
@@ -215,7 +214,7 @@ class Dynamic4D : Dynamic, Data4D
     * @param duration number of milliseconds it takes to do one revolution.
     * @param count number of revolutions we will do. Count<=0 means 'infinite'.
     */
-    constructor(duration: Int, count: Float) : super(duration,count,4) { vv = Vector() }
+    constructor(duration: Int, count: Float) : super(duration,count,4) { vv = mutableListOf() }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     /** Returns the index'th Static4D.
@@ -241,12 +240,8 @@ class Dynamic4D : Dynamic, Data4D
         if (index in 0..<numPoints)
         {
             val curr = vv.elementAt(index)
-
-            if (curr!=null)
-            {
-                curr.set(x,y,z,w)
-                cacheDirty = true
-            }
+            curr.set(x,y,z,w)
+            cacheDirty = true
         }
     }
 
@@ -338,7 +333,7 @@ class Dynamic4D : Dynamic, Data4D
             {
                 0, 1, 2 -> {}
                 3 -> {
-                        vc!!.removeAllElements()
+                        vc!!.clear()
                         computeOrthonormalBase2(vv.elementAt(0), vv.elementAt(1))
                      }
                 else -> vc!!.removeAt(n)
@@ -365,18 +360,18 @@ class Dynamic4D : Dynamic, Data4D
     {
         if (index in 0..<numPoints)
         {
-            vv.removeElementAt(index)
+            vv.removeAt(index)
             vn?.removeAt(0)
 
             when (numPoints)
             {
                 0, 1, 2 -> {}
                 3 -> {
-                        vc!!.removeAllElements()
+                        vc!!.clear()
                         computeOrthonormalBase2(vv.elementAt(0), vv.elementAt(1))
                      }
 
-                else -> vc!!.removeElementAt(index)
+                else -> vc!!.removeAt(index)
             }
 
             numPoints--
@@ -394,10 +389,10 @@ class Dynamic4D : Dynamic, Data4D
     fun removeAll()
     {
         numPoints = 0
-        vv.removeAllElements()
-        vc!!.removeAllElements()
+        vv.clear()
+        vc!!.clear()
         cacheDirty = false
-        vn?.removeAllElements()
+        vn?.clear()
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -414,8 +409,8 @@ class Dynamic4D : Dynamic, Data4D
     {
         if (vn==null)
         {
-            vn = Vector()
-            for (i in 0..<numPoints) vn!!.add(VectorNoise())
+            vn = mutableListOf()
+            repeat (numPoints) { vn!!.add(VectorNoise()) }
             if (dimension >= 2) mFactor = FloatArray(dimension-1)
             mNoise = FloatArray(dimension)
         }
diff --git a/src/main/java/org/distorted/library/type/Dynamic5D.kt b/src/main/java/org/distorted/library/type/Dynamic5D.kt
index b8dbd34..257e0f9 100644
--- a/src/main/java/org/distorted/library/type/Dynamic5D.kt
+++ b/src/main/java/org/distorted/library/type/Dynamic5D.kt
@@ -20,7 +20,6 @@
 
 package org.distorted.library.type
 
-import java.util.Vector
 import kotlin.math.sqrt
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -28,7 +27,7 @@ import kotlin.math.sqrt
 */
 class Dynamic5D : Dynamic, Data5D
 {
-    private val vv: Vector<Static5D>
+    private val vv: MutableList<Static5D>
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // no array bounds checking!
@@ -227,7 +226,7 @@ class Dynamic5D : Dynamic, Data5D
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC API
     ///////////////////////////////////////////////////////////////////////////////////////////////
-    constructor() : super(0, 0.5f, 5) { vv = Vector() }
+    constructor() : super(0, 0.5f, 5) { vv = mutableListOf() }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     /** Constructor setting the speed of interpolation and the number of revolutions.
@@ -238,7 +237,7 @@ class Dynamic5D : Dynamic, Data5D
     * @param duration number of milliseconds it takes to do one revolution.
     * @param count number of revolutions we will do. Count<=0 means 'infinite'.
     */
-    constructor(duration: Int, count: Float) : super(duration, count, 5) { vv = Vector() }
+    constructor(duration: Int, count: Float) : super(duration, count, 5) { vv = mutableListOf() }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     /** Returns the index'th Static5D.
@@ -264,12 +263,8 @@ class Dynamic5D : Dynamic, Data5D
         if (index in 0..<numPoints)
         {
             val curr = vv.elementAt(index)
-
-            if (curr!=null)
-            {
-                curr.set(x,y,z,w,v)
-                cacheDirty = true
-            }
+            curr.set(x,y,z,w,v)
+            cacheDirty = true
         }
     }
 
@@ -361,7 +356,7 @@ class Dynamic5D : Dynamic, Data5D
             {
                 0, 1, 2 -> {}
                 3 -> {
-                        vc!!.removeAllElements()
+                        vc!!.clear()
                         computeOrthonormalBase2(vv.elementAt(0), vv.elementAt(1))
                      }
                 else -> vc!!.removeAt(n)
@@ -388,17 +383,17 @@ class Dynamic5D : Dynamic, Data5D
     {
         if (index in 0..<numPoints)
         {
-            vv.removeElementAt(index)
+            vv.removeAt(index)
             vn?.removeAt(0)
 
             when (numPoints)
             {
                 0, 1, 2 -> {}
                 3 -> {
-                        vc!!.removeAllElements()
+                        vc!!.clear()
                         computeOrthonormalBase2(vv.elementAt(0), vv.elementAt(1))
                     }
-                else -> vc!!.removeElementAt(index)
+                else -> vc!!.removeAt(index)
             }
 
             numPoints--
@@ -416,10 +411,10 @@ class Dynamic5D : Dynamic, Data5D
     fun removeAll()
     {
         numPoints = 0
-        vv.removeAllElements()
-        vc!!.removeAllElements()
+        vv.clear()
+        vc!!.clear()
         cacheDirty = false
-        vn?.removeAllElements()
+        vn?.clear()
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -436,8 +431,8 @@ class Dynamic5D : Dynamic, Data5D
     {
         if (vn == null)
         {
-            vn = Vector()
-            for (i in 0..<numPoints) vn!!.add(VectorNoise())
+            vn = mutableListOf()
+            repeat (numPoints) { vn!!.add(VectorNoise()) }
             if (dimension>=2) mFactor = FloatArray(dimension-1)
             mNoise = FloatArray(dimension)
         }
diff --git a/src/main/java/org/distorted/library/type/DynamicQuat.kt b/src/main/java/org/distorted/library/type/DynamicQuat.kt
index dc76eba..b76ea25 100644
--- a/src/main/java/org/distorted/library/type/DynamicQuat.kt
+++ b/src/main/java/org/distorted/library/type/DynamicQuat.kt
@@ -20,7 +20,6 @@
 
 package org.distorted.library.type
 
-import java.util.Vector
 import kotlin.math.sin
 import kotlin.math.sqrt
 
@@ -42,7 +41,7 @@ class DynamicQuat : Dynamic, Data4D
     //  
     // (vx,vy,vz,vw) is the original vector from vv (copied here so when interpolating we can see if it is 
     // still valid and if not - rebuild the Cache.
-    private inner class VectorCacheQuat 
+    private class VectorCacheQuat
     {
         var omega: Float = 0f
         var sinOmega: Float = 0f
@@ -53,8 +52,8 @@ class DynamicQuat : Dynamic, Data4D
         var vw: Float = 0f
     }
 
-    private var cc: Vector<VectorCacheQuat> = Vector<VectorCacheQuat>()
-    private val vv = Vector<Static4D>()
+    private var cc: MutableList<VectorCacheQuat> = mutableListOf()
+    private val vv: MutableList<Static4D> = mutableListOf()
 
     companion object 
     {
@@ -154,12 +153,8 @@ class DynamicQuat : Dynamic, Data4D
         if (index in 0..<numPoints) 
         {
             val curr = vv.elementAt(index)
-
-            if (curr!=null) 
-            {
-                curr.set(x,y,z,w)
-                cacheDirty = true
-            }
+            curr.set(x,y,z,w)
+            cacheDirty = true
         }
     }
 
@@ -216,7 +211,7 @@ class DynamicQuat : Dynamic, Data4D
                         cc.add(VectorCacheQuat())
                         cc.add(VectorCacheQuat())
                     }
-                else -> cc.add(index,VectorCacheQuat())
+                else -> cc.add(index, VectorCacheQuat())
             }
 
             numPoints++
@@ -243,7 +238,7 @@ class DynamicQuat : Dynamic, Data4D
             when (numPoints) 
             {
                 0, 1 -> {}
-                2    -> cc.removeAllElements()
+                2    -> cc.clear()
                 else -> cc.removeAt(n)
             }
 
@@ -268,13 +263,13 @@ class DynamicQuat : Dynamic, Data4D
     {
         if (index in 0..<numPoints) 
         {
-            vv.removeElementAt(index)
+            vv.removeAt(index)
 
             when (numPoints) 
             {
                 0, 1 -> {}
-                2    -> cc.removeAllElements()
-                else -> cc.removeElementAt(index)
+                2    -> cc.clear()
+                else -> cc.removeAt(index)
             }
 
             numPoints--
@@ -292,8 +287,8 @@ class DynamicQuat : Dynamic, Data4D
     fun removeAll() 
     {
         numPoints = 0
-        vv.removeAllElements()
-        cc.removeAllElements()
+        vv.clear()
+        cc.clear()
         cacheDirty = false
     }