Настройка массива комплексных коэффициентов, избегая начальных нулей

Я создал класс для комплексных чисел:

public class Complex {
    private double x;   //Real part x of the complex number x+iy.
    private double y;   //Imaginary part y of the complex number x+iy.

     public Complex(double x, double y) {   //Constructor: Initializes x, y.
        this.x=x;
        this.y=y;
    }

    public Complex(double x) { //Real constructor - initialises with a real number.
        this(x, 0.0);
    }

    public Complex() {   //Default constructor; initialiase x and y to zero.
        this(0.0, 0.0);
    }
}

Что я хотел бы сделать, так это создать функцию Polynomial, которая будет принимать массив коэффициентов и фильтровать его так, чтобы, например, [1,0,0,1,0,0,0,0,0...] , он вернет массив длины 4. Поскольку оставшиеся нули не используются в многочлене.

Вот как будет выглядеть сложный массив

Complex [] coeff = new Complex [] {
    new Complex(-1.0 ,0.0), new Complex(),
    new Complex() , new Complex(1.0, 0.0)
};

Многочлен будет определен как

Polynomial p = new Polynomial(coeff);

Вот постановка задачи:

введите здесь описание изображения

Вот как должен выглядеть многочлен, если ввести комплексные коэффициенты массива

Вот как должен выглядеть многочлен, если ввести комплексные коэффициенты массива

Я думал о построении алгоритма, который ищет первый ноль нулевой последовательности (то есть до конца массива), а затем удаляет нули.

Также я думал инвертировать записи массива, чтобы [0,1,1,0,1,0,0,0] было [0,0,0,1,0,1,1,0] и затем создайте функцию, которая начнет «записывать» мой новый массив с первой нетривиальной записи.

Как бы я пошел с созданием такой функции?

Моя попытка для этого:


   int j=0;
        for(int i=coeff.length-1; i>=0; i-=1)
        {    
            if(coeff[i].getReal()== 0 && coeff[i].getImag() == 0 ){
                 j=+1;     
            }
            else {
                break;
            }

        }

        int a = coeff.length-j;    
        this.coeff = new Complex[a];
        for (int i=0;i<this.coeff.length;i+=1){
            this.coeff[i]=coeff[i];     
        }
     }

И, например, я хотел бы напечатать:

Complex a1=new Complex(-3, 1);
        Complex a2=new Complex(2, 0.3);
        Complex a3=new Complex(); 
        Complex b=new Complex(); 
        Complex[] com=new Complex[] {a1,b, a2, a3,b};

и вывод:


(-3.0+1.0i)+ (0.0+0.0i)X^1+(2.0+0.3i)X^2+(0.0+0.0i)X^3

Но предполагается:

(-3.0+1.0i)+ (0.0+0.0i)X^1+(2.0+0.3i)X^2

И я попытался добавить «-1» к int a = coeff.length-j; :

int a = coeff.length-j-1;

но если я распечатаю


Complex[] com=new Complex[] {a1,b, a2, a3,b,b,b,b,b,b};

Это даст мне те же результаты (т.е. сохранение тривиальных коэффициентов).

Как я могу заставить конструктор не хранить эти тривиальные коэффициенты?


java numbers math polynomials polynomial-math
person The Poor Jew    schedule 26.02.2020    source источник

Ответы (2)


arrow_upward
2
arrow_downward

Я думаю, что способ войти сюда - это перебрать массив от конца к началу, как вы пытались. Проблема с вашим кодом заключается в следующем:

if(coeff[i].getReal()== 0 && coeff[i].getImag() == 0 ){
                 j=+1;     //Here! I think you wanted to do j+=1
            }

При выполнении j=+1 вы делаете j всегда равным 1. Таким образом, изменение j=+1 на j+=1 исправит это.

Кроме того, я сделал другой код, если вы хотите его проверить. В конце он делает то же самое, но я думаю, что он чище.

public class Polynomial {

    private Complex[] coeff; 

    public Polynomial(Complex[] coeff) {
        this.coeff = cleanCoeff(coeff);
    }

    private Complex[] cleanCoeff(Complex[] coeff) {
        int length = coeff.length;
        Complex complex = null;
        for (int i = coeff.length - 1; i >= 0 ; i--) {
            complex = coeff[i];
            if(complex.getX() == 0 && complex.getY() == 0) {
                length--; 
            }else {
                break;
            }
        }
        return Arrays.copyOf(coeff, length);

    }

    public Complex[] getCoeff() {
        return coeff;
    }
}

Я надеюсь, что этот ответ поможет вам.

person diego riveros    schedule 14.03.2020

arrow_upward
1
arrow_downward

Это можно сделать относительно легко, используя что-то вроде следующего:

int effective_len(Complex coeff[]) {
  int pos = 0;
  Complex zero();

  for (int i=0; i<coeff.lengh; i++) {
    if (!zero.equals(coeff[i])) {
      pos = i;
    }
  }

  return pos + 1;
}

Для этого вам нужно будет определить метод equals, где вы просто проверяете действительные и мнимые компоненты, но это должно привести вас туда, куда вам нужно.

person andand    schedule 26.02.2020