[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 <[email protected]>

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

@@ -31,31 +31,31 @@ iterate n while (t^{n+1} < stopTime && n+1 < maxIterations);
 
 InitTime: t^{n=0} = 0.0;
 
-InitXc: ∀c∈cells(), Xc{c} = 0.25 * sum{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: delta_t = Min{c∈cells()}(V{c}/D{c}) * 0.24;
-ComputeV: ∀c∈cells(), V{c} = 0.5 * sum{p∈nodesOfCell(c)}(det(X{p}, X{p+1}));
-ComputeFaceLength: ∀f∈faces(), faceLength{f} = 0.5 * sum{p∈nodesOfFace(f)}(norm(X{p} - X{p+1}));
-ComputeFaceConductivity: ∀f∈faces(), faceConductivity{f} = 2.0 * prod{c1∈cellsOfFace(f)}(D{c1}) / sum{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(), {
+ComputeAlphaCoeff: forall c in cells(), {
 	let real alpha_Diag = 0.0;
-	∀d∈neighbourCells(c), ∀f∈commonFace(c,d), {
+	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;
 	}
 	alpha{c, c} = 1 - alpha_Diag;
 }
 
-UpdateU: ∀c∈cells(), u^{n+1}{c} = alpha{c, c} * u^{n}{c} + sum{d∈neighbourCells(c)} (alpha{c, d} * u^{n}{d});
+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 ]];
@@ -64,20 +64,20 @@ 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(), {
+Initialize: forall j in cells(), {
 	real rho_ic, p_ic;
-	let real[2] center = 0.25 * sum{r∈nodesOfCell(j)}(X^{n=0}{r});
+	let real[2] center = 0.25 * sum{r in nodesOfCell(j)}(X^{n=0}{r});
 	if (center[0] < xInterface) {
 		rho_ic = rho_IniZg;
 		p_ic = pIniZg;
 	} else {
 		rho_ic = rho_IniZd;
 		p_ic = pIniZd;
 	}
-	let real V_ic = 0.5 * sum{r∈nodesOfCell(j)}(dot(Cjr_ic{j,r}, X^{n=0}{r}));
+	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;
 	rho{j} = rho_ic;
@@ -88,40 +88,40 @@ Initialize: ∀j∈cells(), {
 // *************************************************************
 // * 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});
-Computedeltatj: ∀j∈cells(), delta_tj{j} = 2.0 * V{j} / (c{j} * sum{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, rho, c, p, e
 // *************************************************************
-ComputeDensity: ∀j∈cells(), rho{j} = m{j} / V{j};
-ComputeEOSp: ∀j∈cells(), p{j} = (gamma-1.0) * rho{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} = sqrt(gamma * p{j} / rho{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} = ((rho{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} = sum{j∈cellsOfNode(r)}(Ajr{j,r});
-ComputeBr: ∀r∈nodes(), b{r} = sum{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 * sum{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} + delta_t * ur{r};
-ComputeUn: ∀j∈cells(), uj^{n+1}{j} = uj^{n}{j} - (delta_t/m{j}) * sum{r∈nodesOfCell(j)}(F{j,r});
-ComputeEn: ∀j∈cells(), E^{n+1}{j} = E^{n}{j} - (delta_t / m{j}) * sum{r∈nodesOfCell(j)}(dot(F{j,r}, ur{r}));
-ComputeDt: delta_t = min((delta_tCfl * Min{j∈cells()}(delta_tj{j})), (stopTime-t^{n}));
+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

@@ -26,11 +26,11 @@ 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 * sum{r∈nodesOfCell(j)}(X{r});  // only on parallelograms
-IniUn: ∀j∈cells(), u^{n}{j} = cos(2 * PI * alpha * center{j}[0]);
-ComputeV: ∀j∈cells(), V{j} = 0.5 * sum{r∈nodesOfCell(j)}(det(X{r}, X{r+1}));
-ComputeSurface: ∀f∈faces(), surface{f} = 0.5 * sum{r∈nodesOfFace(f)}(norm(X{r}-X{r+1}));
-ComputeOutgoingFlux: ∀j1∈cells(), outgoingFlux{j1} = delta_t/V{j1} * sum{j2∈neighbourCells(j1)}(sum{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} * delta_t + u^{n}{j} + outgoingFlux{j};
+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

@@ -32,25 +32,25 @@ iterate n while (t^{n+1} < stopTime && n+1 < maxIterations);
 
 InitTime: t^{n=0} = 0.0;
 
-InitXc: ∀c∈cells(), Xc{c} = 0.25 * sum{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: delta_t = Min{c∈cells()}(V{c}/D{c}) * 0.24;
-ComputeV: ∀j∈cells(), V{j} = 0.5 * sum{p∈nodesOfCell(j)}(det(X{p}, X{p+1}));
-ComputeFaceLength: ∀f∈faces(), faceLength{f} = 0.5 * sum{p∈nodesOfFace(f)}(norm(X{p} - X{p+1}));
-ComputeFaceConductivity: ∀f∈faces(), faceConductivity{f} = 2.0 * prod{c1∈cellsOfFace(f)}(D{c1}) / sum{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(), {
+ComputeAlphaCoeff: forall c in cells(), {
 	let real alpha_Diag = 0.0;
-	∀d∈neighbourCells(c), ∀f∈commonFace(c,d), {
+	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;

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

@@ -12,7 +12,7 @@ module IterativeHeatEquation;
 with Math.*;
 with CartesianMesh2D.*;
 
-def check: bool → bool, (a) → if (a) return true; else exit "Assertion failed";
+def bool check(bool a) if (a) return true; else exit "Assertion failed";
 
 // Simulation options
 real stopTime;
@@ -37,32 +37,32 @@ iterate	n while (t^{n+1} < stopTime && n+1 < maxIterations),
 
 InitTime: t^{n=0} = 0.0;
 
-InitXc: ∀c∈cells(), Xc{c} = 0.25 * sum{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: delta_t = Min{c∈cells()}(V{c}/D{c}) * 0.1;
-ComputeV: ∀j∈cells(), V{j} = 0.5 * sum{p∈nodesOfCell(j)}(det(X{p}, X{p+1}));
-ComputeFaceLength: ∀f∈faces(), faceLength{f} = 0.5 * sum{p∈nodesOfFace(f)}(norm(X{p} - X{p+1}));
-ComputeFaceConductivity: ∀f∈faces(), faceConductivity{f} = 2.0 * prod{c1∈cellsOfFace(f)}(D{c1}) / sum{c2∈cellsOfFace(f)}(D{c2});
+ComputeDeltaTn: delta_t = Min{c in cells()}(V{c}/D{c}) * 0.1;
+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(), {
+ComputeAlphaCoeff: forall c in cells(), {
 	let real alpha_Diag = 0.0;
-	∀d∈neighbourCells(c), ∀f∈commonFace(c,d), {
+	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;
 	}
 	alpha{c, c} = -alpha_Diag;
 }
 
-UpdateU: ∀c∈cells(), u^{n+1, k+1}{c} = u^{n}{c} + alpha{c, c} * u^{n+1, k}{c} + sum{d∈neighbourCells(c)} (alpha{c, d} * u^{n+1, k}{d});
-ComputeResidual: residual = Max{j ∈ cells()}(abs(u^{n+1,k+1}{j} - u^{n+1,k}{j}));
+UpdateU: forall c in cells(), u^{n+1, k+1}{c} = u^{n}{c} + alpha{c, c} * u^{n+1, k}{c} + sum{d in neighbourCells(c)} (alpha{c, d} * u^{n+1, k}{d});
+ComputeResidual: residual = Max{j in cells()}(abs(u^{n+1,k+1}{j} - u^{n+1,k}{j}));
 ComputeTn: t^{n+1} = t^{n} + delta_t;

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

@@ -270,7 +270,7 @@ class NewNablaProjectWizard extends Wizard implements INewWizard
 	'''
 		extension «extensionName»;
 
-		def myMatVectProduct: x, y  | real[x,y] × real[y] → real[x];
+		def myMatVectProduct: x, y  | real[x,y] , real[y] : real[x];
 	'''
 
 	private def getManifestContent()