[98] PrimitiveType modification

Rename all use of PrimitiveType unicode '\u2115', '\u211D', '\u213E' by
int, real and bool.
Generated code and LaTeX view are unchanged.

Bug: cea-hpc#98
Signed-off-by: Vincent BLAIN <[email protected]>

plugins/fr.cea.nabla.ir/model/Ir.ecore

@@ -382,9 +382,9 @@
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="IrType" eSuperTypes="#//IrAnnotable"/>
   <eClassifiers xsi:type="ecore:EEnum" name="PrimitiveType">
-    <eLiterals name="Int" value="1" literal="ℕ"/>
-    <eLiterals name="Real" value="2" literal="ℝ"/>
-    <eLiterals name="Bool" value="3" literal="ℾ"/>
+    <eLiterals name="Int" value="1" literal="int"/>
+    <eLiterals name="Real" value="2" literal="real"/>
+    <eLiterals name="Bool" value="3" literal="bool"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="BaseType" eSuperTypes="#//IrType">
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="primitive" lowerBound="1"

plugins/fr.cea.nabla.ui/examples/NabLabExamples/src/explicitheatequation/ExplicitHeatEquation.n

@@ -13,19 +13,19 @@ with Math.*;
 with CartesianMesh2D.*;
 
 // Simulation options
-ℝ stopTime;
-ℕ maxIterations;
-
-let ℝ u0 = 1.0;
-let ℝ[2] vectOne = ℝ[2](1.0);
-let ℝ δt = 0.001;
-ℝ t;
-ℝ[2] X{nodes}, Xc{cells}; // Position of nodes and cells center of gravity 
-ℝ u{cells}; // Temperature
-ℝ V{cells}; // Volume of cells
-ℝ D{cells}; // Cell centered conductivity
-ℝ faceLength{faces}, faceConductivity{faces};
-ℝ α{cells, cells};
+real stopTime;
+int maxIterations;
+
+let real u0 = 1.0;
+let real[2] vectOne = real[2](1.0);
+let real δt = 0.001;
+real t;
+real[2] X{nodes}, Xc{cells}; // Position of nodes and cells center of gravity 
+real u{cells}; // Temperature
+real V{cells}; // Volume of cells
+real D{cells}; // Cell centered conductivity
+real faceLength{faces}, faceConductivity{faces};
+real α{cells, cells};
 
 iterate n while (t^{n+1} < stopTime && n+1 < maxIterations);
 
@@ -48,9 +48,9 @@ ComputeFaceConductivity: ∀f∈faces(), faceConductivity{f} = 2.0 * ∏{c1∈ce
 
 // Assembling of the diffusion matrix
 ComputeAlphaCoeff: ∀c∈cells(), {
-	let ℝ αDiag = 0.0;
+	let real αDiag = 0.0;
 	∀d∈neighbourCells(c), ∀f∈commonFace(c,d), {
-		let ℝ αExtraDiag = δt / V{c} * (faceLength{f} *  faceConductivity{f}) / norm(Xc{c} - Xc{d});
+		let real αExtraDiag = δt / V{c} * (faceLength{f} *  faceConductivity{f}) / norm(Xc{c} - Xc{d});
 		α{c, d} = αExtraDiag;
 		αDiag = αDiag + αExtraDiag;
 	}

plugins/fr.cea.nabla.ui/examples/NabLabExamples/src/glace2d/Glace2d.n

@@ -13,50 +13,50 @@ with Math.*;
 with CartesianMesh2D.*;
 
 // Only for 2D vectors
-def perp: ℝ[2] → ℝ[2], (a) → return [ a[1], -a[0] ];
+def perp: real[2] → real[2], (a) → return [ a[1], -a[0] ];
 
-def trace: l | ℝ[l,l] → ℝ, (a) → {
-	let ℝ result = 0.0;
+def trace: l | real[l,l] → real, (a) → {
+	let real result = 0.0;
 	∀ ia ∈ [0;l[, result = result + a[ia, ia];
 	return result;
 }
 
-def tensProduct: l | ℝ[l] × ℝ[l] → ℝ[l,l], (a, b) → {
-	ℝ[l,l] result;
+def tensProduct: l | real[l] × real[l] → real[l,l], (a, b) → {
+	real[l,l] result;
 	∀ ia ∈ [0;l[,
 		∀ ib ∈ [0;l[,
 			result[ia,ib] = a[ia]*b[ib];
 	return result;
 }
 
 // Only for 2x2 matrices
-def inverse: ℝ[2,2] → ℝ[2,2], (a) → {
-	let ℝ alpha = 1.0 / det(a);
+def inverse: real[2,2] → real[2,2], (a) → {
+	let real alpha = 1.0 / det(a);
 	return [[ a[1,1] * alpha, -a[0,1] * alpha ],
 			[-a[1,0] * alpha,  a[0,0] * alpha ]];
 }
 
 // Simulation options
-ℝ stopTime;
-ℕ maxIterations;
-
-let ℝ γ = 1.4;
-let ℝ xInterface = 0.5;
-let ℝ δtCfl = 0.4;
-let ℝ ρIniZg = 1.0;
-let ℝ ρIniZd = 0.125;
-let ℝ pIniZg = 1.0;
-let ℝ pIniZd = 0.1;
-ℝ t, δt;
-ℝ[2] X{nodes}, b{nodes}, bt{nodes};
-ℝ[2,2] Ar{nodes}, Mt{nodes};
-ℝ[2] ur{nodes};
-ℝ c{cells}, m{cells}, p{cells}, ρ{cells}, e{cells}, E{cells}, V{cells};
-ℝ δtj{cells};
-ℝ[2] uj{cells};
-ℝ l{cells, nodesOfCell};
-ℝ[2] Cjr_ic{cells, nodesOfCell}, C{cells, nodesOfCell}, F{cells, nodesOfCell};
-ℝ[2,2] Ajr{cells, nodesOfCell};
+real stopTime;
+int maxIterations;
+
+let real γ = 1.4;
+let real xInterface = 0.5;
+let real δtCfl = 0.4;
+let real ρIniZg = 1.0;
+let real ρIniZd = 0.125;
+let real pIniZg = 1.0;
+let real pIniZd = 0.1;
+real t, δt;
+real[2] X{nodes}, b{nodes}, bt{nodes};
+real[2,2] Ar{nodes}, Mt{nodes};
+real[2] ur{nodes};
+real c{cells}, m{cells}, p{cells}, ρ{cells}, e{cells}, E{cells}, V{cells};
+real δtj{cells};
+real[2] uj{cells};
+real l{cells, nodesOfCell};
+real[2] Cjr_ic{cells, nodesOfCell}, C{cells, nodesOfCell}, F{cells, nodesOfCell};
+real[2,2] Ajr{cells, nodesOfCell};
 
 iterate n while (t^{n+1} < stopTime && n+1 < maxIterations);
 
@@ -68,16 +68,16 @@ IniCjrIc: ∀j∈cells(), ∀r∈nodesOfCell(j),
 	Cjr_ic{j,r} = 0.5 * perp(X^{n=0}{r+1} - X^{n=0}{r-1});
 
 Initialize: ∀j∈cells(), {
-	ℝ ρ_ic, p_ic;
-	let ℝ[2] center = 0.25 * ∑{r∈nodesOfCell(j)}(X^{n=0}{r});
+	real ρ_ic, p_ic;
+	let real[2] center = 0.25 * ∑{r∈nodesOfCell(j)}(X^{n=0}{r});
 	if (center[0] < xInterface) {
 		ρ_ic = ρIniZg;
 		p_ic = pIniZg;
 	} else {
 		ρ_ic = ρIniZd;
 		p_ic = pIniZd;
 	}
-	let ℝ V_ic = 0.5 * ∑{r∈nodesOfCell(j)}(dot(Cjr_ic{j,r}, X^{n=0}{r}));
+	let real V_ic = 0.5 * ∑{r∈nodesOfCell(j)}(dot(Cjr_ic{j,r}, X^{n=0}{r}));
 	m{j} = ρ_ic * V_ic; // m is a constant
 	p{j} = p_ic;
 	ρ{j} = ρ_ic;
@@ -111,20 +111,20 @@ ComputeMt: ∀r∈nodes("InnerNodes"), Mt{r} = Ar{r};
 ComputeBt: ∀r∈nodes("InnerNodes"), bt{r} = b{r};
 
 ComputeBoundaryConditions: {
-	let ℝ[2,2] I = [ [1.0, 0.0], [0.0, 1.0] ];
+	let real[2,2] I = [ [1.0, 0.0], [0.0, 1.0] ];
 
 	// Y boundary conditions (must be done before X)
 	∀r∈nodes("TopNodes"), {
-		let ℝ[2] N = [0.0, 1.0];
-		let ℝ[2,2] NxN = tensProduct(N,N);
-		let ℝ[2,2] IcP = I - NxN;
+		let real[2] N = [0.0, 1.0];
+		let real[2,2] NxN = tensProduct(N,N);
+		let real[2,2] IcP = I - NxN;
 		bt{r} = matVectProduct(IcP, b{r});
 		Mt{r} = IcP * (Ar{r} * IcP) + NxN*trace(Ar{r});
 	}
 	∀r∈nodes("BottomNodes"), {
-		let ℝ[2] N = [0.0, -1.0];
-		let ℝ[2,2] NxN = tensProduct(N,N);
-		let ℝ[2,2] IcP = I - NxN;
+		let real[2] N = [0.0, -1.0];
+		let real[2,2] NxN = tensProduct(N,N);
+		let real[2,2] IcP = I - NxN;
 		bt{r} = matVectProduct(IcP, b{r});
 		Mt{r} = IcP * (Ar{r} * IcP) + NxN*trace(Ar{r});
 	}

plugins/fr.cea.nabla.ui/examples/NabLabExamples/src/heatequation/HeatEquation.n

@@ -13,15 +13,15 @@ with Math.*;
 with CartesianMesh2D.*;
 
 // Simulation options
-ℝ stopTime;
-ℕ maxIterations;
+real stopTime;
+int maxIterations;
 
-let ℝ PI = 3.1415926;
-let ℝ α = 1.0;
-let ℝ δt = 0.001;
-ℝ t;
-ℝ[2] X{nodes}, center{cells};
-ℝ u{cells}, V{cells}, f{cells}, outgoingFlux{cells}, surface{faces};
+let real PI = 3.1415926;
+let real α = 1.0;
+let real δt = 0.001;
+real t;
+real[2] X{nodes}, center{cells};
+real u{cells}, V{cells}, f{cells}, outgoingFlux{cells}, surface{faces};
 
 iterate n while (t^{n+1} < stopTime && n+1 < maxIterations);
 

plugins/fr.cea.nabla.ui/examples/NabLabExamples/src/implicitheatequation/ImplicitHeatEquation.n

@@ -14,19 +14,19 @@ with LinearAlgebra.*;
 with CartesianMesh2D.*;
 
 // Simulation options
-ℝ stopTime;
-ℕ maxIterations;
-
-let ℝ u0 = 1.0;
-let ℝ[2] vectOne = ℝ[2](1.0);
-let ℝ δt = 0.001;
-ℝ t;
-ℝ[2] X{nodes}, Xc{cells}; // Position of nodes and cells center of gravity 
-ℝ u{cells}; // Temperature
-ℝ V{cells}; // Volume of cells
-ℝ D{cells}; // Cell centered conductivity
-ℝ faceLength{faces}, faceConductivity{faces};
-ℝ α{cells, cells}; 
+real stopTime;
+int maxIterations;
+
+let real u0 = 1.0;
+let real[2] vectOne = real[2](1.0);
+let real δt = 0.001;
+real t;
+real[2] X{nodes}, Xc{cells}; // Position of nodes and cells center of gravity 
+real u{cells}; // Temperature
+real V{cells}; // Volume of cells
+real D{cells}; // Cell centered conductivity
+real faceLength{faces}, faceConductivity{faces};
+real α{cells, cells}; 
 
 iterate n while (t^{n+1} < stopTime && n+1 < maxIterations);
 
@@ -49,9 +49,9 @@ ComputeFaceConductivity: ∀f∈faces(), faceConductivity{f} = 2.0 * ∏{c1∈ce
 
 // Assembling of the diffusion matrix
 ComputeAlphaCoeff: ∀c∈cells(), {
-	let ℝ αDiag = 0.0;
+	let real αDiag = 0.0;
 	∀d∈neighbourCells(c), ∀f∈commonFace(c,d), {
-		let ℝ αExtraDiag = - δt / V{c} * (faceLength{f} *  faceConductivity{f}) / norm(Xc{c} - Xc{d});
+		let real αExtraDiag = - δt / V{c} * (faceLength{f} *  faceConductivity{f}) / norm(Xc{c} - Xc{d});
 		α{c, d} = αExtraDiag;
 		αDiag = αDiag + αExtraDiag;
 	}

plugins/fr.cea.nabla.ui/examples/NabLabExamples/src/iterativeheatequation/IterativeHeatEquation.n

@@ -12,25 +12,25 @@ module IterativeHeatEquation;
 with Math.*;
 with CartesianMesh2D.*;
 
-def check: ℾ → ℾ, (a) → if (a) return true; else exit "Assertion failed";
+def check: bool → bool, (a) → if (a) return true; else exit "Assertion failed";
 
 // Simulation options
-ℝ stopTime;
-ℕ maxIterations;
+real stopTime;
+int maxIterations;
 
-let ℝ u0 = 1.0;
-let ℝ[2] vectOne = ℝ[2](1.0);
-let ℕ maxIterationsK = 1000;
-let ℝ ε =  1.0e-8;
-let ℝ δt = 0.001;
-ℝ t;
-ℝ[2] X{nodes}, Xc{cells}; // Position of nodes and cells center of gravity 
-ℝ u{cells}; // Temperature
-ℝ V{cells}; // Volume of cells
-ℝ D{cells}; // Cell centered conductivity
-ℝ faceLength{faces}, faceConductivity{faces};
-ℝ α{cells, cells};
-ℝ residual;
+let real u0 = 1.0;
+let real[2] vectOne = real[2](1.0);
+let int maxIterationsK = 1000;
+let real ε =  1.0e-8;
+let real δt = 0.001;
+real t;
+real[2] X{nodes}, Xc{cells}; // Position of nodes and cells center of gravity 
+real u{cells}; // Temperature
+real V{cells}; // Volume of cells
+real D{cells}; // Cell centered conductivity
+real faceLength{faces}, faceConductivity{faces};
+real α{cells, cells};
+real residual;
 
 iterate	n while (t^{n+1} < stopTime && n+1 < maxIterations),
 		k while (residual > ε && check(k+1 < maxIterationsK));
@@ -54,9 +54,9 @@ ComputeFaceConductivity: ∀f∈faces(), faceConductivity{f} = 2.0 * ∏{c1∈ce
 
 // Assembling of the diffusion matrix
 ComputeAlphaCoeff: ∀c∈cells(), {
-	let ℝ αDiag = 0.0;
+	let real αDiag = 0.0;
 	∀d∈neighbourCells(c), ∀f∈commonFace(c,d), {
-		let ℝ αExtraDiag = δt / V{c} * (faceLength{f} *  faceConductivity{f}) / norm(Xc{c} - Xc{d});
+		let real αExtraDiag = δt / V{c} * (faceLength{f} *  faceConductivity{f}) / norm(Xc{c} - Xc{d});
 		α{c, d} = αExtraDiag;
 		αDiag = αDiag + αExtraDiag;
 	}

plugins/fr.cea.nabla.ui/src/fr/cea/nabla/ui/wizards/NewNablaProjectWizard.xtend

@@ -256,12 +256,12 @@ class NewNablaProjectWizard extends Wizard implements INewWizard
 
 		with CartesianMesh2D.*;
 
-		let ℕ maxIter = 200;
-		let ℝ maxTime = 1.0;
+		let int maxIter = 200;
+		let real maxTime = 1.0;
 
-		ℝ t, δt;
-		ℝ[2] X{nodes};
-		ℝ e{nodes};
+		real t, δt;
+		real[2] X{nodes};
+		real e{nodes};
 
 		iterate n while (n+1 < maxIter && t^{n+1} < maxTime);
 	'''
@@ -270,7 +270,7 @@ class NewNablaProjectWizard extends Wizard implements INewWizard
 	'''
 		extension «extensionName»;
 
-		def myMatVectProduct: x, y  | ℝ[x,y] × ℝ[y] → ℝ[x];
+		def myMatVectProduct: x, y  | real[x,y] × real[y] → real[x];
 	'''
 
 	private def getManifestContent()

plugins/fr.cea.nabla/model/generated/Nabla.ecore

@@ -225,9 +225,9 @@
         eType="#//Expression" containment="true"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EEnum" name="PrimitiveType">
-    <eLiterals name="Int" literal="ℕ"/>
-    <eLiterals name="Real" value="1" literal="ℝ"/>
-    <eLiterals name="Bool" value="2" literal="ℾ"/>
+    <eLiterals name="Int" literal="int"/>
+    <eLiterals name="Real" value="1" literal="real"/>
+    <eLiterals name="Bool" value="2" literal="bool"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="BaseType">
     <eStructuralFeatures xsi:type="ecore:EAttribute" name="primitive" eType="#//PrimitiveType"/>

plugins/fr.cea.nabla/nablalib/Assert.n

@@ -9,29 +9,29 @@
  *******************************************************************************/
 extension Assert;
 
-def assertEquals: ℕ × ℕ → ℾ, (expected, actual) →
+def assertEquals: int × int → bool, (expected, actual) →
 {
-	let ℾ ret = (expected == actual);
+	let bool ret = (expected == actual);
 	if (!ret) exit "** Assertion failed";
 	return ret;
 }
 
-def assertEquals: ℝ × ℝ → ℾ, (expected, actual) →
+def assertEquals: real × real → bool, (expected, actual) →
 {
-	let ℾ ret = (expected == actual);
+	let bool ret = (expected == actual);
 	if (!ret) exit "** Assertion failed";
 	return ret;
 }
 
-def assertEquals: x | ℕ[x] × ℕ[x] → ℾ, (expected, actual) →
+def assertEquals: x | int[x] × int[x] → bool, (expected, actual) →
 {
 	∀i∈[0;x[,
 		if (expected[i] != actual[i])
 			exit "** Assertion failed";
 	return true;
 }
 
-def assertEquals: x | ℝ[x] × ℝ[x] → ℾ, (expected, actual) →
+def assertEquals: x | real[x] × real[x] → bool, (expected, actual) →
 {
 	∀i∈[0;x[,
 		if (expected[i] != actual[i])