abstract field operations

README.md

@@ -22,7 +22,17 @@ My goal is to provide users with the feature of creating their own algebra field
 Suppose for example the set of strings with the concatenation operator,
 it could be extended to a group and maybe to a field and build "matrices of strings".
 
-# Testing
+# Development
+
+## Branches
+
+The git repository has the following remote branches:
+
+  * real
+  * complex
+  * quaternion
+
+## Testing
 
 Install mocha globally
 

index.js

@@ -1,12 +1,9 @@
 
 exports.Field              = require('./lib/Field.js');
-exports.FieldElement       = require('./lib/FieldElement.js');
 exports.Matrix             = require('./lib/Matrix.js');
 exports.SquareMatrix       = require('./lib/SquareMatrix.js');
 exports.GeneralLinearGroup = require('./lib/GeneralLinearGroup.js');
 exports.Group              = require('./lib/Group.js');
-exports.GroupElement       = require('./lib/GroupElement.js');
-exports.RingElement        = require('./lib/RingElement.js');
 exports.Vector             = require('./lib/Vector.js');
 exports.VectorSpace        = require('./lib/VectorSpace.js');
 

lib/Field.js

@@ -9,16 +9,32 @@ function Field(arg) {
 
 util.inherits(Field, Group);
 
+Field.prototype.inv = function(element) {
+  try {
+    var element = this.coerceToElement(element);
+    return element.clone().inv();
+  }
+  catch (err) {}
+}
+
 Field.prototype.mul = function(element1, element2) {
-  return element1.clone().mul(element2);
+  try {
+    var element1 = this.coerceToElement(element1);
+    return element1.clone().mul(element2);
+  }
+  catch (err) {}
 }
 
 Field.prototype.div = function(element1, element2) {
-  return element1.clone().div(element2);
+  try {
+    var element1 = this.coerceToElement(element1);
+    return element1.clone().div(element2);
+  }
+  catch (err) {}
 }
 
 Field.prototype.getOne = function() {
-// TODO throw Error
+// TODO throw Error (unimplemented abstract function
 }
 
 module.exports = Field;

lib/Group.js

@@ -3,24 +3,46 @@ function Group(arg) {
   var self = this;
 }
 
+Group.prototype.coerceToElement = function(element) {
+  // TODO deve essere tipo unimplemented abstract method
+  // fai una classe per tutti in modo tale da lanciare sempre lo stesso errore.
+  throw new Error();
+}
+
 Group.prototype.neg = function(element) {
-  return element.clone().neg();
+  try {
+    var element = this.coerceToElement(element);
+    return element.clone().neg();
+  }
+  catch (err) {}
 }
 
 Group.prototype.eq = function(element1, element2) {
-  return element1.eq(element2);
+  try {
+    var element1 = this.coerceToElement(element1);
+    return element1.eq(element2);
+  }
+  catch (err) {}
 }
 
 Group.prototype.add = function(element1, element2) {
-  return element1.clone().add(element2);
+  try {
+    var element1 = this.coerceToElement(element1);
+    return element1.clone().add(element2);
+  }
+  catch (err) {}
 }
 
 Group.prototype.sub = function(element1, element2) {
-  return element1.clone().sub(element2);
+  try {
+    var element1 = this.coerceToElement(element1);
+    return element1.clone().sub(element2);
+  }
+  catch (err) {}
 }
 
 Group.prototype.getZero = function() {
-// TODO throw Error unhimplemented abstract function
+// TODO throw Error unimplemented abstract function
 }
 
 module.exports = Group;

lib/Real/Element.js

@@ -17,12 +17,6 @@ var RealElement = function(arg) {
     }
   }
 
-  self.neg = function () {
-    _num = 0 - _num;
-
-    return self;
-  }
-
   self.eq = function (x) {
     var num = coerce(x);
 
@@ -34,6 +28,12 @@ var RealElement = function(arg) {
     }
   }
 
+  self.neg = function () {
+    _num = 0 - _num;
+
+    return self;
+  }
+
   self.add = function (x) {
     var num = coerce(x);
 
@@ -50,6 +50,12 @@ var RealElement = function(arg) {
     return self;
   }
 
+  self.inv = function () {
+    _num = 1 / _num;
+
+    return self;
+  }
+
   self.mul = function (x) {
     var num = coerce(x);
 
@@ -67,11 +73,9 @@ var RealElement = function(arg) {
   }
 }
 
-RealElement.prototype = {
-  clone: function () {
-    return new RealElement(this.num());
-  }
-};
+RealElement.prototype.clone = function () {
+  return new RealElement(this.num());
+}
 
 module.exports = RealElement;
 

lib/Real/Field.js

@@ -10,9 +10,21 @@ var RealField = function() {
 
 util.inherits(RealField, Field);
 
-RealField.prototype.getZero = function () { return new Real(0); };
+RealField.prototype.coerceToElement = function (arg) {
+// TODO sistema bene, mancano tutte le casistiche, i test ecc
+// poi considera che voglio fare i numei trascendenti, le radici dei polinomi, ecc
+// gli potrei passare dei numeri complessi, ecc
+  if( typeof arg == 'number' ) {
+    return new Real(arg);
+  }
+  else {
+    return arg;
+  }
+}
+
+RealField.prototype.getZero = function () { return new Real(0); }
 
-RealField.prototype.getOne = function () { return new Real(1); };
+RealField.prototype.getOne = function () { return new Real(1); }
 
 module.exports = RealField;