Facebook
From owczar, 3 Months ago, written in Java.
Embed
Download Paste or View Raw
Hits: 55
  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.List;
  4. import java.util.Scanner;
  5.  
  6. import static java.lang.Math.pow;
  7.  
  8. public class Wielomian {
  9.  
  10.  
  11.     public  Wielomian () {
  12.         // wprowadzanie wspolczynnikow
  13.         System.out.println("Wprowadz wspolczynniki wielomianu:");
  14.         List<Integer> wspolczynniki = new ArrayList<Integer>();
  15.         Scanner scan = new Scanner(System.in);
  16.         while (scan.hasNextInt()) {
  17.             wspolczynniki.add(scan.nextInt());
  18.         }
  19.         // tworzenie list licznikow i mianownikow
  20.         List<Integer> licznik = new ArrayList<Integer>();
  21.         List<Integer> mianownik = new ArrayList<Integer>();
  22.         int b = 0;
  23.         // zeby wspolcznynnik b nie byl ujemny bo petle bedziemy wykonywac tyle razy ile x0 wynosi zeby znalesc pierwiastek
  24.         if (wspolczynniki.get(wspolczynniki.size() - 1) <= 0) {
  25.             b = wspolczynniki.get(wspolczynniki.size() - 1) * -1;
  26.                                                                                                                          //PRINT System.out.println(" b <=0" +  b);
  27.         // wspolczynik b
  28.         } else {
  29.             b = wspolczynniki.get(wspolczynniki.size() - 1);
  30.                                                                                                                          //PRINT System.out.println(" b else" +  b);
  31.         }
  32.         for (int i = 1; i <= b; i++) {
  33.             if (b % i == 0) {
  34.                                                                                                                          //PRINT System.out.println(" Licznik b % i ==0 " +  b % i + " b= " + b + " i= " + i);
  35.                 // dodajemy i oraz -i bo root moze byc o roznych znakach
  36.                 licznik.add(i);
  37.                 licznik.add(-i);
  38.                
  39.             }
  40.         }
  41.         // do b przypisujemy liczbe stojaca przed najwyzsza potega
  42.         if (wspolczynniki.get(0) <= 0) {
  43.             b = wspolczynniki.get(0) * -1;
  44.                                                                                                                           //PRINT System.out.println(" wspolczynniki(0) <=0  b= " +  b);
  45.         } else {
  46.             b = wspolczynniki.get(0);
  47.                                                                                                                           //PRINT System.out.println(" wspolczynniki(0) else  b= " +  b);
  48.         }
  49.         for (int i = 1; i <= b; i++) {
  50.             if (b % i == 0) {
  51.                                                                                                                           //PRINT System.out.println("Mianownik  b % i ==0 " +  b % i + " b= " + b + " i= " + i);
  52.                 mianownik.add(i);
  53.             }
  54.         }
  55.  
  56.         // tworzenie listy wspolcznnikow od konca
  57.         List<Integer> odkonca = new ArrayList<Integer>();
  58.         for(int i=wspolczynniki.size()-1; i>=0; i--){
  59.             odkonca.add(wspolczynniki.get(i));
  60.         }
  61.         // tworzenie listy pierwiastkow postaci [ licznik, mianownik, krotnosc,    licznik, mianownik, krotnosc ..]
  62.         List<Integer> pierwiastki = new ArrayList<Integer>();
  63.         // petla ktora dla dla wszystkich wartosci licznika i mianownika sprawdza krotnosc pierwiastka
  64.         //
  65.         for (int i = 0; i < mianownik.size(); i++) {
  66.             int m = mianownik.get(i);
  67.             for (int j = 0; j < licznik.size(); j++) {
  68.                 int l = licznik.get(j);
  69.                                                                                                                           //PRINT System.out.println("mianownik = " + m + " licznik = "+ l);
  70.                 // jesli pierwiastek o danym liczniku i mianowniku zeruje wialomian to przechodzimy dalej
  71.                 if (Pierwiastek(odkonca, l, m)) {
  72.                     if (((float) l / (float) m) % 1 == 0) {
  73.                         // gdy pierwiastek nie jest ulamkowy to l jest licznikiem a mianownikiem jest 1 i zapisujemy to do listy pierwiastki
  74.                         pierwiastki.add(l / m);
  75.                         pierwiastki.add(1);
  76.                                                                                                                           //PRINT System.out.println(" if pierwiastki = " + pierwiastki);
  77.                     } else {
  78.                         // gdy pierwiastek jest ulamkowy to l jest licznikiem a mianownikiem jest m i zapisujemy to do listy pierwiastki
  79.                         pierwiastki.add(l);
  80.                         pierwiastki.add(m);
  81.                                                                                                                           //PRINT System.out.println("else pierwiastki = " + pierwiastki);
  82.                     }
  83.                     List<Integer> zeruj = new ArrayList<Integer>();
  84.                 // wspolczynniki a po wywolaniu Hornera, opisane przy  funkcji Horner na dole
  85.                     zeruj = Horner(wspolczynniki, l, m);
  86.                                                                                                                           //PRINT System.out.println("zeruj po wywolaniu Horner " + zeruj);
  87.                     int k = 0;
  88.                 // zerujemy tak dlugo az da sie wyzerowac go pierwiastku o danym liczniku l i mianowniku m
  89.                 // ( czyli jesli ostatni element w liscie zeruj jest rowny 0
  90.                 // do k przypisujemy jego krotnosc ile razy dalo sie zredukowac wielomian o tym pierwiastku
  91.                     while (zeruj.get(zeruj.size() - 1) == 0) {
  92.                         k += 1;
  93.                         // usuwamy wspolczynniku z zeruj oprocz najwyzej potegi i ponawiamy hornerem zeby sprawdzic krotnosc
  94.                         zeruj.remove(zeruj.size() - 1);
  95.                         zeruj = Horner(zeruj, l, m);
  96.                     }
  97.                     pierwiastki.add(k);
  98.                                                                                                                           //PRINT System.out.println("pierwiastki krotnosc  " + pierwiastki);
  99.                 }
  100.             }
  101.         }
  102.  
  103.         System.out.println("Pierwiastki wielomianu:");
  104.         for (int i = 0; i < pierwiastki.size() - 1; i += 3) {
  105.                 // jesli ulamek (czyli mianownik nie jest 1 ) wypisz licznik i mianownik (ulamek) i jego krotnosc
  106.             if (pierwiastki.get(i + 1) != 1) {
  107.                 System.out.println(pierwiastki.get(i) + "/" + pierwiastki.get(i + 1) + " :  " + pierwiastki.get(i + 2) + "-krotny");
  108.             }
  109.                 // jesli liczba calkowita wypisz licznik i jego krotnosc  
  110.             else {
  111.                 System.out.println(pierwiastki.get(i) + " :  " + pierwiastki.get(i + 2) + "-krotny");
  112.             }
  113.         }
  114.     }
  115.         // funkcja sprawdza czy dany pierwiastek o danym liczniku 'l' i mianowniku 'm' po wstawieniu jako "x" daje wartosc 0
  116.     public boolean Pierwiastek(List wielomian, int l, int m){
  117.         int spr = 0;
  118.         int max_pot = wielomian.size() - 1;
  119.         for(int i=0; i<wielomian.size(); i++){
  120.                
  121.             int licznik = (int) wielomian.get(i) * (int) pow(l,i) * (int) pow(m,max_pot);
  122.                
  123.             max_pot-=1;
  124.             spr+=licznik;
  125.  
  126.         }
  127.         return spr == 0;
  128.     }
  129.         // funkcja ktora wykonuje metode Hornera, czyli  dla danej liczby obniza stopien wielomianu
  130.         // przykladowo dla wielomianu 1x^3 - 7x^2 + 16x - 12 (x -2)^2(x-3)
  131.         // pierwsze redukowanie bedzie wygladac tak: dla l=2
  132.         // a=1 do nowa dodajemy wynik odejmowania -5, a=-5 nowa=6, a=6 nowa=0. l=2 jest pierwiastkiem
  133.         // drugie redukowanie bedzie dla wielomianu 1x^2 -5x +6
  134.         // a=1 nowa=-3, a=-3 nowa=0
  135.     public List<Integer> Horner(List wiel, int l, int m){
  136.         List<Integer> nowa = new ArrayList<Integer>();
  137.         nowa.add( (int) wiel.get(0));
  138.         int p = 1;
  139.         for(int i=1; i<wiel.size(); i++) {
  140.             int a = nowa.get(nowa.size() - 1);
  141.                                                                                                                              //PRINT System.out.println("a" + " " + a);
  142.             nowa.add((int) ((l * a) + ((int) wiel.get(i) * pow(m, p))));
  143.             p += 1;
  144.         }
  145.         return nowa;
  146.     }
  147.  
  148.  
  149.  
  150.  
  151.  
  152.  
  153.  
  154.     public static void main(String[] args){
  155.         Wielomian w = new Wielomian();}
  156. }