<file_sep>package mathdemo;

public class MathDemo {
    public static void main(String[] args) {
        System.out.println("Примеры вызова функций:");
// Вычисление экспоненты:
        System.out.println("exp(1)="+ MyMath.Exp(1,30));
// Вычисление синуса:
        System.out.println("sin(pi)="+ MyMath.Sin(Math.PI,100));
// Вычисление косинуса:
        System.out.println("cos(pi/2)="+ MyMath.Cos(Math.PI/2,100));
// Вычисление функции Бесселя:
        System.out.println("J0(mu1)="+ MyMath.BesselJ(2.404825558,100));
// Заполнение массивов коэффициентов рядов Фурье для функции y(x)=x:
        int m=1000;
        double[] a=new double[m];
        double[] b=new double[m+1];
        b[0]= MyMath.L/2;
        for(int i=1;i<=m;i++){
            a[i-1]=(2*(i%2)-1)*2* MyMath.L/Math.PI/i;
            b[i]=-4*(i%2)* MyMath.L/Math.pow(Math.PI*i,2);}
// Вычисление функции y(x)=x через синус-ряд Фурье:
        System.out.println("2.0->"+ MyMath.FourSin(2.0,a));
// Вычисление функции y(x)=x через косинус-ряд Фурье:
        System.out.println("2.0->"+ MyMath.FourCos(2.0,b));

        System.out.println("Tan: "+ MyMath.Tan(1,30));
        System.out.println("CoTan: "+ MyMath.CoTan(1,30));
        System.out.println("Sqrt: "+ MyMath.sqrt(3, 3));
        System.out.println("Pow: "+ MyMath.Pow(2,4));

    }
}
<file_sep>public class Vehicle {
    private String speed;
    private String model;
    private String ovnerName;
    private String movingVector;

    Vehicle(String model, String ovnerName, String speed, String movingVector){
        this.speed = speed;
        this.model = model;
        this.ovnerName = ovnerName;
        this.movingVector = movingVector;
    }

    private String getSpeed(){
        return speed;

    }

    private String getOvnerName(){
        return ovnerName;

    }

    private String getMovingVector(){
        return movingVector;

    }

    private String getModel(){
        return model;

    }

    public String toString(){
        return "Venicle: "+getModel()+" Ovner: "+getOvnerName()+" Moving speed: "+getSpeed()+" Moving vector: "+getMovingVector();
    }

}
<file_sep>package mathdemo;

class MyMath {
    // Класс с математическими функциями:
// Интервал разложения в ряд Фурье:
    static double L=Math.PI;
    // Экспонента:
    static double Exp(double x,int N){
        int i;
        double s=0,q=1;
        for(i=0;i<N;i++){
            s+=q;
            q*=x/(i+1);
        }
        return s+q;
    }
    // Синус:
    static double Sin(double x,int N){
        int i;
        double s=0,q=x;
        for(i=0;i<N;i++){
            s+=q;
            q*=(-1)*x*x/(2*i+2)/(2*i+3);
        }
        return s+q;
    }
    // Косинус:
    static double Cos(double x,int N){
        int i;
        double s=0,q=1;
        for(i=0;i<N;i++){
            s+=q;
            q*=(-1)*x*x/(2*i+1)/(2*i+2);
        }
        return s+q;
    }
    // Функция Бесселя:
    static double BesselJ(double x,int N){
        int i;
        double s=0,q=1;
        for(i=0;i<N;i++){
            s+=q;
            q*=(-1)*x*x/4/(i+1)/(i+1);
        }
        return s+q;
    }
    // Ряд Фурье по синусам:
    static double FourSin(double x,double[] a){
        int i,N=a.length;
        double s=0;
        for(i=0;i<N;i++){
            s+=a[i]*Math.sin(Math.PI*x*(i+1)/L);
        }
        return s;}
    // Ряд Фурье по косинусам:
    static double FourCos(double x,double[] a){
        int i,N=a.length;
        double s=0;
        for(i=0;i<N;i++){
            s+=a[i]*Math.cos(Math.PI*x*i/L);
        }
        return s;
    }

    static double Tan(double x, int N){
        return Sin(x,N)/Cos(x,N);
    }

    static double CoTan(double x, int N){
        return Cos(x,N)/Sin(x,N);
    }

    static double sqrt(double value, int decimalPoints)
    {
        int firstPart=0;


        /*calculating the integer part*/
        while(square(firstPart)<value)
        {
            firstPart++;
        }

        if(square(firstPart)==value)
            return firstPart;
        firstPart--;

        /*calculating the decimal values*/
        double precisionVal=0.1;
        double[] decimalValues=new double[decimalPoints];
        double secondPart=0;

        for(int i=0;i<decimalPoints;i++)
        {
            while(square(firstPart+secondPart+decimalValues[i])<value)
            {
                decimalValues[i]+=precisionVal;
            }

            if(square(firstPart+secondPart+decimalValues[i])==value)
            {
                return (firstPart+secondPart+decimalValues[i]);
            }

            decimalValues[i]-=precisionVal;
            secondPart+=decimalValues[i];
            precisionVal*=0.1;
        }

        return(firstPart+secondPart);

    }

    private static double square(double val)
    {
        return val*val;
    }

    static double Pow(double pVal, int pPow){
            double res = 1;
            double v1, v2;
            int n = pPow;
            v1 = pVal;
            if ((n & 1) == 1) {
                res = pVal;
            }
            n = n >>> 1;
            while (n > 0) {
                v2 = v1 * v1;
                if ((n & 1) == 1) {
                    res = res * v2;
                }
                v1 = v2;
                n = n >>> 1;
            }
            return res;
    }
}

<file_sep>import java.util.*;

public class Lab1 {

    public static void main(String[] args) {
        System.out.println("Lab1");
        System.out.println("ex1:");
        ex1();
        System.out.println("ex2:");
        ex2();
        System.out.println("ex3:");
        ex3();
        System.out.println("ex4:");
        ex4();
        System.out.println("ex5:");
        ex5();
        System.out.println("ex6:");
        ex6();
    }
/*1. Дан массив из целых чисел A(n), где n=1…25. Напишите метод класса, позволяющий менять
местами его максимальный и минимальный элемент.
*/
    private static void ex1(){
        ArrayList<Integer>A=generateArray(25);
        System.out.println(A);
        int maxInd = A.indexOf(Collections.max(A));
        int minInd = A.indexOf(Collections.min(A));
        Integer max = Collections.max(A);
        Integer min = Collections.min(A);
        A.set(maxInd, min);
        A.set(minInd, max);
        System.out.println(A);
    }

/*2. Дан массив из целых чисел B(n), где n известное, но произвольное целое число до 1000.
Напишите метод класса, позволяющий упорядочить массив по возрастанию. Алгоритм
упорядочения выберите самостоятельно.
*/
    private static void ex2(){
        ArrayList<Integer>B=generateArray(1000);
        System.out.println(B);
        Collections.sort(B);
        System.out.println(B);
    }

/*3. Дан массив из целых чисел С(n), где n=1…20. Напишите метод класса, позволяющий найти
среднее значение элементов массива и вывести его на консоль.*/
    private static void ex3(){
        ArrayList<Integer>C=generateArray(20);
        System.out.println(C);
        System.out.println(C.stream().mapToInt((x) -> x).average());
    }

/*4. Дан массив из целых чисел D(n), где n=1…30. Напишите метод класса, позволяющий найти
сумму четных и нечетных элементов массива.
*/
    private static void ex4(){
        Integer sumEven = 0, sumOdd = 0, sum1, sum2;
        ArrayList<Integer>D=generateArray(30);
        System.out.println(D);

        for (Integer integer : D) {
            sum1 = (integer % 2 == 0) ? integer : 0;
            sumEven += sum1;
        }
        System.out.println(sumEven);

        for (Integer integer : D) {
            sum2 = !(integer % 2 == 0) ? integer : 0;
            sumOdd += sum2;
        }
        System.out.println(sumOdd);

    }

/*5. Напишите программу, выводящую на консоль таблицу размером 3×5 случайных элементов
(a(i,j) < 10).
*/
    private static void ex5(){

        print(matrixCreation(3,5));
    }

/*6. Задается пять строк s1, s2, s3, s4 и s5. Напишите метод класса, работающий на основе
следующего условия: если строка s4 равна строке s5, нужно выполнить конкатенацию строк s1 и
s2, иначе нужно выполнить конкатенацию строк s1 и s3.
*/
    private static void ex6(){
        String s1="abcd", s2="1234", s3="ABCD", s4="zxcv", s5="zxcv";
        //String s1="abcd", s2="1234", s3="ABCD", s4="zxcv", s5="ZX12";
        System.out.println("s1: "+s1);
        System.out.println("s2: "+s2);
        System.out.println("s3: "+s3);
        System.out.println("s4: "+s4);
        System.out.println("s5: "+s5);
        if(s4.equals(s5))
            System.out.println("Concat "+s1+s2);
        else
            System.out.println("Concat "+s1+s3);
    }

    static ArrayList<Integer> generateArray(Integer n){
        ArrayList<Integer> numbers = new ArrayList<>(Collections.emptyList());
        for (int i = 0; i < Math.random()*n; i++) {
            numbers.add((int) Math.round((Math.random() * n)));
        }
        return numbers;
    }

    static void print(int[][] puzzle) {
        for (int[] row : puzzle) {
            for (int elem : row) {
                System.out.printf("%4d", elem);
            }
            System.out.println();
        }
        System.out.println();
    }

    static void print(double[][] puzzle) {
        for (double[] row : puzzle) {
            for (double elem : row) {
                System.out.printf("%8.3f", elem);
            }
            System.out.println();
        }
        System.out.println();
    }

    static int[][] matrixCreation(int m, int n){
        int[][] numbers = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                numbers[i][j]=((int) Math.round((Math.random() * 9)));
            }
        }
        return  numbers;
    }

}

