[98] Functions modifications

Replace \u2200 and \u2208 caracters by 'forall' and 'in'.
Replace \u2192, \u00D7 caracters by changing the function/reduction
syntaxes.

Bug: cea-hpc#98
Signed-off-by: Vincent BLAIN <vincent.blain@obeosoft.com>

plugins/fr.cea.nabla.edit/plugin.properties

@@ -308,3 +308,13 @@ _UI_ConnectivityCall_group_feature = Group
 _UI_TargetType_ArcaneSequential_literal = ArcaneSequential
 _UI_TargetType_ArcaneAccelerator_literal = ArcaneAccelerator
 _UI_TargetType_ArcaneThread_literal = ArcaneThread
+_UI_Function_returnType_feature = Return Type
+_UI_Function_inTypes_feature = In Types
+_UI_FunctionReturnTypeDeclaration_type = Function Return Type Declaration
+_UI_FunctionInTypeDeclaration_type = Function In Type Declaration
+_UI_Function_returnTypeDeclaration_feature = Return Type Declaration
+_UI_Function_intypesDeclaration_feature = Intypes Declaration
+_UI_FunctionReturnTypeDeclaration_returnType_feature = Return Type
+_UI_FunctionInTypeDeclaration_inTypes_feature = In Types
+_UI_Reduction_inArgs_feature = In Args
+_UI_FunctionInTypeDeclaration_inArgs_feature = In Args

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

@@ -18,44 +18,44 @@ int maxIterations;
 
 let real u0 = 1.0;
 let real[2] vectOne = real[2](1.0);
-let real δt = 0.001;
+let real delta_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 alpha{cells, cells};
 
 iterate n while (t^{n+1} < stopTime && n+1 < maxIterations);
 
 InitTime: t^{n=0} = 0.0;
 
-InitXc: ∀c∈cells(), Xc{c} = 0.25 * ∑{p∈nodesOfCell(c)}(X{p});  // Only valid on parallelograms
+InitXc: forall c in cells(), Xc{c} = 0.25 * sum{p in nodesOfCell(c)}(X{p});  // Only valid on parallelograms
 
-InitU: ∀c∈cells(),
+InitU: forall c in cells(),
 	if (norm(Xc{c} - vectOne) < 0.5)
 		u^{n}{c} = u0;
 	else 
 		u^{n}{c} = 0.0; // Initial circle in the center with value u0
 
-InitD: ∀c∈cells(), D{c} = 1.0;
+InitD: forall c in cells(), D{c} = 1.0;
 
-ComputeDeltaTn: δt = Min{c∈cells()}(V{c}/D{c}) * 0.24;
-ComputeV: ∀c∈cells(), V{c} = 0.5 * ∑{p∈nodesOfCell(c)}(det(X{p}, X{p+1}));
-ComputeFaceLength: ∀f∈faces(), faceLength{f} = 0.5 * ∑{p∈nodesOfFace(f)}(norm(X{p} - X{p+1}));
-ComputeFaceConductivity: ∀f∈faces(), faceConductivity{f} = 2.0 * ∏{c1∈cellsOfFace(f)}(D{c1}) / ∑{c2∈cellsOfFace(f)}(D{c2});
+ComputeDeltaTn: delta_t = Min{c in cells()}(V{c}/D{c}) * 0.24;
+ComputeV: forall c in cells(), V{c} = 0.5 * sum{p in nodesOfCell(c)}(det(X{p}, X{p+1}));
+ComputeFaceLength: forall f in faces(), faceLength{f} = 0.5 * sum{p in nodesOfFace(f)}(norm(X{p} - X{p+1}));
+ComputeFaceConductivity: forall f in faces(), faceConductivity{f} = 2.0 * prod{c1 in cellsOfFace(f)}(D{c1}) / sum{c2 in cellsOfFace(f)}(D{c2});
 
 // Assembling of the diffusion matrix
-ComputeAlphaCoeff: ∀c∈cells(), {
-	let real αDiag = 0.0;
-	∀d∈neighbourCells(c), ∀f∈commonFace(c,d), {
-		let real αExtraDiag = δt / V{c} * (faceLength{f} *  faceConductivity{f}) / norm(Xc{c} - Xc{d});
-		α{c, d} = αExtraDiag;
-		αDiag = αDiag + αExtraDiag;
+ComputeAlphaCoeff: forall c in cells(), {
+	let real alpha_Diag = 0.0;
+	forall d in neighbourCells(c), forall f in commonFace(c,d), {
+		let real alpha_ExtraDiag = delta_t / V{c} * (faceLength{f} *  faceConductivity{f}) / norm(Xc{c} - Xc{d});
+		alpha{c, d} = alpha_ExtraDiag;
+		alpha_Diag = alpha_Diag + alpha_ExtraDiag;
 	}
-	α{c, c} = 1 - αDiag;
+	alpha{c, c} = 1 - alpha_Diag;
 }
 
-UpdateU: ∀c∈cells(), u^{n+1}{c} = α{c, c} * u^{n}{c} + ∑{d∈neighbourCells(c)} (α{c, d} * u^{n}{d});
-ComputeTn: t^{n+1} = t^{n} + δt;
+UpdateU: forall c in cells(), u^{n+1}{c} = alpha{c, c} * u^{n}{c} + sum{d in neighbourCells(c)} (alpha{c, d} * u^{n}{d});
+ComputeTn: t^{n+1} = t^{n} + delta_t;

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

@@ -13,24 +13,24 @@ with Math.*;
 with CartesianMesh2D.*;
 
 // Only for 2D vectors
-def perp: real[2] → real[2], (a) → return [ a[1], -a[0] ];
+def real[2] perp(real[2] a) return [ a[1], -a[0] ];
 
-def trace: l | real[l,l] → real, (a) → {
+def <l> real trace(real[l,l] a)  {
 	let real result = 0.0;
-	∀ ia ∈ [0;l[, result = result + a[ia, ia];
+	forall  ia in [0;l[, result = result + a[ia, ia];
 	return result;
 }
 
-def tensProduct: l | real[l] × real[l] → real[l,l], (a, b) → {
+def <l> real[l,l] tensProduct(real[l] a, real[l] b)  {
 	real[l,l] result;
-	∀ ia ∈ [0;l[,
-		∀ ib ∈ [0;l[,
+	forall  ia in [0;l[,
+		forall  ib in [0;l[,
 			result[ia,ib] = a[ia]*b[ib];
 	return result;
 }
 
 // Only for 2x2 matrices
-def inverse: real[2,2] → real[2,2], (a) → {
+def real[2,2] inverse(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 ]];
@@ -40,19 +40,19 @@ def inverse: real[2,2] → real[2,2], (a) → {
 real stopTime;
 int maxIterations;
 
-let real γ = 1.4;
+let real gamma = 1.4;
 let real xInterface = 0.5;
-let real δtCfl = 0.4;
-let real ρIniZg = 1.0;
-let real ρIniZd = 0.125;
+let real delta_tCfl = 0.4;
+let real rho_IniZg = 1.0;
+let real rho_IniZd = 0.125;
 let real pIniZg = 1.0;
 let real pIniZd = 0.1;
-real t, δt;
+real t, delta_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 c{cells}, m{cells}, p{cells}, rho{cells}, e{cells}, E{cells}, V{cells};
+real delta_tj{cells};
 real[2] uj{cells};
 real l{cells, nodesOfCell};
 real[2] Cjr_ic{cells, nodesOfCell}, C{cells, nodesOfCell}, F{cells, nodesOfCell};
@@ -64,64 +64,64 @@ iterate n while (t^{n+1} < stopTime && n+1 < maxIterations);
 // * Initialization
 // *************************************************************
 IniTime: t^{n=0} = 0.0;
-IniCjrIc: ∀j∈cells(), ∀r∈nodesOfCell(j),
+IniCjrIc: forall j in cells(), forall r in nodesOfCell(j),
 	Cjr_ic{j,r} = 0.5 * perp(X^{n=0}{r+1} - X^{n=0}{r-1});
 
-Initialize: ∀j∈cells(), {
-	real ρ_ic, p_ic;
-	let real[2] center = 0.25 * ∑{r∈nodesOfCell(j)}(X^{n=0}{r});
+Initialize: forall j in cells(), {
+	real rho_ic, p_ic;
+	let real[2] center = 0.25 * sum{r in nodesOfCell(j)}(X^{n=0}{r});
 	if (center[0] < xInterface) {
-		ρ_ic = ρIniZg;
+		rho_ic = rho_IniZg;
 		p_ic = pIniZg;
 	} else {
-		ρ_ic = ρIniZd;
+		rho_ic = rho_IniZd;
 		p_ic = pIniZd;
 	}
-	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
+	let real V_ic = 0.5 * sum{r in nodesOfCell(j)}(dot(Cjr_ic{j,r}, X^{n=0}{r}));
+	m{j} = rho_ic * V_ic; // m is a constant
 	p{j} = p_ic;
-	ρ{j} = ρ_ic;
-	E^{n}{j} = p_ic / ((γ-1.0) * ρ_ic);
+	rho{j} = rho_ic;
+	E^{n}{j} = p_ic / ((gamma-1.0) * rho_ic);
 	uj^{n}{j} = [0.0, 0.0];
 }
 
 // *************************************************************
 // * C{j,r} and dependent variables computation 
 // *************************************************************
-ComputeCjr: ∀j∈cells(), ∀r∈nodesOfCell(j), C{j,r} = 0.5 * perp(X^{n}{r+1} - X^{n}{r-1});
-ComputeLjr: ∀j∈cells(), ∀r∈nodesOfCell(j), l{j,r} = norm(C{j,r});
-Computeδtj: ∀j∈cells(), δtj{j} = 2.0 * V{j} / (c{j} * ∑{r∈nodesOfCell(j)}(l{j,r}));
+ComputeCjr: forall j in cells(), forall r in nodesOfCell(j), C{j,r} = 0.5 * perp(X^{n}{r+1} - X^{n}{r-1});
+ComputeLjr: forall j in cells(), forall r in nodesOfCell(j), l{j,r} = norm(C{j,r});
+Computedeltatj: forall j in cells(), delta_tj{j} = 2.0 * V{j} / (c{j} * sum{r in nodesOfCell(j)}(l{j,r}));
 
 // *************************************************************
-// * Standard EOS rules: m, ρ, c, p, e
+// * Standard EOS rules: m, rho, c, p, e
 // *************************************************************
-ComputeDensity: ∀j∈cells(), ρ{j} = m{j} / V{j};
-ComputeEOSp: ∀j∈cells(), p{j} = (γ-1.0) * ρ{j} * e{j};
-ComputeInternalEnergy: ∀j∈cells(), e{j} = E^{n}{j} - 0.5 * dot(uj^{n}{j}, uj^{n}{j});
-ComputeEOSc: ∀j∈cells(), c{j} = √(γ * p{j} / ρ{j}); 
+ComputeDensity: forall j in cells(), rho{j} = m{j} / V{j};
+ComputeEOSp: forall j in cells(), p{j} = (gamma-1.0) * rho{j} * e{j};
+ComputeInternalEnergy: forall j in cells(), e{j} = E^{n}{j} - 0.5 * dot(uj^{n}{j}, uj^{n}{j});
+ComputeEOSc: forall j in cells(), c{j} = sqrt(gamma * p{j} / rho{j}); 
 
 // *************************************************************
 // * Cell-centered Godunov Scheme for Lagragian gas dynamics
 // *************************************************************
-ComputeAjr: ∀j∈cells(), ∀r∈nodesOfCell(j), Ajr{j,r} = ((ρ{j} * c{j}) / l{j,r}) * tensProduct(C{j,r}, C{j,r});
-ComputeFjr: ∀j∈cells(), ∀r∈nodesOfCell(j), F{j,r} = p{j} * C{j,r} + matVectProduct(Ajr{j,r}, (uj^{n}{j}-ur{r}));
-ComputeAr: ∀r∈nodes(), Ar{r} = ∑{j∈cellsOfNode(r)}(Ajr{j,r});
-ComputeBr: ∀r∈nodes(), b{r} = ∑{j∈cellsOfNode(r)}(p{j} * C{j,r} + matVectProduct(Ajr{j,r}, uj^{n}{j}));
-ComputeMt: ∀r∈nodes("InnerNodes"), Mt{r} = Ar{r};
-ComputeBt: ∀r∈nodes("InnerNodes"), bt{r} = b{r};
+ComputeAjr: forall j in cells(), forall r in nodesOfCell(j), Ajr{j,r} = ((rho{j} * c{j}) / l{j,r}) * tensProduct(C{j,r}, C{j,r});
+ComputeFjr: forall j in cells(), forall r in nodesOfCell(j), F{j,r} = p{j} * C{j,r} + matVectProduct(Ajr{j,r}, (uj^{n}{j}-ur{r}));
+ComputeAr: forall r in nodes(), Ar{r} = sum{j in cellsOfNode(r)}(Ajr{j,r});
+ComputeBr: forall r in nodes(), b{r} = sum{j in cellsOfNode(r)}(p{j} * C{j,r} + matVectProduct(Ajr{j,r}, uj^{n}{j}));
+ComputeMt: forall r in nodes("InnerNodes"), Mt{r} = Ar{r};
+ComputeBt: forall r in nodes("InnerNodes"), bt{r} = b{r};
 
 ComputeBoundaryConditions: {
 	let real[2,2] I = [ [1.0, 0.0], [0.0, 1.0] ];
 
 	// Y boundary conditions (must be done before X)
-	∀r∈nodes("TopNodes"), {
+	forall r in nodes("TopNodes"), {
 		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"), {
+	forall r in nodes("BottomNodes"), {
 		let real[2] N = [0.0, -1.0];
 		let real[2,2] NxN = tensProduct(N,N);
 		let real[2,2] IcP = I - NxN;
@@ -130,24 +130,24 @@ ComputeBoundaryConditions: {
 	}
 
 	// X boundary conditions
-	∀r∈nodes("LeftNodes"),{
+	forall r in nodes("LeftNodes"),{
 		Mt{r} = I;
 		bt{r} = [0.0, 0.0];
 	}
-	∀r∈nodes("RightNodes"),{
+	forall r in nodes("RightNodes"),{
 		Mt{r} = I;
 		bt{r} = [0.0, 0.0];
 	}
 }
 
-ComputeU: ∀r∈nodes(), ur{r} = matVectProduct(inverse(Mt{r}), bt{r});
-ComputeV: ∀j∈cells(), V{j} = 0.5 * ∑{r∈nodesOfCell(j)}(dot(C{j,r}, X^{n}{r}));
+ComputeU: forall r in nodes(), ur{r} = matVectProduct(inverse(Mt{r}), bt{r});
+ComputeV: forall j in cells(), V{j} = 0.5 * sum{r in nodesOfCell(j)}(dot(C{j,r}, X^{n}{r}));
 
 // *************************************************************
 // * Loop iteration (n)
 // *************************************************************
-ComputeXn: ∀r∈nodes(), X^{n+1}{r} = X^{n}{r} + δt * ur{r};
-ComputeUn: ∀j∈cells(), uj^{n+1}{j} = uj^{n}{j} - (δt/m{j}) * ∑{r∈nodesOfCell(j)}(F{j,r});
-ComputeEn: ∀j∈cells(), E^{n+1}{j} = E^{n}{j} - (δt / m{j}) * ∑{r∈nodesOfCell(j)}(dot(F{j,r}, ur{r}));
-ComputeDt: δt = min((δtCfl * Min{j∈cells()}(δtj{j})), (stopTime-t^{n}));
-ComputeTn: t^{n+1} = t^{n} + δt;
+ComputeXn: forall r in nodes(), X^{n+1}{r} = X^{n}{r} + delta_t * ur{r};
+ComputeUn: forall j in cells(), uj^{n+1}{j} = uj^{n}{j} - (delta_t/m{j}) * sum{r in nodesOfCell(j)}(F{j,r});
+ComputeEn: forall j in cells(), E^{n+1}{j} = E^{n}{j} - (delta_t / m{j}) * sum{r in nodesOfCell(j)}(dot(F{j,r}, ur{r}));
+ComputeDt: delta_t = min((delta_tCfl * Min{j in cells()}(delta_tj{j})), (stopTime-t^{n}));
+ComputeTn: t^{n+1} = t^{n} + delta_t;

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

@@ -17,20 +17,20 @@ real stopTime;
 int maxIterations;
 
 let real PI = 3.1415926;
-let real α = 1.0;
-let real δt = 0.001;
+let real alpha = 1.0;
+let real delta_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);
 
 IniTime: t^{n=0} = 0.0;
-IniF: ∀j∈cells(), f{j} = 0.0;
-IniCenter: ∀j∈cells(), center{j} = 0.25 * ∑{r∈nodesOfCell(j)}(X{r});  // only on parallelograms
-IniUn: ∀j∈cells(), u^{n}{j} = cos(2 * PI * α * center{j}[0]);
-ComputeV: ∀j∈cells(), V{j} = 0.5 * ∑{r∈nodesOfCell(j)}(det(X{r}, X{r+1}));
-ComputeSurface: ∀f∈faces(), surface{f} = 0.5 * ∑{r∈nodesOfFace(f)}(norm(X{r}-X{r+1}));
-ComputeOutgoingFlux: ∀j1∈cells(), outgoingFlux{j1} = δt/V{j1} * ∑{j2∈neighbourCells(j1)}(∑{cf∈commonFace(j1,j2)}( (u^{n}{j2}-u^{n}{j1}) / norm(center{j2}-center{j1}) * surface{cf}));
-ComputeUn: ∀j∈cells(), u^{n+1}{j} = f{j} * δt + u^{n}{j} + outgoingFlux{j};
-ComputeTn: t^{n+1} = t^{n} + δt;
+IniF: forall j in cells(), f{j} = 0.0;
+IniCenter: forall j in cells(), center{j} = 0.25 * sum{r in nodesOfCell(j)}(X{r});  // only on parallelograms
+IniUn: forall j in cells(), u^{n}{j} = cos(2 * PI * alpha * center{j}[0]);
+ComputeV: forall j in cells(), V{j} = 0.5 * sum{r in nodesOfCell(j)}(det(X{r}, X{r+1}));
+ComputeSurface: forall f in faces(), surface{f} = 0.5 * sum{r in nodesOfFace(f)}(norm(X{r}-X{r+1}));
+ComputeOutgoingFlux: forall j1 in cells(), outgoingFlux{j1} = delta_t/V{j1} * sum{j2 in neighbourCells(j1)}(sum{cf in commonFace(j1,j2)}( (u^{n}{j2}-u^{n}{j1}) / norm(center{j2}-center{j1}) * surface{cf}));
+ComputeUn: forall j in cells(), u^{n+1}{j} = f{j} * delta_t + u^{n}{j} + outgoingFlux{j};
+ComputeTn: t^{n+1} = t^{n} + delta_t;

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

@@ -19,44 +19,44 @@ int maxIterations;
 
 let real u0 = 1.0;
 let real[2] vectOne = real[2](1.0);
-let real δt = 0.001;
+let real delta_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 alpha{cells, cells}; 
 
 iterate n while (t^{n+1} < stopTime && n+1 < maxIterations);
 
 InitTime: t^{n=0} = 0.0;
 
-InitXc: ∀c∈cells(), Xc{c} = 0.25 * ∑{p∈nodesOfCell(c)}(X{p});  // Only valid on parallelograms
+InitXc: forall c in cells(), Xc{c} = 0.25 * sum{p in nodesOfCell(c)}(X{p});  // Only valid on parallelograms
 
-InitU: ∀c∈cells(),
+InitU: forall c in cells(),
 	if (norm(Xc{c} - vectOne) < 0.5)
 		u^{n}{c} = u0;
 	else 
 		u^{n}{c} = 0.0; // Initial circle in the center with value u0
 
-InitD: ∀c∈cells(), D{c} = 1.0; 
+InitD: forall c in cells(), D{c} = 1.0; 
 
-ComputeDeltaTn: δt = Min{c∈cells()}(V{c}/D{c}) * 0.24;
-ComputeV: ∀j∈cells(), V{j} = 0.5 * ∑{p∈nodesOfCell(j)}(det(X{p}, X{p+1}));
-ComputeFaceLength: ∀f∈faces(), faceLength{f} = 0.5 * ∑{p∈nodesOfFace(f)}(norm(X{p} - X{p+1}));
-ComputeFaceConductivity: ∀f∈faces(), faceConductivity{f} = 2.0 * ∏{c1∈cellsOfFace(f)}(D{c1}) / ∑{c2∈cellsOfFace(f)}(D{c2});
+ComputeDeltaTn: delta_t = Min{c in cells()}(V{c}/D{c}) * 0.24;
+ComputeV: forall j in cells(), V{j} = 0.5 * sum{p in nodesOfCell(j)}(det(X{p}, X{p+1}));
+ComputeFaceLength: forall f in faces(), faceLength{f} = 0.5 * sum{p in nodesOfFace(f)}(norm(X{p} - X{p+1}));
+ComputeFaceConductivity: forall f in faces(), faceConductivity{f} = 2.0 * prod{c1 in cellsOfFace(f)}(D{c1}) / sum{c2 in cellsOfFace(f)}(D{c2});
 
 // Assembling of the diffusion matrix
-ComputeAlphaCoeff: ∀c∈cells(), {
-	let real αDiag = 0.0;
-	∀d∈neighbourCells(c), ∀f∈commonFace(c,d), {
-		let real αExtraDiag = - δt / V{c} * (faceLength{f} *  faceConductivity{f}) / norm(Xc{c} - Xc{d});
-		α{c, d} = αExtraDiag;
-		αDiag = αDiag + αExtraDiag;
+ComputeAlphaCoeff: forall c in cells(), {
+	let real alpha_Diag = 0.0;
+	forall d in neighbourCells(c), forall f in commonFace(c,d), {
+		let real alpha_ExtraDiag = - delta_t / V{c} * (faceLength{f} *  faceConductivity{f}) / norm(Xc{c} - Xc{d});
+		alpha{c, d} = alpha_ExtraDiag;
+		alpha_Diag = alpha_Diag + alpha_ExtraDiag;
 	}
-	α{c, c} = 1 - αDiag;
+	alpha{c, c} = 1 - alpha_Diag;
 }
 
-UpdateU: u^{n+1} = solveLinearSystem(α, u^{n});
-ComputeTn: t^{n+1} = t^{n} + δt;
+UpdateU: u^{n+1} = solveLinearSystem(alpha, u^{n});
+ComputeTn: t^{n+1} = t^{n} + delta_t;