diff --git a/Assets/NanoBrain/LinearAlgebra/src/Direction.cs b/Assets/NanoBrain/LinearAlgebra/src/Direction.cs
index 7047da6..a1ff8f3 100644
--- a/Assets/NanoBrain/LinearAlgebra/src/Direction.cs
+++ b/Assets/NanoBrain/LinearAlgebra/src/Direction.cs
@@ -127,9 +127,11 @@ namespace LinearAlgebra
 
             // Calculate Vector
             float cosV = MathF.Cos(radV);
-            float x = cosV * MathF.Cos(radH);
-            float y = MathF.Sin(radV);
-            float z = cosV * MathF.Sin(radH);
+            float sinV = MathF.Sin(radV);
+
+            float x = cosV * MathF.Sin(radH);
+            float y = sinV;
+            float z = cosV * MathF.Cos(radH);
 
             return new UnityEngine.Vector3(x, y, z);
         }
diff --git a/Assets/NanoBrain/LinearAlgebra/src/Spherical.cs b/Assets/NanoBrain/LinearAlgebra/src/Spherical.cs
index 0b7c8b4..996232c 100644
--- a/Assets/NanoBrain/LinearAlgebra/src/Spherical.cs
+++ b/Assets/NanoBrain/LinearAlgebra/src/Spherical.cs
@@ -62,13 +62,15 @@ namespace LinearAlgebra {
 #if UNITY_5_3_OR_NEWER
         public static Spherical FromVector3(Vector3 v) {
             float distance = v.magnitude;
-            if (distance == 0.0f)
-                return Spherical.zero;
-            else {
-                float verticalAngle = (float)(Math.PI / 2 - Math.Acos(v.y / distance)) * AngleFloat.Rad2Deg;
-                float horizontalAngle = (float)Math.Atan2(v.x, v.z) * AngleFloat.Rad2Deg;
-                return Degrees(distance, horizontalAngle, verticalAngle);
-            }
+            // if (distance == 0.0f)
+            //     return Spherical.zero;
+            // else {
+            //     float verticalAngle = (float)(Math.PI / 2 - Math.Acos(v.y / distance)) * AngleFloat.Rad2Deg;
+            //     float horizontalAngle = (float)Math.Atan2(v.x, v.z) * AngleFloat.Rad2Deg;
+            //     return Degrees(distance, horizontalAngle, verticalAngle);
+            // }
+            Direction direction = Direction.FromVector3(v.normalized);
+            return new Spherical(distance, direction);
         }
 
         public readonly Vector3 ToVector3() {
diff --git a/Assets/NanoBrain/Neuroid.cs b/Assets/NanoBrain/Neuroid.cs
index e0ba72f..71e48e7 100644
--- a/Assets/NanoBrain/Neuroid.cs
+++ b/Assets/NanoBrain/Neuroid.cs
@@ -75,7 +75,26 @@ public class Neuroid : Nucleus {
     }
 
     public override void UpdateState() {
-        Vector3 resultVector = Vector3.zero;
+        // Vector3 resultVector = Vector3.zero;
+        // foreach (Synapse synapse in this.synapses) {
+        //     Nucleus synapseNucleus = synapse.nucleus;
+        //     if (synapseNucleus is Neuroid neuroid && neuroid.isSleeping)
+        //         continue;
+
+        //     Vector3 direction = synapseNucleus.outputValue.direction.ToVector3();
+
+        //     float weight = synapse.weight;
+        //     float activatedValue = curve.Evaluate(synapseNucleus.outputValue.magnitude);
+        //     float magnitude = weight * activatedValue;
+        //     //Debug.Log($"{this.name} {synapseNucleus.outputValue.direction} {synapseNucleus.outputValue.direction.horizontal}{synapseNucleus.outputValue.direction.vertical} {direction}");
+        //     Vector3 a = direction * magnitude;
+        //     //Debug.Log($"A {direction} {magnitude} {a}");
+        //     resultVector += a;
+        // }
+        // if (average && this.synapses.Count > 0)
+        //     resultVector /= this.synapses.Count;
+        /*
+        List<Vector3> v3s = new();
         foreach (Synapse synapse in this.synapses) {
             Nucleus synapseNucleus = synapse.nucleus;
             if (synapseNucleus is Neuroid neuroid && neuroid.isSleeping)
@@ -89,34 +108,55 @@ public class Neuroid : Nucleus {
             //Debug.Log($"{this.name} {synapseNucleus.outputValue.direction} {synapseNucleus.outputValue.direction.horizontal}{synapseNucleus.outputValue.direction.vertical} {direction}");
             Vector3 a = direction * magnitude;
             //Debug.Log($"A {direction} {magnitude} {a}");
-            resultVector += a;
+            v3s.Add(a);
         }
-        if (average && this.synapses.Count > 0)
-            resultVector /= this.synapses.Count;
+        Vector3 sum = Vector3.zero; // Start with a zero vector
 
-        Spherical result = Spherical.FromVector3(resultVector);
+        // Sum all vectors
+        foreach (Vector3 vector in v3s)
+            sum += vector;        
 
-        List<Spherical> vectors = new();
+        // Calculate average
+        Vector3 averagevs = sum / v3s.Count;
+        Vector3 result1 = averagevs * v3s.Count;
+        // if (average && this.synapses.Count > 0)
+        //     resultVector /= this.synapses.Count;
+
+        Spherical result = Spherical.FromVector3(result1);
+        */
+        List<Spherical> sVectors = new();
+        List<Vector3> cVectors = new();
         foreach (Synapse synapse in this.synapses) {
             if (synapse.nucleus.isSleeping)
                 continue;
-            
+
             float weight = synapse.weight;
             float activatedValue = curve.Evaluate(synapse.nucleus.outputValue.magnitude);
             float magnitude = weight * activatedValue;
-            Spherical vector = new(magnitude, synapse.nucleus.outputValue.direction);
+            Spherical sVector = new(magnitude, synapse.nucleus.outputValue.direction);
             //Debug.Log($"B {synapse.nucleus.outputValue.direction.ToVector3()} {magnitude} {vector.ToVector3()}");
-            vectors.Add(vector); //synapse.nucleus.outputValue);
+            sVectors.Add(sVector); //synapse.nucleus.outputValue);
+
+            Vector3 direction = synapse.nucleus.outputValue.direction.ToVector3();
+            Vector3 cVector = direction * magnitude;
+            cVectors.Add(cVector);
         }
-        Spherical result2 = Spherical.Average(vectors);
+        Vector3 cResult = Vector3.zero;
+        foreach (Vector3 vector in cVectors)
+            cResult += vector;
+
+        Spherical sResult = Spherical.Average(sVectors);
         if (average == false)
-            result2 *= vectors.Count;
+            sResult *= sVectors.Count;
 
-        if (result2 != result)
-            Debug.Log($"update error {result2} != {result}");
+        if (sResult != Spherical.FromVector3(cResult))
+            Debug.Log($"spherical different {sResult} != {Spherical.FromVector3(cResult)}");
+        //if (sResult.ToVector3() != cResult)
+            Debug.Log($"vector different {sResult.ToVector3()} != {cResult}");
+
+
+        UpdateResult(Spherical.FromVector3(cResult));
 
-        UpdateResult(result);
-  
     }
 
 }