Serwis Edukacyjny
Nauczycieli I-LO
w Tarnowie
obrazek

Materiały dla uczniów liceum

  Wyjście       Spis treści       Wstecz       Dalej  

Autor artykułu: mgr Jerzy Wałaszek

©2026 mgr Jerzy Wałaszek

W naszym serwisie jest nowszy artykuł o obliczaniu pierwiastków funkcji: "Metody numeryczne".

Metoda Regula Falsi

SPIS TREŚCI
Podrozdziały

Algorytm Regula Falsi

Mamy daną funkcję \(f(x)\) oraz przedział \({[a,b]}\) poszukiwań pierwiastka. W przedziale tym funkcja musi spełniać następujące warunki:

\[
{f(a)<f(x_0)=0<f(b)} \text{ lub } {f(a)>f(x_0)=0>f(b)}
\]

Gdy funkcja \(f(x)\) spełnia podane warunki, to w przedziale \({[a,b]}\) zagwarantowane jest istnienie pierwiastka i możemy go wyszukać algorytmem Regula Falsi.

W języku łacińskim Regula Falsi oznacza fałszywą prostą. Ideą tej metody jest założenie, iż funkcja w coraz mniejszych przedziałach wokół pierwiastka zaczyna przypominać funkcję liniową. Skoro tak, to przybliżenie pierwiastka otrzymujemy prowadząc linię prostą (sieczną) z punktów krańcowych przedziału. Sieczna przecina oś OX w punkcie \(x_0\), który przyjmujemy za przybliżenie pierwiastka – gdyby funkcja faktycznie była liniowa, otrzymany punkt \(x_0\) byłby rzeczywistym pierwiastkiem.

Wzór dla \(x_0\) można wyprowadzić na kilka sposobów. My wybierzemy znane twierdzenie Talesa, które mówi, iż jeżeli ramiona kąta przetniemy dwiema prostymi równoległymi, to długości odcinków wyznaczonych przez te proste na jednym ramieniu kąta będą proporcjonalne do długości odpowiednich odcinków wyznaczonych przez te proste na ramieniu drugim. Poniższy rysunek obrazuje tę sytuację:


\[
\dfrac{|AB|}{|AB'|} = \dfrac{|BC|}{|B'C'|} = \dfrac{|AC|}{|AC'|}
\]

W naszym przypadku postępujemy następująco:

Określmy punkty:

\(a\) i \(b\) – punkty krańcowe przedziału \({[a,b]}\) na osi OX, w którym poszukujemy pierwiastka
\((a,0)\) – współrzędna punku \(a\) w układzie osi OXY
\((b,0)\) – współrzędna punktu \(b\)
\((a,f(a))\) – współrzędna punktu na wykresie o odciętej \(a\) i rzędnej \(f(a))\)
\((b,f(b))\) – współrzędna punktu na wykresie o odciętej \(b\) i rzędnej \(f(b))\)

Kąt utworzą odpowiednie odcinki:

pionowo \({FA = (a,0){-}(a,f(a))}\) powiększony o odcinek \({FB = (b,0){-}(b,-f(b))}\)

poziomo \({XAB = (a,0){-}(b,0)}\)

Prostymi równoległymi będzie cięciwa z punktów krańcowych \((a,f(a))\) i \((b,f(b))\), oraz ta sama cięciwa przesunięta równolegle pionowo w górę o długość odcinka \(FB\).

Poniższy rysunek obrazuje otrzymaną sytuację:

Zgodnie z twierdzeniem Talesa mamy:

\[
\dfrac{FA-FB}{XAB}=\dfrac{FA}{XX{0}}
\]

Jeśli podstawimy do tego wzoru długości odcinków:

\[
\begin{array}{l}
FA = f(a) \\
FB = -f(b) \\
XAB = b - a \\
XX{0} = x_0 - a
\end{array}
\]

Otrzymamy:

\[
\dfrac{f(a)-f(b)}{b-a}=\dfrac{f(a)}{x_0-a}
\]

a dalej:

\[
\begin{array}{l}
(x_0 - a) \cdot \dfrac{f(a) - f(b)}{b - a} = f(a) \\
x_0 - a = f(a) \cdot \dfrac{b - a}{f(a) - f(b)} \\
x_0 = a + f(a) \cdot \dfrac{b - a}{f(a) - f(b)} \\
x_0 = a - f(a) \cdot \dfrac{b - a}{f(b) - f(a)}
\end{array}
\]

Ostatnie przekształcenie ma na celu otrzymanie wzoru o lepszej "zapamiętywalności". Mnożymy mianownik przez \({(-1)}\), dzięki czemu staje się on spójny z licznikiem ułamka. Sam ułamek zmienia znak na minus.

Algorytm Regula Falsi jest bardzo podobny do opisanego w poprzednim rozdziale algorytmu bisekcji. Założenia wstępne dla badanej funkcji w obu algorytmach są identyczne. Różnią się one sposobem wyznaczania punktu \(x_0\). W algorytmie bisekcji punkt ten zawsze wyznaczany był w środku przedziału \({[a,b]}\). Z tego powodu algorytm bisekcji jest "nieczuły" na przebieg funkcji – zawsze zbliża się do pierwiastka w ten sam sposób.

W algorytmie Regula Falsi jest inaczej. Punk \(x_0\) wyznaczany jest w zależności od wartości funkcji na krańcach przedziału poszukiwań. W efekcie w każdej iteracji otrzymujemy lepsze przybliżenie do rzeczywistej wartości pierwiastka. Zatem w większości przypadków algorytm Regula Falsi szybciej osiągnie założoną dokładność pierwiastka od algorytmu bisekcji (chociaż można oczywiście podać kontrprzykłady).

Po wyznaczeniu przybliżonego pierwiastka postępowanie w obu algorytmach jest w zasadzie takie samo. Sprawdzamy, czy wartość modułu różnicy pomiędzy dwoma ostatnimi przybliżeniami pierwiastka jest mniejsza od zadanego minimum. Jeśli tak, obliczenia kończymy zwracając \(x_0\).

Obliczamy wartość funkcji w punkcie \(x_0\) i sprawdzamy, czy jest ona dostatecznie bliska zeru. Jeśli tak, zwracamy \(x_0\) i kończymy. Jeśli nie, za nowy przedział przyjmujemy tą część przedziału \({[a,b]}\) rozdzielonego przez \(x_0\), w której funkcja zmienia znak. Całą procedurę powtarzamy, aż do osiągnięcia pożądanego wyniku.


do podrozdziału  do strony 

Opis Algorytmu

Specyfikacja problemu

Dane wejściowe

\(f(x)\)

 		 –

 		 funkcja, której pierwiastek liczymy.
Musi spełniać warunki podane na
początku tego rozdziału.
\(a,b\)

 		 –

 		 punkty krańcowe przedziału
poszukiwań pierwiastka
funkcji \(f(x)\); \({a,b\in\mathbb{R}}\)

Dane wyjściowe

\(x_0\) – pierwiastek funkcji \(f(x)\)

Zmienne pomocnicze i funkcje

\(f_a\), \(f_b\), \(f_0\)
 		 –
 		 wartości funkcji odpowiedniow
punktach \(a\), \(b\), \(x_0\); \({fa, fb, f0\in\mathbb{R}}\).
\(x_1\)
 		 –
 		 przechowuje poprzednią wartość
przybliżenia \(x_0\)
\(\varepsilon_0\)
 		 –
 		 określa dokładność porównania
z zerem; \({\varepsilon_0 = 0{,}0000000001}\)
\(\varepsilon_x\)
 		 –
 		 określa dokładność wyznaczania
pierwiastka \(x_0\); \({\varepsilon_x = 0{,}0000000001}\)

Lista kroków

  K01: Czytaj \(a,b\)
  K02: \(f_a\leftarrow f(a);\; f_b\leftarrow f(b);\)
\(x_1\leftarrow a;\; x_0\leftarrow b\)
  K03: Jeśli \(f_a\cdot f_b > 0,\)
to pisz "Brak pierwiastka"
i zakończ
  K04: Dopóki \(|x_1 - x_0| > \varepsilon_x\):
wykonuj kroki K05 ... K08
K05:     \(x_1\leftarrow x_0\)
K06:     \(x_0\leftarrow a-f_a\cdot\dfrac{b-a}{f_b-f_a};\;f_0\leftarrow f(x_0)\)
K07:     Jeśli \(|f0| < \varepsilon_0,\)
    to idź do kroku K09
K08:     Jeśli \(f_a\cdot f_0 < 0,\)
    to \(b\leftarrow x_0;\; f_b\leftarrow f_0,\)
    inaczej  \(a\leftarrow x_0;\;f_a\leftarrow f_0\)
  K09: Pisz \(x_0\)
  K10: Zakończ

Schemat blokowy

Algorytm Regula Falsi jest bardzo podobny do algorytmu bisekcji. Zmiany zaznaczono na schemacie blokowym zielonym kolorem elementów.

Odczytujemy zakres poszukiwań pierwiastka danej funkcji. W zmiennych \(f_a\) i \(f_b\) umieszczamy wartość funkcji na krańcach tego zakresu. Inicjujemy \(x_1\) oraz \(x_0\), tak aby algorytm nie zatrzymał się przy pierwszym obiegu pętli.

Pierwszy test ma na celu sprawdzenie warunku różnych znaków wartości funkcji na krańcach przedziału \({[a,b].}\) Różne znaki gwarantują nam istnienie pierwiastka w danym zakresie. Jeśli funkcja na krańcach ma ten sam znak, wypisujemy odpowiedni komunikat i kończymy algorytm.

Rozpoczynamy pętlę wyliczania kolejnych przybliżeń pierwiastka funkcji. Pętla wykonywana jest do momentu, gdy dwa ostatnio obliczone pierwiastki różnią się o \(\varepsilon_x\).

Na początku pętli do \(x_1\) wprowadzamy poprzednio wyliczony pierwiastek i obliczamy nowy. Następne obliczamy wartość funkcji w \(x_0\) umieszczając ją w zmiennej \(f_0\). Sprawdzamy, czy wartość \(f_0\) jest dostatecznie bliska zeru (wpada w otoczenie zera o promieniu ε0), Jeśli tak, to przerywamy pętlę, co spowoduje wypisanie \(x_0\) i zakończenie algorytmu.

Za nowy przedział \({[a,b]}\) przyjmujemy tę część przedziału podzielonego przez \(x_0\), w której funkcja zmienia znak. Testujemy iloczyn \(f_a\) przez \(f_0\). Jeśli jest ujemny, to funkcja zmienia znak przyjmuje w \({[a,x_0]}\). Za nowy koniec \(b\) przyjmujemy \(x_0\) i kontynuujemy pętlę. W przeciwnym razie zmiana znaku występuje w \({[x_0,b]}\). Za nowy początek \(a\) przyjmujemy \(x_0\) i kontynuujemy pętlę. W obu przypadkach przepisujemy również \(f_0\) odpowiednio do \(f_a\) lub \(f_b\) w celu uniknięcia ponownych obliczeń wartości funkcji w nowych punktach krańcowych przedziału.


do podrozdziału  do strony 

Programy

Programy wyznaczają miejsce zerowe funkcji:

\[
f(x)=x^3\cdot\left(x+\sin(x^2-1)-1\right)-1
\]

Pierwiastków należy poszukiwać w przedziałach \({[-1;0]}\) i \({[1;2]}\).

C++
// Program znajduje miejsce
// zerowe funkcji f(x) za
// pomocą algorytmu
// regula falsi
// ------------------------
//  (C)2006 mgr J.Wałaszek

#include <iostream>
#include <iomanip>
#include <cmath>
#include <cstdlib>

using namespace std;

// dokładność porównania z zerem
const double EPS0 = 0.0000000001;
// dokładność wyznaczenia pierwiastka
const double EPSX = 0.0000000001;

// Funkcja, której miejsce
// zerowe obliczamy
// f(x) = x^3*(x+sin(x^2-1)-1)-1
// <-1,0> i <1,2>
double f(double x)
{
  return x * x * x *
         (x + sin(x * x - 1) - 1) - 1;
}

//---------------
// Program główny
//---------------

int main()
{
  double a,b,x0,x1,fa,fb,f0;

  cout << setprecision(8)
       << fixed
       << "Obliczanie pierwiastka funkcji\n"
          "za pomoca metody Regula Falsi\n"
          "f(x) = x^3*(x+sin(x^2-1)-1)-1\n"
          "------------------------------\n"
          "  (C)2006 mgr Jerzy Walaszek\n\n"
          "Podaj przedzial poszukiwan:\n\n";
  cout << "a = "; cin >> a;
  cout << "b = "; cin >> b;
  cout << "\nWYNIK:\n\n";
  fa = f(a);
  fb = f(b);
  x1 = a;
  x0 = b;
  if(fa * fb > 0) cout << "Brak pierwiastka\n";
  else
  {
    while(fabs(x1 - x0) > EPSX)
    {
      x1 = x0;
      x0 = a - fa * (b - a) / (fb - fa);
      f0 = f(x0);
      if(fabs(f0) < EPS0) break;
      if(fa * f0 < 0)
      {
        b = x0; fb = f0;
      }
      else
      {
        a = x0; fa = f0;
      }
    }
    cout << "x0 = " << setw(15) << x0 << endl;
  }
  cout << endl;
  system("pause");
  return 0;
}
Pascal
// Program znajduje miejsce
// zerowe funkcji f(x) za
// pomocą algorytmu
// Regula Falsi
// ------------------------
//  (C)2006 mgr J.Wałaszek

program mzf1;

uses math;

const
  // dokładność porównania z zerem
  EPS0 = 0.0000000001;
  // dokładność wyznaczenia pierwiastka
  EPSX = 0.0000000001;

// Funkcja, której miejsce zerowe obliczamy
// f(x) = x^3*(x+sin(x^2-1)-1)-1
// <-1,0> i <1,2>
function f(x : real) : double;
begin
  Result := x * x * x *
           (x + sin(x * x - 1) - 1) - 1;
end;

//---------------
// Program główny
//---------------

var
  a,b,x0,x1,fa,fb,f0 : double;

begin
  writeln('Obliczanie pierwiastka funkcji');
  writeln('za pomoca metody Regula Falsi');
  writeln('f(x) = x^3*(x+sin(x^2-1)-1)-1');
  writeln('------------------------------');
  writeln(' (C)2006 mgr Jerzy Walaszek');
  writeln;
  writeln('Podaj przedzial poszukiwan:');
  writeln;
  write('a = '); readln(a);
  write('b = '); readln(b);
  writeln;
  writeln('WYNIK:');
  writeln;
  fa := f(a);
  fb := f(b);
  x1 := a;
  x0 := b;
  if fa * fb > 0 then
    writeln('Brak pierwiastka')
  else
  begin
    while abs(x1 - x0) > EPSX do
    begin
      x1 := x0;
      x0 := a - fa * (b - a) / (fb - fa);
      f0 := f(x0);
      if abs(f0) < EPS0 then break;
      if fa * f0 < 0 then
      begin
        b := x0; fb := f0;
      end
      else
      begin
        a := x0; fa := f0;
      end;
    end;
    writeln('x0 = ',x0:15:8);
  end;
  writeln;
  writeln('Nacisnij Enter...');
  readln;
end.
Basic
' Program znajduje miejsce
' zerowe funkcji f(x) za
' pomocą algorytmu
' Regula Falsi
' ------------------------
'  (C)2006 mgr J.Wałaszek

Declare Function f(x As Double) _
                     As Double

' dokładność porównania z zerem
Const EPS0 As Double = 0.0000000001
' dokładność wyznaczenia pierwiastka
Const EPSX As Double = 0.0000000001

'---------------
' Program główny
'---------------

Dim As double a, b, x0, x1, fa, fb, f0

Print "Obliczanie pierwiastka funkcji"
Print "za pomoca metody Regula Falsi"
Print "f(x) = x^3*(x+sin(x^2-1)-1)-1"
Print "------------------------------"
Print "  (C)2006 mgr Jerzy Walaszek"
Print
Print "Podaj przedzial poszukiwan:"
Print
Input "a = ", a
Input "b = ", b
Print
Print "WYNIK:"
Print
fa = f(a)
fb = f(b)
x1 = a
x0 = b
If fa * fb > 0 Then
  Print "Brak pierwiastka"
Else
  While Abs(x1 - x0) > EPSX
    x1 = x0
    x0 = a - fa * (b - a) / (fb - fa)
    f0 = f(x0)
    If Abs(f0) < EPS0 Then Exit While
    If fa * f0 < 0 Then
      b = x0 : fb = f0
    Else
      a = x0 : fa = f0
    End If
  Wend
  Print Using "x0 = ######.########"; x0
End If

Print
Print "Nacisnij Enter..."
Sleep
End

' Funkcja, której miejsce
' zerowe obliczamy
' f(x) = x^3*(x+sin(x^2-1)-1)-1
' <-1,0> i <1,2>
Function f(x As Double) As Double
  Return x * x * x * _
        (x + Sin(x * x - 1) - 1) - 1
End Function
Python (dodatek)
# Program znajduje miejsce
# zerowe funkcji f(x) za
# pomocą algorytmu
# Regula Falsi
# ------------------------
#  (C)2006 mgr J.Wałaszek

import math

# Funkcja, której miejsce
# zerowe obliczamy
# f(x) = x^3*(x+sin(x^2-1)-1)-1
# <-1,0> i <1,2>
def f(x):
    return x * x * x * \
           (x+math.sin(x*x-1)-1)-1

# dokładność porównania z zerem
EPS0 = 0.0000000001
# dokładność wyznaczenia pierwiastka
EPSX = 0.0000000001

#---------------
# Program główny
#---------------

print("Obliczanie pierwiastka funkcji")
print("za pomocą metody Regula Falsi")
print("f(x) = x^3*(x+sin(x^2-1)-1)-1")
print("------------------------------")
print("  (C)2026 mgr Jerzy Wałaszek")
print()
print("Podaj przedział poszukiwań:")
print()
a = float(input("a = "))
b = float(input("b = "))
print()
print("WYNIK:")
print()
fa = f(a)
fb = f(b)
x1 = a
x0 = b
if fa * fb > 0:
    print("Brak pierwiastka")
else:
    while abs(x1 - x0) > EPSX:
        x1 = x0
        x0 = a-fa*(b-a)/(fb-fa)
        f0 = f(x0)
        if abs(f0) < EPS0: break
        if fa * f0 < 0:
            b, fb = x0, f0
        else:
            a, fa = x0, f0
    print("x0 = %15.8f" % x0)

print()
input("Naciśnij Enter...")
Wynik: 
Obliczanie pierwiastka funkcji
za pomocą metody Regula Falsi
f(x) = x^3*(x+sin(x^2-1)-1)-1
------------------------------
  (C)2026 mgr Jerzy Wałaszek

Podaj przedział poszukiwań:

a = 1
b = 2

WYNIK:

x0 =      1.18983299

Naciśnij Enter...
JavaScript
<html>
  <head>
  </head>
  <body>
<div style="overflow-x: auto; overflow-y: hidden;"
     align="center">
  <table
  border="0"
  cellpadding="4"
  style="border-collapse:
         collapse">
    <tr>
      <td nowrap>
        <form
        name="frmbincode"
        style="text-align: center;
               background-color:
               #E7E7DA;">
          <b><big>
          Obliczanie<br>
          pierwiastka funkcji<br>
          metodą Regula Falsi
          </big></b><br><br>
          f(x) = x<sup>3</sup>(x +
          sin(x<sup>2</sup>-1)-1)-1<br>
          <br>
          &nbsp;&nbsp;
          (C)2026
          mgr Jerzy Wałaszek
          I LO w Tarnowie
          &nbsp;&nbsp;
          <hr>
          Wpisz do pól edycyjnych<br>
          krańce przedziału<br>
          poszukiwań pierwiastka<br>
          <br>
          a = <input
              type="text"
              name="inp_a"
              size="16"
              value="1"
              style="text-align:
              right">
          <br>
          b = <input
              type="text"
              name="inp_b"
              size="16"
              value="2"
              style="text-align:
              right">
          <hr>
          <input
          type="button"
          value="Szukaj"
          name="B1"
          onclick="main()">
          <hr>
          <b>Wynik:</b>
          <div id="out">.</div>
        </form>
      </td>
    </tr>
  </table>
</div>

<script language=javascript>

// Program znajduje miejsce
// zerowe funkcji f(x)
// za pomocą algorytmu
// regula falsi
// ------------------------
//  (C)2006 mgr J.Wałaszek

// dokładność porównania z zerem
var EPS0 = 0.0000000001
// dokładność wyznaczenia
// pierwiastka
var EPSX = 0.0000000001

// Funkcja, której miejsce
// zerowe obliczamy
// f(x) = x^3*(x+sin(x^2-1)-1)-1
// <-1,0> i <1,2>
function f(x)
{
  return x*x*x*
        (x+Math.sin(x*x-1)-1)-1;
}

//---------------
// Program główny
//---------------

function main()
{
  var a,b,x0,x1,fa,fb,f0,t

  a = parseFloat(document
      .frmbincode.inp_a.value)
  b = parseFloat(document
      .frmbincode.inp_b.value)
  if(isNaN(a) || isNaN(b))
    t = "<font color=red><b>" +
        "Złe krańce zakresu " +
        "poszukiwań pierwiastka!" +
        "</b></font>"
  else
  {
    t  = "x<sub>o</sub> = "
    fa = f(a); fb = f(b)
    x1 = a; x0 = b
    if(fa * fb > 0)
      t = "<font color=red><b>" +
          "Brak pierwiastka" +
          "</b></font>"
    else
    {
      while(Math.abs(x1 - x0) > EPSX)
      {
        x1 = x0
        x0 = a - fa * (b - a) /
             (fb - fa)
        f0 = f(x0)
        if(Math.abs(f0) < EPS0)
          break
        if(fa * f0 < 0)
        {
          b = x0
          fb = f0
        }
        else
        {
          a = x0
          fa = f0
        }
      }
      t += x0
    }
  }
  t = "<nobr>" + t + "</nobr>"
  document.getElementById("out")
  .innerHTML = t
}

</script>
  </body>
</html>

Tutaj możesz przetestować działanie prezentowanego skryptu. Pierwiastków należy poszukiwać w przedziałach \({[-1;0]}\) i \({[1;2]}\).

Obliczanie
pierwiastka funkcji
metodą Regula Falsi

f(x) = x3(x + sin(x2-1)-1)-1

   (C)2026 mgr Jerzy Wałaszek I LO w Tarnowie   
Wpisz do pól edycyjnych
krańce przedziału
poszukiwań pierwiastka

a =
b =
Wynik:
.

do podrozdziału  do strony 
Zespół Przedmiotowy
Chemii-Fizyki-Informatyki
w I Liceum Ogólnokształcącym
im. Kazimierza Brodzińskiego
w Tarnowie
ul. Piłsudskiego 4
©2026 mgr Jerzy Wałaszek

Materiały tylko do użytku dydaktycznego. Ich kopiowanie i powielanie jest dozwolone pod warunkiem podania źródła oraz niepobierania za to pieniędzy.
Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl
Serwis wykorzystuje pliki cookies. Jeśli nie chcesz ich otrzymywać, zablokuj je w swojej przeglądarce.
Informacje dodatkowe.