function [err, uh, xDOFs] = efcv(N, Omega, f, k, u, deru)
  // N     = nombre des noeuds internes
  // Omega = domaine
  // f     = seconde membre
  // k     = dégré [1,2]

  //--------------------------------------------------------------------
  // Initialisation du domaine

  if (Omega(2) <= Omega(1))
    error("Domaine non valide");
  end

  h = (Omega(2)-Omega(1)) / (N+1);

  X = Omega(1):h:Omega(2);

  //--------------------------------------------------------------------
  // Initialisation de l'espace des éléments finis

  if (k == 1)   
    Aloc = [1, -1; -1, 1];

    NDOFs = N+2;
    DOFs = [(1:N+1)', (2:N+2)'];

    xDOFs = Omega(1):h:Omega(2);
  elseif (k == 2)
    Aloc = 1/3 * [7, -8, 1; -8, 16, -8; 1, -8, 7];

    NDOFs = 2*N+3;
    DOFs = [(1:2:2*N+1)', (2:2:2*N+2)', (3:2:2*N+3)'];

    xDOFs = Omega(1):h/2:Omega(2);
  else
    error("Dégrée %i non disponible", k);
  end

  //--------------------------------------------------------------------
  // Evaluation des fonctions de base aux noeuds de quadrature
  
  w = [5/18, 8/18, 5/18];                    // poids
  t = [0.5-sqrt(3/20), 0.5, 0.5+sqrt(3/20)]; // noeuds

  if (k == 1)
    phit = [1-t; t];
    derPhit = [-ones(size(t,1),1); ones(size(t,1),1)];
  elseif (k == 2)
    phit = [(2*t-1).*(t-1); 4*t.*(1-t); t.*(2*t-1)];
    derPhit = [4*t-3; 4-8*t; 4*t-1];
  else
    error("Dégrée %i non disponible", k);
  end

  //--------------------------------------------------------------------
  // Assemblage

  A = zeros(NDOFs, NDOFs);
  b = zeros(NDOFs, 1);

  for (i = 1:N+1)
    wi = w * (X(i+1) - X(i));
    xi = X(i) + t * (X(i+1) - X(i));

    A(DOFs(i,:), DOFs(i,:)) = A(DOFs(i,:), DOFs(i,:)) + 1/h * Aloc;
    x = xi;
    b(DOFs(i,:)) = b(DOFs(i,:)) + phit * (wi .* eval(f))';
  end

  // Conditions de Dirichlet homogènes
  A = A(2:NDOFs-1, 2:NDOFs-1);
  b = b(2:NDOFs-1);

  uh = A \ b;
  uh = [0; uh; 0];

  //--------------------------------------------------------------------
  // Calcul de l'erreur

  //norme L2
  errl2 = 0;

  for (i = 1:N+1)
    wi = w * (X(i+1) - X(i));
    xi = X(i) + t * (X(i+1) - X(i));

    x = xi;
    errl2 = errl2 + sum((uh(DOFs(i,:))' * phit - eval(u)).^2 .* wi);
  end
  errl2 = sqrt(errl2);

  // norme H1
  errh1 = errl2^2;

  for (i = 1:N+1)
    wi = w * (X(i+1) - X(i));
    xi = X(i) + t * (X(i+1) - X(i));
    hi = X(i+1)-X(i);

    x = xi;
    errh1 = errh1 + sum((uh(DOFs(i,:))' * derPhit / hi - eval(deru)).^2 .* wi);
  end
  errh1 = sqrt(errh1);

  err = [errl2, errh1];

endfunction