News Contents

Toplam 3 İlan Bulundu

Nesneye yönelik analiz - HW1_LinearSolverDeluxe

 

Gaussian Elimination Method Matrix Inversion Method
package com.aydincalikoglu.LinearSolverDeluxeService.impl;

import com.aydincalikoglu.LinearSolverDeluxeService.Solver;

import java.util.*;
import java.util.List;
import java.util.stream.Collectors;

import static java.lang.Math.abs;

/**
* Created by Aydın on 11.10.2018.
*/
public class GaussianElimination implements Solver {
private List<List<Double>> katSayilar;
private List<Double> sabitler;
private List<Double> x = new ArrayList<Double>();

/**
* Kat sayılar ile aldığı sabitleri Gaus Elimination yöntemi ile hesaplar ve sonuçları verir.
* @param katSayilar
* @param sabitler
* @return ArrayList olarak X değerlerini döndürür.
*/
private List<Double> calculate(List<List<Double>> katSayilar, List<Double> sabitler)
{
this.katSayilar=katSayilar;
this.sabitler = sabitler;
pivotlama(0,0);
if (!controlDiagonal(0)) {
System.out.println(“it couldnt calculate because there is 0 in diagonal of the matrix after GausElimanation“);
return null;
}
else
{
BackSubstitution();

}
return x;
}

/**
* Hesaplanmış olan üst üçgensel matrisi üzerinde, en alt x değerlerinden başlayarak tüm x değerlerini hesaplar.
*/
private void BackSubstitution()
{
int j=sabitler.size()-2;
for (int i = sabitler.size()-1; i >-1 ; i--) {
double sonuc=sabitler.get(i);
int l=0;
for (int k = sabitler.size()-1; k >j ; k--) {
if (l<x.size()) {
sonuc-=katSayilar.get(i).get(k)*x.get(l);
l++;
}
else
x.add(sonuc/katSayilar.get(i).get(k));
}
j--;
}
reverseListX();
}

/**
* Recursive Köşegen Matris kontrolü
* @param index
* @return Köşeğen matris ise true değerini verir.
*/
private boolean controlDiagonal(int index)
{
if (index==sabitler.size()) {
return true;
}
if (katSayilar.size()<index)
return false;
// Köşegen Matris kontrolü
if (katSayilar.get(index).get(index)==0) {
return false;
}
return controlDiagonal(index+1);
}

/**
* Maksimum pivotları tekrar hesaplamamak için dinamik bir yapı kullanılmıştır.
*/
private ArrayList<Double> maxPivot = new ArrayList<>();

/**
* Büyük Sayıların olduğu pivotları matris üzerinde en üste taşıyarak, Bölmelerde minumum hata payı elderek
* Her Satirda Gauss elimination yöntemini kullanılmıştır.
* @param col
* @param row
*/
private void pivotlama(int col,int row)
{
// Büyük Sayıların olduğu pivotları en üste taşıyarak, Bölmelerde minumum hata payı elde etmeye çalışıyoruz.
if (row==sabitler.size()-1) {
return;
}
double rowMaxNum=0;
int maxValueRowIndex=0;
for (int i = row; i < katSayilar.size(); i++) {
double colMaxNum=abs(katSayilar.get(i).get(col));
for (int j = col+1; j < katSayilar.get(i).size(); j++) {
double ColumnValue=abs(katSayilar.get(i).get(j));
if (colMaxNum<ColumnValue)
{
colMaxNum=ColumnValue;
}
}
if (row!=0) {
colMaxNum = maxPivot.get(i);
}
else
maxPivot.add(colMaxNum);

colMaxNum=abs(katSayilar.get(i).get(col))/colMaxNum;
if (rowMaxNum<colMaxNum) {
rowMaxNum=colMaxNum;
maxValueRowIndex=i;
}
}

// Kat sayılarda ve sabitlerde yer değiştirme
if (katSayilar.get(maxValueRowIndex).get(col)!=0) {
List<Double> tempAr=katSayilar.get(row);
katSayilar.set(row, katSayilar.get(maxValueRowIndex));
katSayilar.set(maxValueRowIndex, tempAr);
double tempSon=sabitler.get(row);
sabitler.set(row, sabitler.get(maxValueRowIndex));
sabitler.set(maxValueRowIndex, tempSon);
}
gaussElimination(col,row);
pivotlama(col+1,row+1);
}

/**
* Matris içerisinde verilen satır ve sütun sonrasındaki tüm satırları pivot elemanlarına bölerek üst üçgensel bir matrise yakınlaştırır.
* @param col
* @param row
*/
private void gaussElimination(int col,int row)
{
for (int i = row+1; i < katSayilar.size(); i++) {
if(katSayilar.get(i).get(row)==0)
continue;
double kat=katSayilar.get(i).get(row)/katSayilar.get(row).get(row);
for (int j = col; j < katSayilar.get(i).size(); j++) {
katSayilar.get(i).set(j, katSayilar.get(i).get(j)-(katSayilar.get(row).get(j)*kat));
}
sabitler.set(i,sabitler.get(i)-sabitler.get(row)*kat);
}
}

/**
* Kat sayılar matrisi ve sabitler matrisini ekrana yazdırır.
*/
public void printMatries()
{
for (int i = 0; i < katSayilar.size(); i++) {
for (int j = 0; j < katSayilar.get(i).size(); j++) {
System.out.printf(“%.4f “,katSayilar.get(i).get(j));
}
System.out.printf(“= %.4f
“,sabitler.get(i));
}
System.out.println();
}

@Override
public String toString() {
return x.stream().map(i -> System.out.format(“%.2f“,i).toString()).collect(Collectors.joining(System.lineSeparator()));
}

/**
* Hesaplanmış olan X değerlerini ekrana yazdırır.
*/
public void printAllX()
{
for (int i = 0; i < x.size(); i++) {
System.out.printf(“x%d: %.4f “,i+1,x.get(i));
}
System.out.println();
}

/**
* x değerlerini doğru sırayla listeye eklenmesi için reverse alınır.
*/
private void reverseListX()
{
if (x.size()==0)
return;
double temp=x.get(0);
x.remove(0);
reverseListX();
x.add(temp);
}

@Override
public List<Double> solveMatris(List<List<Double>> katSayilar, List<Double> sabitler) {
return calculate(katSayilar,sabitler);
}
}
package com.aydincalikoglu.LinearSolverDeluxeService.impl;

import com.aydincalikoglu.LinearSolverDeluxeService.Solver;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.DoubleStream;

import static java.lang.Math.abs;

public class InverseMatrixMethod implements Solver {
@Override
public List<Double> solveMatris(List<List<Double>> katSayilar, List<Double> sabitler) {
return calculate(katSayilar, sabitler);
}

private List<Double> calculate(final List<List<Double>> katSayilar, List<Double> sabitler)
{
List<List<Double>> a = katSayilar;
List<Double> b = sabitler;

List<List<Double>> inverseA = inverse(a);
List<Double> result = multiply(inverse(a), b);

System.out.println(“The inverse is: “);
for (int i=0; i<inverseA.size(); ++i)
{
for (int j=0; j<inverseA.size(); ++j)
{
System.out.print(inverseA.get(i).get(j) +“ “);
}
System.out.println();
}

return result;
}

private double determinant(List<List<Double>> matris) {
if (matris.size() == 2)
return matris.get(0).get(0) * matris.get(1).get(1) - matris.get(0).get(1) * matris.get(1).get(0);

double det = 0;
for (int i = 0; i < matris.get(0).size(); i++) {
det += Math.pow(-1, i) * matris.get(0).get(i)
* determinant(minor(matris, 0, i));
}
return det;
}

public List<List<Double>> inverse(List<List<Double>> matris) {
List<List<Double>> inverseMatrix = new ArrayList<>();
// Minor ve kofaktor hesaplama
for (int i = 0; i < matris.size(); i++) {
inverseMatrix.add(new ArrayList<>());
for (int j = 0; j < matris.get(i).size(); j++) {
inverseMatrix.get(i).add(Math.pow(-1, i + j) * determinant(
minor(matris, i, j)));
}
}
double det = 1.0 / determinant(matris);
for (int i = 0; i < inverseMatrix.size(); i++) {
for (int j = 0; j <= i; j++) {
double temp = inverseMatrix.get(i).get(j);
inverseMatrix.get(i).set(j, inverseMatrix.get(j).get(i) * det);
inverseMatrix.get(j).set(i, temp * det);
}
}
return inverseMatrix;
}

private List<List<Double>> minor(List<List<Double>> matris, int row, int col) {
Double[][] minor = new Double[matris.size() - 1][matris.size() - 1];
for (int i = 0; i < matris.size(); i++)
for (int j = 0; i != row && j < matris.get(i).size(); j++)
if (j != col)
minor[i < row ? i : i - 1][j < col ? j : j - 1] = matris.get(i).get(j);
List<List<Double>> result = new ArrayList<>();
for(Double[] array : minor){
List<Double> list = Arrays.asList(Arrays.stream(array).toArray( Double[]::new ));
result.add(list);
}
return result;
}

private List<Double> multiply(List<List<Double>> a, List<Double> b) {
List<Double> result = new ArrayList<>();
for (int i = 0; i < a.size(); i++) {
double sum = 0;
for (int k = 0; k < a.get(i).size(); k++)
sum += a.get(i).get(k) * b.get(k);
result.add(sum);
}
return result;
}
}

Show More Devamı
Tüm Yorumlar - All Comments

#include void Operationsfonk(){ printf("Welcome
"); printf("[1] Triangle
"); printf("[2] Rhomboid
"); printf("[3] Circle
"); printf("[4] Exit
"); printf("Select a Shape: "); } void traingleDrawer(){ int h,i,y=1,j,s=0,a; printf("Enter triangle height:"); scanf("%d",

Show More Devamı
Tüm Yorumlar - All Comments

def compareScales(leftScaleList, rightScaleList):

  result = sum(leftScaleList) - sum(rightScaleList)    

  if result < 0:        

    return 1    

  elif result > 0:        

    return -1    

  else:        

    return 0

 

 

def WalnutsBinarySearch(walnuts,index):

  size = len(walnuts)

  half=(int)(size/2)

 

  if(size<2):

    return index

 

  if size%2==1: # Size tek ise ortaki elemana bakma

    if walnuts[half+1]>walnuts[half]:

      return half

    elif walnuts[half+1]<walnuts[half]:

      return half+1

    walnutsRight = walnuts[half+1:]

  else:

    walnutsRight = walnuts[half:]

  walnutsLeft = walnuts[0:half]

 

  durum = compareScales(walnutsLeft,walnutsRight)

  if durum == 0:

    return -1

  elif durum == 1:

    return WalnutsBinarySearch(walnutsLeft,index)

  else:

    return WalnutsBinarySearch(walnutsRight,index+half+size%2)

 

walnuts= [1,1,1,1,0.5,1,1,1,1]

print(WalnutsBinarySearch(walnuts,0))

Show More Devamı
Tüm Yorumlar - All Comments