element multiply

Author: RCmags

examples/quaternion/quaternion.ino

@@ -83,61 +83,70 @@ void setup() {
   q5 /= 2;
   printOperation( "9. Scalar self divide: ", q5 );
 
+  // Element-wise multiplication
+  quat_t q6 = q5 ^ q4;
+  printOperation( "10A. Element-wise multiply", q6 );
+
+  // self element-wise multiply
+  q6 ^= q5;
+  printOperation( "10B. Self Element-wise multiply", q6 ); 
+
+
   // 2. Quaternion multiplication and division:
   /* Quats can be multiplied together to generate a new quaternion. This can encode multiple rotations */
 
     // Multiply
   q5 = q5*q1;
-  printOperation( "10. Quaternion multiply: ", q5 );
+  printOperation( "11. Quaternion multiply: ", q5 );
 
     // Divide
   q5 = q5/q2;
-  printOperation( "11. Quaternion division: ", q5 );
+  printOperation( "12. Quaternion division: ", q5 );
 
     // Self multiply
   q5 *= q3;
-  printOperation( "12. Quaternion self multiply: ", q5 );
+  printOperation( "13. Quaternion self multiply: ", q5 );
 
     // Self divide
   q5 /= q4;  
-  printOperation( "13. Quaternion self divide: ", q5 );
+  printOperation( "14. Quaternion self divide: ", q5 );
 
   // 3. Important operations:
 
     // Conjugate
-  printOperation( "14. Conjugate: ", q5.conj() );  
+  printOperation( "15. Conjugate: ", q5.conj() );  
 
     // Normalize
-  printOperation( "15. Normalize: ", q5.norm() );
+  printOperation( "16. Normalize: ", q5.norm() );
 
     // Inner product
-  Serial.print( "16. Inner product: " );
+  Serial.print( "17. Inner product: " );
   Serial.println( q5.inner() );
 
     // Magnitude
-  Serial.print( "17. Magnitude: " );
+  Serial.print( "18. Magnitude: " );
   Serial.print( q5.mag() );
   Serial.print("\n\n");
 
   // 4. Compatibility with arrays:
   /* In operations between a quaternion and an array, the array will be interpreted as a quaternion */
   float arr[] = {1, 2, 3, 4};
 
-  printOperation( "18. Quaternion and array addition: "   , q5 + arr );
-  printOperation( "19. Quaternion and array subtraction: ", q5 - arr );
-  printOperation( "20. Quaternion and array multiply: "   , q5 * arr );
+  printOperation( "19. Quaternion and array addition: "   , q5 + arr );
+  printOperation( "20. Quaternion and array subtraction: ", q5 - arr );
+  printOperation( "21. Quaternion and array multiply: "   , q5 * arr );
 
   // Operations with arrays are not converted to a quaternion type. These need to be explicitly converted.
-  printOperation( "21. Array conversion (multiply): ", quat_t(arr)*3 );
-  printOperation( "22. Array conversion (divide): "  , quat_t(arr)/10 );
+  printOperation( "22. Array conversion (multiply): ", quat_t(arr)*3 );
+  printOperation( "23. Array conversion (divide): "  , quat_t(arr)/10 );
 
   //-- Compatibility with vectors
   /* Vectors will be interpreted as quaternions without a scalar value (w = 0) */
   vec3_t vec = {1, 2, 3};
 
-  printOperation( "23. Quaternion and vector addition: "   , q5 + vec );
-  printOperation( "24. Quaternion and vector subtraction: ", q5 - vec );
-  printOperation( "25. Quaternion and vector multiply; "   , q5 * vec );
+  printOperation( "24. Quaternion and vector addition: "   , q5 + vec );
+  printOperation( "25. Quaternion and vector subtraction: ", q5 - vec );
+  printOperation( "26. Quaternion and vector multiply; "   , q5 * vec );
 
   // 5. Vector rotation: a quaternion can rotate and stretch a 3D vector
 
@@ -154,18 +163,18 @@ void setup() {
       // Rotate into angle
   vec_rot = qrot.rotate(vec, GLOBAL_FRAME);            
 
-  printOperation<vec3_t>( "26. Rotate by axis and angle (Global): ", vec_rot );
+  printOperation<vec3_t>( "27. Rotate by axis and angle (Global): ", vec_rot );
 
       // Rotate away from angle
   vec_rot = qrot.rotate(vec, LOCAL_FRAME);   
 
-  printOperation<vec3_t>( "27. Rotate by axis and angle (local): ", vec_rot );
+  printOperation<vec3_t>( "28. Rotate by axis and angle (local): ", vec_rot );
 
   // B) Rotate by unit vector of magnitude sin(angle)
   qrot.setRotation( axis, LARGE_ANGLE );     
   vec_rot = qrot.rotate(vec, GLOBAL_FRAME);
 
-  printOperation<vec3_t>( "28. Rotate by unit vector: ", vec_rot );
+  printOperation<vec3_t>( "29. Rotate by unit vector: ", vec_rot );
 
   // 6. Axes projections: can choose between GLOBAL_FRAME and LOCAL_FRAME
   /* GLOBAL_FRAME projects local axis-vectors to global coordinates 
@@ -176,9 +185,9 @@ void setup() {
   vec3_t y = qrot.axisY(GLOBAL_FRAME);
   vec3_t z = qrot.axisZ(GLOBAL_FRAME);
 
-  printOperation<vec3_t>( "29. X-axis vector: ", x );    
-  printOperation<vec3_t>( "30. Y-axis vector: ", y );
-  printOperation<vec3_t>( "31. Z-axis vector: ", z );
+  printOperation<vec3_t>( "30. X-axis vector: ", x );    
+  printOperation<vec3_t>( "31. Y-axis vector: ", y );
+  printOperation<vec3_t>( "32. Z-axis vector: ", z );
 }
 
 void loop() {}

examples/vector/vector.ino

@@ -76,22 +76,30 @@ void setup() {
   v4 /= 20;
   printOperation( "9. Self divide: ", v4 );
 
+  // Element-wise multiplication
+  vec3_t v5 = v3 ^ v4;
+  printOperation( "10A. Element-wise multiply", v5 );
+
+    // self element-wise multiply
+  v5 ^= v4;
+  printOperation( "10B. Self Element-wise multiply", v5 ); 
+
   // 2. Important operations: 
   //  These are useful operations that are commonly encountered. They are explicitly named for clarity.
 
     // Normalize
-  printOperation( "10. Normalize vector: ", v4.norm() ); 
+  printOperation( "11. Normalize vector: ", v4.norm() ); 
 
     // Cross product
   v4 = v4.cross(v1);
-  printOperation( "11. Cross product: ", v4 );
+  printOperation( "12. Cross product: ", v4 );
 
     // Dot product
-  Serial.print( "11. Dot product: " );
+  Serial.print( "13. Dot product: " );
   Serial.println( v4.dot(v2) );
 
     // Magnitude
-  Serial.print( "12. Magnitude: " );
+  Serial.print( "14. Magnitude: " );
   Serial.print( v4.mag() );
   Serial.println("\n");
 
@@ -100,17 +108,17 @@ void setup() {
 
   float arr[] = {1, 2, 3};
 
-  printOperation( "13. Vector and array addition: "     , v4 + arr );
-  printOperation( "14. Vector and array subtraction: "  , v4 - arr );
-  printOperation( "15. Vector and array cross product: ", v4.cross(arr) );
+  printOperation( "15. Vector and array addition: "     , v4 + arr );
+  printOperation( "16. Vector and array subtraction: "  , v4 - arr );
+  printOperation( "17. Vector and array cross product: ", v4.cross(arr) );
 
-  Serial.print( "16. Dot product (array): " );
+  Serial.print( "18. Dot product (array): " );
   Serial.print( v4.dot(arr) );
   Serial.println("\n");
 
   // Operations with arrays are not converted to a vector type. These need to be explicitly converted.
-  printOperation( "17. Array conversion (multiply): ", vec3_t(arr)*3 );
-  printOperation( "18. Array conversion (divide): ", vec3_t(arr)/10 );
+  printOperation( "19. Array conversion (multiply): ", vec3_t(arr)*3 );
+  printOperation( "20. Array conversion (divide): ", vec3_t(arr)/10 );
 }
 
 void loop() {}

library.properties

@@ -1,5 +1,5 @@
 name=Vector datatype
-version=1.1.1
+version=1.2.1
 author=RCmags <memoryofatrufestival@gmail.com>
 maintainer=RCmags <memoryofatrufestival@gmail.com>
 sentence=Library for 3d vectors and quaternions

src/quaternion_type.cpp

@@ -65,6 +65,18 @@ void quat_t::operator -= ( const quat_t &r ) {
     v -= r.v;  
 }
 
+//-- Element-wise multiplication:
+quat_t quat_t::operator ^ ( const quat_t &r ) {
+	quat_t q = { w * r.w , 
+	             v ^ r.v }; 
+	return q;
+} 
+
+void quat_t::operator ^= ( const quat_t &r ) {
+	w *= r.w;
+	v ^= r.v;
+} 
+
 //-- Scalar product and division:
 
 // Scalar product

src/quaternion_type.h

@@ -31,7 +31,11 @@ struct quat_t {
     quat_t operator - ( const quat_t & );
     quat_t operator - ( void );
     void operator += ( const quat_t & );
-    void operator -= ( const quat_t & );
+    void operator -= ( const quat_t & );    
+
+		// Element-wise multiplication
+	quat_t operator ^ ( const quat_t & );
+	void operator ^= ( const quat_t & );
 
         // Scalar product and division:
     quat_t operator * ( const float );

src/vector_type.cpp

@@ -67,6 +67,21 @@ void vec3_t::operator -= ( const vec3_t &r ) {
     z -= r.z;
 } 
 
+
+//----------- Element-wise multiplication ------------
+vec3_t vec3_t::operator ^ ( const vec3_t &r ) {
+	vec3_t v = { x * r.x ,
+	             y * r.y ,
+	             z * r.z };
+	return v;
+}
+
+void vec3_t::operator ^= ( const vec3_t &r ) {
+	x *= r.x;
+	y *= r.y;
+	z *= r.z;
+}  
+
 //-------- Scalar multiplication and division --------
 
 // Scalar product

src/vector_type.h

@@ -25,6 +25,10 @@ struct vec3_t {
     void operator += ( const vec3_t & );
     void operator -= ( const vec3_t & );
 
+		// Element-wise multiplication
+	vec3_t operator ^ ( const vec3_t & );
+	void operator ^= ( const vec3_t & );
+    
     	// Scalar multiplication and division:
     vec3_t operator * ( const float );
     vec3_t operator / ( const float );