Ramazan Bellek

Quadtree ile Hızlandırılmış Geometrik Arama

2013-12-31T21:43:00.000+02:00

Bir çok problemin çözümünde geometrik çözümlerden istifade edilebilir. Geometrik çözüm, bir meseleyi geometrik perspektif vasıtasıyla çözmektir, velev ki problemimiz doğrudan geometrik olarak tanımlanmış olmasın. Biraz daha açarsak, doğrudan geometrik olarak tanımlanmış problemlere örnek vermek gerekirse, kapalı bir sistemde hareket eden hava moleküllerinin bulunduğu kap yüzeyiyle ve birbirleriyle olan çarpışma testlerinin yapılması olabilir. Doğrudan geometrik olarak tanımlanmayan problemlere ise bir cemiyetteki insanların birbiriyle olan münasebetlerinin mevcut skaler veriler üzerinden geometrik yorumlama vasıtasıyla tespit edilmesi olabilir. İster doğrudan ister yorumlama vasıtasıyla olsun geometrik hale gelen verilerde en büyük problem hızlı bir şekilde arama yapabilmektir. Arama ile kastedilen işlem, belirli bir bölgedeki veyahut belirli bir noktanın belirli bir mesafedeki komşularının tespitidir. Bu işlemi gerçekleştirmek için akla ilk gelen çözüm en ilkel hali ile zorlama yöntemidir (brute-force). Bu yöntemde tahmin edebileceğiniz gibi aranan noktaların bulunması için tüm noktalar sırayla taranır ve referans noktamıza olan uzaklığına bakılır. Bu usul her zaman doğru sonuca kati suretle varacaktır, fakat muhtemelen en uzun yoldan, zira muhtemel olsun olmasın tüm noktaları taradık ve maliyeti azami tuttuk.

İnsan zihni bu problemi çözerken aslında çok da fazla zorlanmaz, zira sezgilerindeki gelişmişlik arama uzayında orta kısımda bulunan bir referans noktası için yapacağımız komşu aramasını gidipte çok uzaklarda aramaz, doğrudan ilgili kısma bakar. Fakat bilgisayar sistemlerinde genelde durum böyle değildir, veriler hafızada karışık bir sırayla tutulmaktadır (genelde üretim sırasına göre). Bu yüzden hangi nokta hangi noktaya ne kadar yakın bunu verinin geliş sırasında anlamak mümkün değildir. İşte hızlandırma tam da bu noktada mümkün olmaktadır. Aslında hızlandırma yöntemlerinde yapılan genel olarak düzensiz veriyi daha düzenli bir hale getirmekten ibarettir. Meseleyi daha iyi idrak etmek için doğrudan kullanacağımız veriyapısını detaylandıralım. Quadtree veri yapısı alsında bir çeşit ağaç yapısıdır. 2 boyutlu uzayda geçerli olmak üzere bir kök düğümden başlayarak her düğüm 4 alt düğüme ayrılmaktadır. Bu bölümleme kapsadığı noktalardan bağımsız olarak 4 eşit parçaya bölme şeklinde gerçekleşir. Nokta ihtiva eden düğümlere yaprak denmektedir. Bizim tasarımımızda bir yaprakta en fazla 1 nokta mevcut olabilir. Tarama işlemi ise, tıpkı ağacı oluşturduğumuz gibi, aradığımız nokta mevcut düğümün sol (alt-üst) ya da sağ (alt-üst) kısımlarından hangisine ait ise o bölgedeki alt ağacı tarayarak devam ediyoruz, böylelikle yakınlık ihtimali olmayan diğer bölgelerdeki noktaları devre dışı bırakmış ve bu yükten kurtulmuş oluyoruz, aynı insanın sezgisel olarak yaptığı gibi. Örnek ağaçlara bir göz atalım:

Veriyapısı ve algoritma hakkında daha detaylı bilgi için: http://en.wikipedia.org/wiki/Quadtree

Amacım algoritmayı tam anlamıyla anlatmak değil, sadece bir gerçekleme örneği sağlamak. Bu sebeple daha fazla detaylandırmak istemiyorum. Gerçekleme için C++ dili ve görselleştirme için OpenGL kütüphanesini kullandım. Performans arttırımı için dar boğaz olan dinamik bellek ayrımı (dynamic memory allocation) için bir iyileştirme gerçekleştirdim, fakat bu iyileştirmenin çalışabilmesi için maksimum nokta sınırının belirlenmesi gerekiyor, bu bilinmiyorsa daha farklı bir usul geliştirilebilir veya bu iyileştirme kaldırılabilir. Eğer kararlılık (stability) sizin için daha önemli ise bu iyileştirmeyi kaldırmanızı veya gözden geçirmenizi tavsiye ederim, zira bazı durumlarda (nokta yoğunlaşması gibi) hatalarla karşılaştım ayrıca aynı anda birden fazla ağaç üretmesine mani oluyor (no multiple instance).

Not: Nokta tanımında açık kaynak kodlu ve ücretsiz temin edilebilen GTL (https://code.google.com/p/geometry/) kütüphanesinden istifade ettim.

/*
 * Point.h
 *
 *  Created on: Oct 24, 2013
 *      Author: ramazan
 */

#ifndef POINT_H_
#define POINT_H_

#include <gtl/vec2.hpp>
#include <gtl/vec3.hpp>

#include "Utility.h"
#include <algorithm>

using namespace gtl;

class Point {
public:
 Point() {
  color.setValue(0, 0, 1);
  location.setValue(randomFloat() * SCREEN_WIDTH, randomFloat() * SCREEN_HEIGHT);
 }

 void walk() {
  location += Vec2f(randomSignedFloat() * 30, randomSignedFloat() * 30);
  location[0] = std::max(location[0], 0.f);
  location[0] = std::min(location[0], (float)SCREEN_WIDTH);

  location[1] = std::max(location[1], 0.f);
  location[1] = std::min(location[1], (float)SCREEN_HEIGHT);
 }

 Vec2f location;
 Vec3f color;
};


#endif /* POINT_H_ */

/*
 * Utility.h
 *
 *  Created on: Oct 24, 2013
 *      Author: ramazan
 */

#ifndef UTILITY_H_
#define UTILITY_H_

#include <stdlib.h>
#include <stdio.h>

#define SCREEN_WIDTH 800
#define SCREEN_HEIGHT 600

#define THREESHOLD 0.000001
#define PARMEQ(x, y) (fabs(x - y) <= THREESHOLD)

static inline float randomFloat() {
 return (float)rand()/(float)RAND_MAX;
}

static inline float randomSignedFloat() {
 const float r = randomFloat();
 return r - 0.5f;
}


#endif /* UTILITY_H_ */

#ifndef QUADTREE_H_
#define QUADTREE_H_

#include <assert.h>
#include <vector>

#include "Point.h"

// You can remove all optimization lines together. 

#define MAX_POINT_CAPACITY 1000000 // Optimization line!

class QuadNode {
public:
 QuadNode() {
  leaf = true;
  point = NULL;
  children[0] = children[1] = children[2] = children[3] = NULL;
 }

 ~QuadNode() {
  for (int i = 0; i < 4; i++) {
   QuadNode *child = children[i];
   if (child != NULL)
    delete child;
  }
 }

 void insert(const Point &point) {
  if (leaf && this->point == NULL) {
   this->point = &point;
  }
  else {
   makeChild(-1, -1);
   makeChild(-1, 1);
   makeChild(1, -1);
   makeChild(1, 1);

   QuadNode *node = NULL;

   if (leaf) {
    const Point *thisPoint = this->point;
    this->point = NULL;
    node = findChild(*thisPoint);
    node->insert(*thisPoint);
   }

   node = findChild(point);
   node->insert(point);

   leaf = false;
  }
 }

 void query(const Vec2f &center, const float radius, std::vector<const Point *> &points) {
  const float absDX = fabs(center[0] - this->center[0]);
  const float absDY = fabs(center[1] - this->center[1]);

  if (absDX <= (halfSize[0] + radius) && absDY <= (halfSize[1] + radius)) {
   if (point != NULL) {
    Vec2f disn = point->location - center;
    const float dist = disn.length();

    if (dist <= radius)
     points.push_back(point);
   }
   else {
    for (int i = 0; i < 4; i++) {
     QuadNode *child = children[i];
     if (child != NULL)
      child->query(center, radius, points);
    }
   }
  }
 }

 void render() {
  const Vec2f p0 = center + Vec2f(-halfSize[0], halfSize[1]);
  const Vec2f p1 = center + Vec2f(-halfSize[0], -halfSize[1]);
  const Vec2f p2 = center + Vec2f(halfSize[0], -halfSize[1]);
  const Vec2f p3 = center + Vec2f(halfSize[0], halfSize[1]);

  glColor3f(1, 0, 0);
  glBegin(GL_LINES);
  glVertex2fv(p0.getValue());
  glVertex2fv(p1.getValue());

  glVertex2fv(p1.getValue());
  glVertex2fv(p2.getValue());

  glVertex2fv(p2.getValue());
  glVertex2fv(p3.getValue());

  glVertex2fv(p3.getValue());
  glVertex2fv(p0.getValue());
  glEnd();

  for (int i = 0; i < 4; i++) {
   QuadNode *child = children[i];
   if (child != NULL)
    child->render();
  }
 }
private:
 int makeChild(const float dX, const float dY) {
  int index = -1;
  float newX = halfSize[0] / 2;
  float newY = halfSize[1] / 2;
  if (dX < 0) {
   newX = -newX;
   if (dY < 0) {
    index = 1;
    newY = -newY;
   }
   else
    index = 0;
  } else {
   if (dY < 0) {
    index = 2;
    newY = -newY;
   }
   else
    index = 3;
  }

  verifyChild(index, center + Vec2f(newX, newY));

  return index;
 }
 QuadNode *findChild(const Point &point) {
  const float dX = point.location[0] - center[0];
  const float dY = point.location[1] - center[1];

  return children[makeChild(dX, dY)];
 }

 void verifyChild(const int index, const Vec2f newCenter) {
  assert(index >= 0 && index <= 3);

  if (children[index] == NULL) {
   children[index] = new QuadNode();
   assert(children[index] != NULL);
   children[index]->center = newCenter;
   children[index]->halfSize = halfSize / 2;
  }
 }

private:
 static char memory[]; // Optimization line!
 static int memoryIndex; // Optimization line!

public:
 void *operator new(size_t size) { // Optimization line!
  assert(memoryIndex < MAX_POINT_CAPACITY); // Optimization line!
  return &memory[memoryIndex++ * size]; // Optimization line!
 } // Optimization line!

 void operator delete(void *p) { // Optimization line!
  p = NULL; // Optimization line!
 } // Optimization line!

public:

 // 0 3
 // 1 2
 QuadNode *children[4];
 const Point *point;
 Vec2f center;
 Vec2f halfSize;
 bool leaf;
};

int QuadNode::memoryIndex = 0; // Optimization line!
char QuadNode::memory[sizeof(QuadNode) * MAX_POINT_CAPACITY] = { }; // Optimization line!

class Quadtree {
public:
 Quadtree(const Vec2f &center, const float w, const float h) {
  root = new QuadNode();
  root->center = center;
  root->halfSize.setValue(w / 2, h / 2);
 }

 ~Quadtree() {
  if (root != NULL) {
   delete root;
  }
 }

 void insert(const Point &point) {
  assert(root != NULL);

  root->insert(point);
 }

 void render() {
  assert(root != NULL);
  root->render();
 }

 void query(const Vec2f &center, const float radius, std::vector<const Point *> &points) {
  assert(root != NULL);

  root->query(center, radius, points);
 }

 QuadNode *root;
};


#endif /* QUADTREE_H_ */

// main.cpp

#include <iostream>
#include <glut\\glut.h>
#include <time.h>

#include "Quadtree.h"

#define RENDER_WAIT_TIME 25
#define NUMBER_OF_POINTS 30000

using namespace std;

Point *points = NULL;
Quadtree *qt;

Vec2f qCenter(300, 400);
float radius = 100;

void display(void) {
    glClear(GL_COLOR_BUFFER_BIT);
    glLoadIdentity();

    glBegin(GL_POINTS);
    for (int i = 0; i < NUMBER_OF_POINTS; i++) {
     glColor3fv(points[i].color.getValue());
     glVertex2fv(points[i].location.getValue());
    }
    glEnd();

    glColor3f(0, 1, 0);
    glBegin(GL_LINES);
    for (int i = 0; i < 360; i++) {
     Vec2f p1 = qCenter + Vec2f(cos((i * M_PI / 180.f)) * radius, sin((i * M_PI / 180.f)) * radius);
     Vec2f p2 = qCenter + Vec2f(cos(((i + 1) * M_PI / 180.f)) * radius, sin(((i + 1) * M_PI / 180.f)) * radius);
     glVertex2fv(p1.getValue());
     glVertex2fv(p2.getValue());
    }
    glEnd();

    if (qt != NULL)
     qt->render();

    //glFlush();
    glutSwapBuffers();
}

void mouse(int btn, int state, int x, int y) {
    //if(btn==GLUT_LEFT_BUTTON && state == GLUT_DOWN) axis = 0;
}

void search() {
 if (qt == NULL)
  return;
 std::vector<const Point *> qpoints;
    qt->query(qCenter, radius, qpoints);

    std::cout<<qpoints.size()<<std::endl;
    for (int i = 0; i < NUMBER_OF_POINTS; i++) {
  points[i].color.setValue(0, 0, 1);
     for (unsigned int j = 0; j < qpoints.size(); j++) {
      if (&points[i] == qpoints[j])
       points[i].color.setValue(0, 1, 0);
     }
    }
}

void mainLoop(int value) {
    glutPostRedisplay();
    glutTimerFunc(RENDER_WAIT_TIME, mainLoop, 0);
}

void build() {
 qt = new Quadtree(Vec2f(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2), SCREEN_WIDTH, SCREEN_HEIGHT);
    for (int i = 0; i < NUMBER_OF_POINTS; i++)
     qt->insert(points[i]);
}

void keyPressed(unsigned char key, int x, int y) {
    if (key == 'x')
        exit(0);

 if (key == 'w')
  qCenter += Vec2f(0, 10);

 if (key == 's')
  qCenter += Vec2f(0, -10);

 if (key == 'a')
  qCenter += Vec2f(-10, 0);

 if (key == 'd')
  qCenter += Vec2f(10, 0);

 if (key == 'r') {
  for (int i = 0; i < NUMBER_OF_POINTS; i++)
   points[i].walk();
  build();
 }

 search();
}

void myReshape(int w, int h) {
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0f, 800, 0, 600, 1.0f, -1.0f);
    glMatrixMode(GL_MODELVIEW);
}

void keySpecial(int key, int x, int y) {
    if (key == GLUT_KEY_F4)
        exit(0);
}

void init() {
    glShadeModel(GL_FLAT);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glPointSize(3);

    points = new Point[NUMBER_OF_POINTS];
 //points[0].location.setValue(100, 100);
 //points[1].location.setValue(110, 120);
 //points[2].location.setValue(105, 105);
 build();
 search();
}

int main(int argc, char** argv) {
    srand(time(NULL));
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowSize(SCREEN_WIDTH, SCREEN_HEIGHT);
    glutCreateWindow("Quadtree");
    glutReshapeFunc(myReshape);
    glutDisplayFunc(display);
    glutKeyboardFunc(keyPressed);
    glutSpecialFunc(keySpecial);
    init();
    glutTimerFunc(RENDER_WAIT_TIME, mainLoop, 0);
    glutMouseFunc(mouse);
    glutMainLoop();
    return 0;
}

Bir kaç deneme yapalım:

10 adet nokta

100 adet nokta

5000 adet nokta

30000 adet nokta

Bu bölümde 2 boyutlu düzlem üzerindeki geometrik problemlerin çözümünde kullanılan arama işlemini hızlandıran bir veriyapısını inceledik. Aynı veri yapısı 3 boyutlu uzayda da uygulanabilir (Octree - http://en.wikipedia.org/wiki/Octree). Mantık olarak aynı yalnızca 4 yerine 8 eşit parçaya ayrılmaktadır. Performans değerlendirmesini zaman cinsinden değerleri belirterek yapmak istemiyorum, kullandığım bilgisayar üzerinde brute-force yöntemine göre tahmin edebileceğiniz gibi (beklendiği üzere) çok büyük oranda hızlanma sağladı. Bunu kendi probleminize uygulayarak görebilirsiniz. Basit düzeyde anlatmaya çalıştım, umarım işinize yarar.

Yapay Sinir Ağları İleri Besleme & Geri Yayılım Algoritmaları - XOR Örneği

2012-11-24T16:13:00.000+02:00

http://scitechdaily.com/ibm-supercomputer-simulates-530-billion-neurons-100-trillion-synapses/

IBM'in yapmış olduğu çalışmanın haberini okuduktan sonra yapay zeka meselesi hakkında küçük bir yazı yazmaya karar verdim. Tabiki haberdeki çalışmaya nazaran bizim yapacağımız örnek çok iptidai kalmaktadır. Lakin buradaki maksadım bir şekilde meseleye giriş yapmak bilahare daha gelişmiş örneklerle konuyu izah etmek şeklinde olacaktır.

Yapay zeka çok geniş bir kavram ve bir çok alt dalları bulunmaktadır (bkz: http://en.wikipedia.org/wiki/List_of_basic_artificial_intelligence_topics). Ben burada giriş mahiyetinde Yapay Sinir Ağları (bkz: http://en.wikipedia.org/wiki/Artificial_neural_network) hususunda ileri besleme (Feed forward bkz: http://en.wikipedia.org/wiki/Feedforward_neural_network) ve geri yayılım (bkz: http://en.wikipedia.org/wiki/Back-propagation) algoritmalarını kullanarak artık klasikleşmiş ve tabiri caizse bıktırmış olan XOR örneğini gerçekleyeceğim.

Yukarıda verdiğim bağlantılara göz atarsanız algoritmanın nasıl çalıştığını kolayca anlayabilirsiniz. Bu noktada fazla bir teferruat icap etmiyor zira yapacağımız örnekteki XOR problemi 2 neron hidden layer için 1 neron da output layer için kafidir. Mühim bir not; biz bu örnekte BIAS değerini tüm neronlara ayrı ayrı vermek yerine bir kukla neron (dummy neuron, ağırlıkları ve çıktısı değişmeyen) kullanacağız.

Biraz gerçekleme (implementation) detaylarına göz atalım.

Uygulamayı Java ile yapacağız. Aslınca C gibi bir dil ile çok daha basit ve hızlı bir şekilde gerçeklenebilirdi lakin müstakbel uygulamalarımızda yapacağımız muameleler daha karmaşık olacağından bu yapı ileride bize fayda sağlayacaktır, şu anda aksi gibi görünse dahi.

Temel olarak Object-Oriented yapı:

Neuron (Class)
NN (Class)
IActivation (Interface)
SigmoidActivation (Class) -> IActivation
DummyActivation (Class) -> IActivation

Başlamdan önce belirlenmesi gereken ilk husus neronların ilk ağırlık değerleridir, burada önceden çalıştığı bilinen bir küme de seçilebilir ya da sözde rastgele değerlerde seçilebilir, neticede kötü seçilen değerler sadece sonuca ulaşma süremizi uzatacaktır. Biz rastgele değerler üreteceğiz bu yüzden programı her çalıştırdığınızda farklı bekleme süreleri ile karşılacaksınız. Ayrıca eğitim sürecinde iterasyon sayısını bir hudut koyuyoruz çünkü bazı durumlarda gelen değerler deltaW değeri sıfıra çok yaklaştığı için istenilen değere (desired value) bir türlü yaklaşılamıyor ve çok bekleme yaşanıyor. Bu sebeple azami tekerrür 3.000.000 olarak seçiyoruz, beklenen hata nispetini ise 0.005 olarak seçtim. Bu değerler tamamen keyfi olup siz de istediğiniz gibi değiştirebilirisiniz.

Kaynak kodda herhangi bir dış kütüphane kullanmadım, doğrudan derleyip çalıştırabilisiniz.

Şimdi kaynak kodumuza bir göz atalım:

// Main.java

package ann.xor;

/**
 *
 * @author ramazan
 */
public class Main {

    public static String quantizeResult(float result) {
        return Integer.toString(Math.round(result)) + " (" + Float.toString(result) + ")";
    }
    
    public static void main(String[] args) {
        NN nn = new NN(5E-3f, 1.0f, 0.1f);
        SigmoidActivation sa = new SigmoidActivation();
        DummyActivation da = new DummyActivation();
        float BIAS = -1f;

        Neuron input1 = new Neuron(da, 0);
        Neuron input2 = new Neuron(da, 0);
        Neuron input3 = new Neuron(da, 0); // BIAS.
        Neuron hidden1 = new Neuron(sa, 3);
        Neuron hidden2 = new Neuron(sa, 3);
        Neuron hidden3 = new Neuron(da, 3); // Dummy neuron.
        Neuron output1 = new Neuron(sa, 3);

        nn.addInputNeuron(input1);
        nn.addInputNeuron(input2);
        nn.addInputNeuron(input3);

        nn.addHiddenNeuron(hidden1);
        nn.addHiddenNeuron(hidden2);
        nn.addHiddenNeuron(hidden3);

        nn.addOutNeuron(output1);

        hidden3.setDummy(true);
        input3.setOutput(BIAS);

        System.out.println("All inputs & weights has been set.");
        System.out.println("Training has been started.");
        
        int iteration = 0;
        do {
            iteration++;
            
            input1.setOutput(0);
            input2.setOutput(0);
 
            output1.desired = 0;

            nn.train();

            input1.setOutput(0);
            input2.setOutput(1);

            output1.desired = 1;

            nn.train();

            input1.setOutput(1);
            input2.setOutput(0);

            output1.desired = 1;

            nn.train();

            input1.setOutput(1);
            input2.setOutput(1);

            output1.desired = 0;

            nn.train();
            
            if (iteration % 50000 == 0) {
                System.out.println("-------------------------------");
                System.out.println("Current iteration:" + iteration);
                System.out.println("Current error:" + nn.getE());
                System.out.println("-------------------------------");
            }
        } while(!nn.learnt() && iteration < 3000000);
        
        System.out.println("Training has been completed.");
        System.out.println("Total iteration: " + iteration + ", accepted error: " + nn.getE());
        System.out.println("Test cases are in progress...");
        
        input1.setOutput(1);
        input2.setOutput(0);

        nn.test();

        System.out.println("1 XOR 0 = " + quantizeResult(nn.getOutput(0).getOutput()));

        input1.setOutput(1);
        input2.setOutput(1);

        nn.test();

        System.out.println("1 XOR 1 = " + quantizeResult(nn.getOutput(0).getOutput()));

        input1.setOutput(0);
        input2.setOutput(1);

        nn.test();

        System.out.println("0 XOR 1 = " + quantizeResult(nn.getOutput(0).getOutput()));

        input1.setOutput(0);
        input2.setOutput(0);

        nn.test();

        System.out.println("0 XOR 0 = " + quantizeResult(nn.getOutput(0).getOutput()));
    }
}

// NN.java

package ann.xor;

import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author ramazan
 */
public class NN {
   
    private List<neuron> inputLayer;
    private List<neuron> hiddenLayer;
    private List<neuron> outputLayer;
    private float E;
    private float e;
    private float lambda;
    private float nu;
    
    public NN(float E, float lambda, float nu) {
        inputLayer = new ArrayList<>();
        hiddenLayer = new ArrayList<>();
        outputLayer = new ArrayList<>();
        this.E = E;
        e = 0;
        this.lambda = lambda;
        this.nu = nu;
    }
    
    public void addInputNeuron(Neuron neuron) {
        inputLayer.add(neuron);
    }
    
    public void addHiddenNeuron(Neuron neuron) {
        hiddenLayer.add(neuron);
    }
    
    public void addOutNeuron(Neuron neuron) {
        outputLayer.add(neuron);
    }
    
    public Neuron getOutput(int index) {
        return outputLayer.get(index);
    } 
    
    public void train() {
        feedForward();
        calculateError();
        backPropagation();
        //System.out.println("Error value: " + e);
    }
    
    public void test() {
        feedForward();
    }
    
    protected void feedForward() {
        for (Neuron nH : hiddenLayer) {
            float inputs = 0;
            for (Neuron nI : inputLayer) {
                int i = inputLayer.indexOf(nI);
                inputs += nI.getOutput() * nH.getWeight(i);
            }
            nH.setInput(inputs);
            nH.activate(lambda);
        }
        
        for (Neuron nO : outputLayer) {
            float inputs = 0;
            for (Neuron nH : hiddenLayer) {
                int i = hiddenLayer.indexOf(nH);
                inputs += nH.getOutput() * nO.getWeight(i);
            }
            nO.setInput(inputs);
            nO.activate(lambda);
        }
    }
    
    protected void calculateError() {
        e = 0;
        for (Neuron nO : outputLayer) {
            nO.error = nO.desired - nO.getOutput();
            e += (float) Math.pow(nO.error, 2);
        }
        
        e = (float)Math.sqrt(e); 
    }
    
    protected void backPropagation() {
        for (Neuron nO : outputLayer) {
            nO.calculateDelta(lambda, nO.error);
            for (Neuron nH : hiddenLayer) {
                int i = hiddenLayer.indexOf(nH);
                nH.calculateDelta(lambda, nO.getDelta() * nO.getWeight(i));
                float diff = nu * nO.getDelta() * nH.getOutput();
                nO.setWeight(i, nO.getWeight(i) + diff);
            }
        }
        
        for (Neuron nH : hiddenLayer) {
            for (Neuron nI : inputLayer) {
                int i = inputLayer.indexOf(nI);
                float diff = nu * nH.getDelta() * nI.getOutput();
                nH.setWeight(i, nH.getWeight(i) + diff);
            }
        }
    }

    public float getE() {
        return e;
    }
    
    public boolean learnt() {
        return (e < E);
    }
}

// Neuron.java

package ann.xor;

import java.util.Random;

/**
 *
 * @author ramazan
 */
public class Neuron {

    private float[] weights;
    private float input;
    private float output;
    private IActivation activation;
    private float delta;
    public float desired;
    public float error;
    private boolean dummy;
    private static final Random random = new Random();

    public Neuron(IActivation activation, int weights) {
        this.weights = new float[weights];
        this.activation = activation;
        delta = 0;
        dummy = false;
        error = desired = 0;
        
        for (int i = 0; i < weights; i++) {
            this.weights[i] = getRandomWeight();
        }
    }
    
    protected final float getRandomWeight() {
        final float r = random.nextFloat();
        final float range = 2.4f / weights.length;

        return (r * 2 * range) - range;
    }

    public float getWeight(int index) {
        return weights[index];
    }

    public void setWeight(int index, float weight) {
        if (!dummy) {
            weights[index] = weight;
        }
    }

    public float getInput() {
        return input;
    }

    public void setInput(float input) {
        this.input = input;
    }

    public float getOutput() {
        return output;
    }

    public void setOutput(float output) {
        this.output = output;
    }

    public float getDelta() {
        return delta;
    }

    public boolean isDummy() {
        return dummy;
    }

    public void setDummy(boolean dummy) {
        this.dummy = dummy;
    }
    
    public void activate(float lambda) {
        float value = input;
        if (!dummy) {
            value *= -lambda;
        }
        output = activation.activate(value);
    }

    public void calculateDelta(float lambda, float error) {
        if (!dummy) {
            delta = error * lambda * activation.derivative(output);
        }
    }
}

// IActivation.java

package ann.xor;

/**
 *
 * @author ramazan
 */
public interface IActivation {
    public float activate(float input);
    public float derivative(float input);
}

// SigmoidActivation.java

package ann.xor;

/**
 *
 * @author ramazan
 */
public class SigmoidActivation implements IActivation {

    @Override
    public float activate(float input) {
        return (float) (1. / (1. + Math.exp(input)));
    }

    @Override
    public float derivative(float input) {
        return input * (1 - input);
    }
    
}

// DummyActivation.java

package ann.xor;

/**
 *
 * @author ramazan
 */
public class DummyActivation implements IActivation {

    @Override
    public float activate(float input) {
        return input;
    }

    @Override
    public float derivative(float input) {
        return input;
    }
}

Şimdi örnek bir çıktı üretelim:

run:
All inputs & weights has been set.
Training has been started.
-------------------------------
Current iteration:50000
Current error:0.02354227
-------------------------------
-------------------------------
Current iteration:100000
Current error:0.014160486
-------------------------------
-------------------------------
Current iteration:150000
Current error:0.011045283
-------------------------------
-------------------------------
Current iteration:200000
Current error:0.009226563
-------------------------------
-------------------------------
Current iteration:250000
Current error:0.008103463
-------------------------------
-------------------------------
Current iteration:300000
Current error:0.0073397583
-------------------------------
-------------------------------
Current iteration:350000
Current error:0.006666307
-------------------------------
-------------------------------
Current iteration:400000
Current error:0.00628476
-------------------------------
-------------------------------
Current iteration:450000
Current error:0.0058559924
-------------------------------
-------------------------------
Current iteration:500000
Current error:0.0055325483
-------------------------------
-------------------------------
Current iteration:550000
Current error:0.0051981094
-------------------------------
Training has been completed.
Total iteration: 586265, accepted error: 0.004999997
Test cases are in progress...
1 XOR 0 = 1 (0.9973595)
1 XOR 1 = 0 (0.004999945)
0 XOR 1 = 1 (0.9919734)
0 XOR 0 = 0 (0.0039330246)
BUILD SUCCESSFUL (total time: 4 seconds)

Bu basit örnek ile konuyu teorik olarak okuduktan sonra pratik olarak uygulamasını görerek daha iyi anlaşılacağı kanaatindeyim. Bir sonraki yazıda, yine klasikleşmiş olan tanıma (recognition) uygulamalarından bir örnek yapabilirim veyahut farklı bir anlada mesela Multi-agent systems simulation bir çalışma olabilir. Henüz karar vermedim. :)

Umarım faydalı olmuştur, böylelikle uzunca bir aradan sonra yazı yazabilmenin huzuruyla sizlere veda ediyorum, Allah'a emanet olunuz...

IREM Oyun Motoru Çalışması - Rapor 1

2011-04-14T01:40:00.017+03:00

Herkese merhaba,

bu yazımda bitirme projesi olarak yaptığımız IREM Oyun Motoru projesinden bahsetmek istiyorum. Bu projeyi üniversite lisans bitirme projesi olarak toplam 4 kişilik bir ekip ile yapıyoruz. Profesyonel düzeyde bir proje olduğunu söyleyemem, fakat elimizden geldiğince gelişime açık bir tasarım ve esnek bir kodlama yapmaya çalışıyoruz. Proje henüz sonuçlanmadı fakat dönem sonuna doğru yaklaştıkça zaman kısıtı yüzünden projeyi bir noktada sınırlayıp nihayete erdirmek zorundayız. Gelin şuan ki aşamaya kadar neler yaptığımıza bir göz atalım.

Teknik Alt Yapı ve Sınırlar
C++ programlama dili üzerinden kodlamayı gerçekleştirdik. Grafik arayüzü olarak Microsoft DirectX API kullandık. Proje dahilinde singleton, façade, strategy, abstract factory vb. tasarım desenleri uygulandı. Networking, AI (yapay zeka), 3d sound, shader effects (HLSL) gibi modüllerin yalnızca tanımlaması yapıldı gerçeklenmedi. İleriki aşamalarda mevcut kod değiştirilmeden rahatlıkla bu modüller gerçeklenebilir. Fiziksel etkileşim yalnızca çarpışma testi ve parçacık dinamiği üzerinden gerçeklendi.

Teknik Üst Yapı ve Tasarım
Geliştirdiğimiz oyun motorunun temel fikri; yaklaşık olarak %90 seviyesinde nesne yönelimli, kolay programlanabilir, anlaşılır ve çevik (agile) geliştirmeye açık bir tasarım sağlamaktır. Bu yüzden inceledeğim bir çok modern oyun motorlarından da esinlenerek birbiriyle alakası olmayan tüm işlemleri ayırarak kendi aralarında bir yönetici sınıf atadım. Bu yönetici sınıflar singleton tasarım şablonu ile yalnız ve tek bir adet üretilerek çok başlılık sorununa mahal vermeden işlem yapmaktadır. Bu noktada sizlerle daha projenin ilk aşamalarında şekillendirmek adına çıkarttığım sınıf tasarımını paylaşmak istiyorum. İsterseniz tasarıma bir göz atalım, böylelikle kurgu kafamızda biraz daha somutlaşacaktır, daha sonra detaylı incelemeye devam edelim.

Buradaki bazı sınıfın yapısı değişmiş ve yine burada belirtmediğim bir çok yeni sınıf eklenmiş olsa da sistemin genel mantığını ifade ettiğini düşünüyorum.

Çekirdek uygulamanın yanında ek olarak pencere yöneticisi (window manager) ve arazi üreticisi (terrain generator) gibi araçlar geliştirdik. Bunlar programcıya hız kazandıracak araçlardır.

Son Durum & Karşılaştığımız Sorunlar
Gelelim şuanda projenin ne aşamada olduğu ve ne gibi sorunlarla karşılaştığımız kısmına. Projede şu anda çekirdek sınıf vasıtasıyla bir oyun işlemi başlatıp, sahne yöneticisi sınıfı vasıtasıyla istediğimiz sayıda birbirinden bağımsız sahneler üretebiliyoruz. Bu sahneler arasında gecikme olmaksızın anlık geçişler yapabiliyoruz. Çizdirilebilir nesne sayısı çok fazla olduğundan yavaşlayan bir sahne diğer bir sahneyi etkilememektedir. Sahneye eklediğimiz nesneleri kök düğüme ya da alt düğümlerine bağlayabiliyoruz. Böylelikle nesneleri grup olarak hareket ettirebiliyoruz. Kamera, ışık, model ve sabit nesneler sahneye eklebilmektedir. Uygulama başlatılmadan önce ayar penceresi gösterilerek seçilen ayarlar bir akış üzerinden kaydedilip okunabilmektedir.

Bir kaç model ile oyun motorunun işlevsel sınamalarından bir kare.

Karşılaştığımız başlıca teknik sorun kurduğumuz yapıyı sürekli yeniden değiştirme gereği duymamızdır. Daha önce tecrübe edinmediğimiz için modern yapıları inceledikçe yeni yöntemler keşfedip, kendi projemizdeki eski yapıları atma ihtiyacı duyuyoruz. Sosyal açıdan en büyük sorun ekip çalışmasının getirdiği zorluklar olarak tarif edebilirim.

Geleceğe Dair Planlar
Projeye ileriki aşamalarda yapmak istediğim eklemeleri şu şekilde sıralayabilirim:

- OpenGL desteği ile platform bağımsız tasarıma geçerek MacOS X, Linux, BSD, iPhone OS, PlayStation 3 gibi sistemlerde çalışmasını sağlamak.
- Çok kanallı programlama desteği sağlamak
- Shader desteği
- Gerçek zamanlı 3D model ve sahne düzenleme aracı
vs..

Bir sonraki yazımda da projemizdeki yenilikleri ve gelişmeleri sizlerle paylaşmaya devam edeceğim. Esen kalın efendim...

Güvenlik ve Güvenilirlik Kavramları

2011-03-16T21:39:00.004+02:00

Bilişim dünyasında genellikle karıştırılarak birbiri yerine kullanılan bu iki terimden kısaca bahsetmek istiyorum.

- Güvenlik (Security) Nedir?
Bilişimde güvenlik terimi, bir sistemin ihtiva ettiği bilginin veyahut sahip olduğu yetkilerin sistemin izni olmadan yetkisiz bir kişi ya da sistem tarafından kullanılmasının önüne geçilmesi olarak tarif edilebilir. Bunu sağlayamayan programlarda "Güvenlik açığı vardır" denir.

- Güvenilirlik (Reliability) Nedir?
Bilişimde güvenilirlik terimi, bir sistemin sürekliğinin ve kararlılığının her koşulda ve zamanda mutlak suretle sağlanmasıdır. Bunu sağlayamayan programlarda "güvenilirlik sorunu vardır" denir.

Bu terimleri açıklamak istememin sebebi birbirine çok karıştırılıyor olmasıdır. Bir sistemi geliştirmek sistemli çalıştırmayı gerektirir, sistemli çalışmanın şartı da bireylerin birbirini doğru ve tam olarak anlamasından geçer. En basit örnek olarak bu iki terimi birbirine karıştıran bir programcı, "programda güvenlik sorunu var!" dediği zaman gizli bilgi ihlali olasılığından mı bahsediyor yoksa (beklenmeyen) ölümcül bir hata ile programın sonlanması ihtimali ile istikrar sorunundan mı bahsediyor doğrudan anlamak malesef mümkün değildir.

Son olarak, güvenliği sağlamak için güvenilirliği sağlamak şarttır. Güvenilir olmayan (hata verme olasılığı olan) bir sistemin güvenlikli olması beklenemez. Güvenliğin temel şartı güvenilirliktir. Fakat tam tersini söylemek her zaman doğru değildir. Güvenliği sağlanmamış bir program yıllar boyunca istikrarlı bir şekilde (beklenmeyen) ölümcül bir hata vermeden çalışabilir. Çünkü güvenlik ihlalleri kişi ya da sistemler tarafından bilinçli olarak yapılan ve doğal olmayan eylemlerdir.

Güvenirlir sistemler geliştirip güvenliğini sağlamanız dileğiyle...

Şifrelemenin Kanunları - Bölüm 1.2

2011-02-19T23:15:00.016+02:00

1.3 Kümeler

Bir küme, herhangi iki elemandan eşsiz bir üçüncü elemanı türetmek için bir ikili işleme (binary operation) sahip bir takım küme elemanlarıdır. Eğer küme işlemini # işareti ile gösterecek olursak, yukarıda söylenen herhangi bir küme elemanı olan a ve b için, a#b tanımlıdır ve hatta bir kümenin elemanıdır. Ayrıca kümeler çağrışımsaldır yani a, b ve c kümenin herhangi birer elemanı olsun, a#(b#c) = (a#b)#c'dir. Kümenin herhangi bir elemanı olan a için bir adet birim (etkisiz) eleman (e) olmalıdır, a#e = e#a = a. Son olarak herhangi bir eleman olan a'nın bir tane tersi (a') olmalıdır, a#a' = a'#a = e.

Kümenin tüm elemanları olabilen a ve b için eğer a#b = b#a ise bu küme değişme özelliğine sahiptir. Aksi halde değişme özelliği yoktur. Şu noktaya dikkat çekelim, değişme özelliğine sahip olmayan bir küme için bazı durumlarda a#b = b#a eşitliği doğru olabilir - örneğin a ya da b birim eleman olursa.

Sınırlı sayıda eleman içeren kümeye sınırlı küme, aski durumda sınırsızdır denir.

Örnekler:
1. Tam sayılar (tüm sayılar, 0 ve negatif sayılar) adi toplama işlemiyle bir küme oluştursunlar. Birim eleman 0 olur ve a'nın tersi -a olur. Bu sınırsız ve değişebilen bir kümedir.
2. Pozitif rasyonel sayılar (tüm pozitif tam sayılar da dahil olmak üzere tüm pozitif kesirler) adi çarpma işlem olarak bir küme oluştursun. Birim eleman 1 sayısı ve r'nin tersi 1/r = r^-1. Bu da diğer bir sınırsız değişebilen kümedir.
3. Tam sayıların n ile modu, n > 0 herhangi bir tam sayı olmak üzere bir küme oluştursun. Bu küme genelde Z(n) (Çevirmenin yorumu: asal belgede n, Z'nin sağ altında gösterilmektedir, bu çeviride parantez içerisinde gösterilecektir.) şeklinde gösterilir. Elemanlar 0, 1, 2, ..., n-1 ve işlem toplamanın n ile bölümünden kalan şeklindedir:

Birim eleman 0 sayısıdır ve a'nın tersi n-a'dır (tersi kendisi olan 0 sayısı hariç).

4. Değişemeyen kümeye örnek olarak, 2'ye 2 tekil olmayan gerçek (reel) sayılardan (ya da rasyonel sayılardan) oluşan matrisler düşünelim, işlem matris çarpmasıdır:

Buradaki a, b, c ve d gerçek sayılardır (ya da rasyonel) ve ad-bc sıfır değildir. İşlem matris çarpmasıdır. Yukarıdaki matrisin tersi

ve birim elemanı

Bu bir sınırsız değişemeyen bir kümedir.

5. Ondalıklı sayıların bir bölümü sınırlı değişemez kümelere ilginç ve faydalı bir örnek olarak verilebilir: on elemanlı dihedral (Çevirmenin yorumu: kelime aslı gibidir, kısaca uçak kanatlarının yatay düzlemle yaptığı açıya denir, detaylı bilgi için bkz: [1] http://en.wikipedia.org/wiki/Dihedral_group, [2] http://tr.wikipedia.org/wiki/Dihedral) kümesi.

KANUN KÜME-1: Şifrecilerin gözde kümesi, tam sayıları n ile mod alandır, Z(n).

n = 10'a özel olarak, Z(10)'da toplama işlemi (x+y) mod 10 şeklinde tanımlanabilir, bu, 10'a böl ve kalanını al demektir. Tablo 1.3 nasıl olduğunu göstermektedir ve ayrıca 10 sayısı ile mod alınan tam sayıların toplama tablosu olarak da kullanılabilir.

1.4 Alanlar

Bir alan içerisinde bir çok yapıyı bulunduran bir nesnedir ki bu bölüm yalnızca bir özet niteliğindedir. Bir alan iki işleme sahiptir, bunları + ve * (adi toplama ve çarpma olmak zorunda olmamasına rağmen) olarak adlandıralım. +'yı kullanırsak, alanın tüm elemanları değişebilen bir küme kuracaktır. Bu kümenin birim elemanını 0 olarak ve a'nın tersini -a olarak gösterelim. *'yı kullanırsak, 0 hariç alanın tüm elemanları, birim elemanı 1 ile ve a'nın tersi a^-1 ile gösterilen başka bir değişebilen küme oluşturacaktır. (0 elemanının * işlemi altında tersi yoktur.) Ayrıca bir de dağılma özelliğine sahiptir, + ya da * ile bağlandığında: a*(b+c) = (a*b) + (a*c), a,b ve c tüm elemanlar için. Son olarak birşeyi hariç tutmalıyız, sıfıra bölünenler, bunlar sıfır üreten sıfır olamayan elemanlardır. Bu aşağıdaki fesih neteliğine eşdeğerdir:
eğer c sıfır değilse ve a*c = b*c ise a = b 'dir.

Örnekler:

1. Rasyonel sayıları (kesirler) Q olarak düşünelim, ya da gerçek sayıları R olarak, ya da karmaşık sayıları C olarak, bunlarda adi toplama ve çarpma işlemi kullanmak ( son durumda karmaşık sayılar dahil edilmiştir). Bunların tümü sınırsız alanlardır.

2. Tam sayıların p ile mod alındığını düşünelim, Z(p) olarak gösterilsin, p bir asal sayı olsun (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ...). Bunu + kullanan bir küme olarak görelim (adi toplamanın ardından p'ye bölümünden kalandır). 0 olan elemanlar * altıda bulunmadığı bir küme oluşacaktır (p'ye bölümünden kalanın ardıdan yapılan adi çarpmadır). Burada birim eleman belirgin olarak 1'dir, ama sıfır olmayan a elemanının tersi açık değildir. Java'da tersi, (x*a)%p==1 olan bir x elemanı olmalıdır. Sayılar teorisinde genişletilmiş Öklit Algotirması olarak bilinen bir algoritma kullanılarak eşsiz bir x elemanı bulmak her zaman mümkündür. Bir sonraki bölümün bu başlığında, özet olarak: p'nin asal sayı olması ve a'nın sıfırdan farklı olması sebebiyle, p ve a'nın en büyük ortak bölenleri 1'dir. Şimdi genişletilmiş Öklit algoritması, x*a + y*p = 1 ya da x*a = 1 - y*p sağlayan x ve y sıradan tam sayılarını verecektir, ve bu bize eğer x*a'yı p'ye bölersen 1 kalanını alırsın demektedir, böylece bu x, a'nın tersi olur. ( Bir tam sayı olarak, x negatif olabilir, ve bu durumda Z(p)'nin bir elemanını alabilmesi için ona p eklenmelidir.)

KANUN ALAN-1: Şifrecilerin gözde alanı p'nin asal olduğu Z(p) ile gösterilen tamsayıların p ile modunu alandır.

Yukarıdaki alan p elemanlı olarak tektir. Diğer bir değişle, alan elemanlarının yeniden adlandırılmasıyla eşsizdir, yani alanın elemanları her zaman için bir başka işaret takımıyla gösterilebilir, fakat temel olarak aynıdır.

Ayrıca GF(p^n) şeklinde gösterilen, p^n'in elemanlarından herhangi birisi için n>1 geçerli olan eşsiz sınırlı bir alan daha vardır. Bilhassa şifrelemede p=2 özel durumu çok işe yarar. Bu durumda, n>1 olamak üzere 2^n adet eleman vardır. 2^8 = 256 durumu, örnek olarak, yeni Birleşmiş Milletler Gelişmiş Şifreleme Ölçünü'nünde (U.S. Advanced Encryption Standart - AES) kullanılmıştır. Bunu anlatmak Z(p) alanını anlatmaktan daha zordur. AES için çarma işlemi hakkındaki bölüm bu alanı daha detaylı anlatacaktır, fakat burada bazı özelliklerini özetlemek gerekirse: 256 tane elemanı vardır, 8-bitlik olası tüm katarları ifade eder. Bu alanda toplama bitsel özel veya (XOR) ya da yine bitsel olarak toplamanın mod 2 işlemiyle aynıdır. Sıfır elemanı 00000000'dır, ve birim eleman 00000001'dır. Şimdiye kadar iyi gittik, fakat çarma yapmak daha bir sorunlu: bir eleman, Z(p) alanında katsayılar içeren 7. dereceden bir polinomu ifade etmelidir (bir 0 ya da 1)ve bu polinomların özel bir çarpma hali kullanımalıdır. Ayrıntılar AES üzerine olan sonraki bölümde gelecektir.

KANUN ALAN-2: Şifrecilerin diğer bir gözde alanı GF(2^n)'dır.

Şifrelemenin Kanunları - Bölüm 1

2011-01-13T23:25:00.021+02:00

Şifrecilerin Gözdeleri

1.1 Özel Veya (XOR)

Özel veya olarak bilinen bu fonksiyon aynı zamanda xor olarak ya da bir daire içerisindeki artı işareti (+) olarak da gösterilebilir. a (+) b demek a ya da b fakat ikisi birden değil demektir. Matematikte normal veya (or) demek biri ya da diğeri veyahut ikisi birden demektir. Özel veya işlevi (function) C/C++/Java dillerinde mevcut olup şapka karakteri ^ ile ifade edilmektedir. (Dikkatli olun: şapka karakteri sık sık üstel ifadeler için kullanılır, fakat Java, C ve C++ dillerinde herhangi bir üstel operatör yoktur.) Java'da ayrıca özel veya mantıksal değişkenlerde de (boolean) kullanılabilmektedir.

KANUN XOR-1: Şifrecilerin gözde işlevi özel veyadır.

Özel veya şifrelemede devamlı olarak kullanılır. Bu işlev tek-seferlik şifrelemede, akış şifrelemesinde ve Gelişmiş Şifreleme Ölçünü (AES) ve bir çok yerde kullanılmaktadır.

Hatırlayalım, mantıksal sabit doğru (true) genellikle 1 olarak yanlış (false) ise 0 olarak yazılır. Özel veya toplama işlemi sonucunda mod 2 işlemini yapmakla aynıdır, yani sıradan bir toplama işlemini yaptıktan sonra sonucu 2 sayısına bölüp kalanı alma işlemidir. 0 ve 1 bit değerleri için aşağıdaki tabloda özel veya işlemi sonuçları verilmiştir.

Özel veya işlevinin bir çok ilginç özelliği vardır, a,b ve c bit değerlerini ya da dizilerini tutsun:

Yeni başlayan programcılar iki değişkenin değerini değiş tokuş yapmak için üçüncü bir geçici değişkene atama yaparak öğrenirler:

temp = a;
a = b;
b = temp;

Aynı sonucu xor işlevini kullanarak ek olarak üçüncü bir geçici alan ayırmadan gerçekleştirilebilir. a ve b değerlerinin bit dizileri olsun.

a = a xor b;
b = a xor b;
a = a xor b;

Çevirmenin yorumu:

Özel veya işlevinin şifrelemede kullanımına örnek verecek olursak, xor işlevi sözde rastgele bit akışı olan ri ile şifrelenecek mesajımızın bitlerini içeren mi akışını alsın ve şifrelenmiş halinin ci akışı olarak çıkartsın ci = ri (+) mi. Şifrelenmiş veriyi çözümlemek için aynı sözde rastsal bit akışını (yani ri) ci'ye vererek mi akışını elde ederiz. ri (+) ci = ri (+) ri (+) mi = 0 (+) mi = mi, Şekil 1.1 (Figure 1.1) bu işlem gösterilmiştir.

KANUN XOR-2: Şifreciler özel veya işlevini çok sever çünkü ivedi bir şifreleme mekanizması sağlar.

1.2 Logaritma

Tanım olarak, y = logb(x) demek b^y = x (b üssü y eşittir x). Bir başka değişle: "y, b tabanında x'in logaritmasıdır" ya da "y, x'in taban b'deki logaritmasıdır" denir. Aynı zamanda logb(x) (yani y) ifadesinin b üssü şeklinde yazılarak x değeri elde edilebilir, b^(logb(x)) = x. Daha matematiksel bir ifadeyle logaritma, üssel işlevin (exponential) tersi bir işlevdir.

KANUN LOG-1: Şifrecilerin gözde logaritma işlevi 2 tabanında logaritmadır.

Şifrelemede logaritma 2 tabanındanın kullanılmasının bir sebebi de (çoğunlukla bilgisayar biliminde) bu alanda ikili (binary) sayı düzenine yoğunlaşılmış olmasıdır.
Öyle ise y = log2(x) demek 2^y=x demekle aynı ve logaritma 2 tabanında x'in 2 üssü şeklinde yazımından x'i elde ederiz. Şekillerle ifade edersek: eğer y = log2(x) ise o zaman x = 2^y = 2^(log2(x)). Öyle ise 2^10 = 1024 demek log2(1024)=10 demekle aynı. Fark ettiyseniz tüm y değerleri için 2^y>0 ve tersten gidersek log2(x) x<=0 olduğunda tanımsızdır.

Logaritmayı içeren bir kaç formül:

log2(ab) = log2(a) + log2(b), her a,b > 0
log2(a/b) = log2(a) - log2(b), her a,b > 0
log2(1/a) = log2(a^(-1)) = - log2(a), her a > 0
log2(a^r) = r log2(a), her a > 0, r
log2(a+b) = (Ups! Bunun için basit bir formül yok.)
Tablo 1.2 log2 için bir kaç örnek vermektedir.

Bazı hesap makineleri, Java gibi diller de dahil, doğrudan log2 işlevini desteklemiyorlar. Java 10 tabanından logaritmayı da desteklemiyor yalnızca e tabanında logaritmayı destekliyor ki buna "doğal" logaritma diyoruz. Logaritma 2 tabanında a ile logaritma e tabanında a çarpımının sonucu bir sabit olduğu için eğer "sihirli" sabiti biliyorsanuz bu sonucu hesaplamak çok kolay olacaktır. Formül şöyle:

log2(x) = loge(x) / loge(2) (matematik)
= Math.log(x)/Math.log(2.0); (Java)

Sihirli sabit: loge(2) = 0.69314 71805 59945 30941 72321, yada 1/loge(2) = 1.44269 50408 88963 40735 99246. (Benzer şekilde, log2(x) = log10(x)/log10(2) ve log10(2) = 0.30102999566398114.)

Yukarıdaki formülün ispatı şöyle:

2^y = x, ya da y = log2(x) -> her iki tarafında e tabanında logaritmasını alalım
loge(2^y) = loge(x)
y loge(2) = loge(x)
y = loge(x) / loge(2)
log2(x) = loge(x) / loge(2)

KANUN LOG-2: Bir tam sayının 2 tabanında logaritmasını almak, bize o sayıyı ikili düzende (binary) kaç tane bit ile ifade edebileceğimizi söyler.

Buna göre log2(10000) = 13.28771238, yani iki düzende bu sayıyı ifade etmek için 14 tane bit gereklidir. (Gerçektende, 10000(10) = 10011100010000(2).) İkinin tam katlarının özel bir durumu vardır: log2(1024) = 10 fakat bu sayıyı ikili düzende ifade etmek için 11 adet bit gerekmektedir. 10000000000(2).

Benzer şekilde, log10(x) bize onluk sistemde bu sayıyı ifade etmek için kaç tane raka kullanmamız gerektiğini söyleyecektir.

The Laws of Cryptography

2011-01-12T01:17:00.003+02:00

Hi, this is my first translation project in cryptography. I am very glad to say that I started to translate the masterpiece of Mr. Neal R. Wagner (http://www.cs.utsa.edu/~wagner/) who is Retired as Assoc. Prof. from UTSA ( The University of Texas at San Antonio - http://www.cs.utsa.edu/) which is called The Laws of Cryptography (http://www.cs.utsa.edu/~wagner/lawsbookcolor/laws.pdf) into Turkish. I asked him for the permission to translate his book into Turkish by a personal email conversation. It is an honor for me to do this important job. My purpose is making people who live in Turkey as an computer engineer paying attention to cryptography a little. Although, he emphasized on importance of English in cryptograpy, I would like to translate a part of the book. Because somebody has to trigger it. I hope I will succeed.

Thank you again Mr. Neal R. Wagner.

Merhaba, bu benim şifreleme alanındaki ilk çeviri projem. Şunu söylemekten çok mutluyum ki Texas Üniversitesinde görev almış emekli Profesör Sayın Neal R. Wagner'ın şaheseri diyebileceğimiz Şifrelemenin Kanunları isimli kitabını Türkçe'ye çevirmeye başladım. Kendisinden kişisel bir eposta görüşmesiyle kitabının Türkçe'ye çevirilme iznini istedim. Bu çeviriyi gerçekleştirmek benim için bir onurdur. Amacım Türkiye'de yaşayan bilgisayar mühendisi arkadaşlarımın ilgilisini biraz olsun şifreleme alanına çekebilmektir. Kendisinin bana şifrelemede İngizce'nin önemini vurgulamasına rağmen, kitabının bir kısmını çevirmek istiyorum. Çünkü birileri bu işi başlatmalı. Umarım başarabilirim.

Sayın Neal R. Wagner'a tekrar teşekkür ederim.

Not: Çevirileri ilerleme kaydettikçe bölüm bölüm girdi yapacağım. Kendilerinin de izniyle bazı kısımlarda kendi yorum ve eklemelerim olabilir.

Oyun Programlama Seminerleri (5. Oturum)

2010-12-22T01:34:00.002+02:00

About this playlist

9 videos
Total length: 1 hour, 26 minutes

Description: Sakarya Üniversitesi Bilgisayar Mühendisliği 3 Boyutlu Oyun Motoru Programlama Seminerleri 5. Oturumu
Oturum Konusu: OpenGL
Toplam Uzunluk: 01:30:30

Oyun Programlama Seminerleri (4. Oturum)

2010-12-21T00:59:00.005+02:00

About this playlist

9 videos
Total length: 1 hour, 31 minutes

Description:
Sakarya Üniversitesi Bilgisayar Mühendisliği 3 Boyutlu Oyun Motoru Programlama Seminerleri 4. Oturumu
Oturum Konusu: Sayısal Sistemler ve Sistem Programlama
Toplam Uzunluk: 01:31:46

Drawing a Text on Screen in an OpenGL Application

2010-12-05T00:30:00.006+02:00

Drawing a text on screen is a very general problem when you first start OpenGL. Conversely, it is simple to implement. I tried to make it possible with a little function as I show in the video above. Please note that it is required GLUT library to generate fonts. Do not forget to include to your project. I used SDL to manage Windows but it is optional for you.

Here is the code:


#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <Windows.h>
#include <SDL.h>
#include <gl\GL.h>
#include <gl\GLU.h>
#include <glut.h>
#include <math.h>
#include <cstring>



#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"glu32.lib")


/*
 Drawing text 2D screen.
*/
void drawText(const char *text, int length, int x, int y){
 glMatrixMode(GL_PROJECTION); // change the current matrix to PROJECTION
 double matrix[16]; // allocate 16-byte in memory (thanks to BlueByteGames about memory-leak warning comment on YouTube)
 glGetDoublev(GL_PROJECTION_MATRIX, matrix); // get the values from PROJECTION matrix to local variable
 glLoadIdentity(); // reset PROJECTION matrix to identity matrix
 glOrtho(0, 800, 0, 600, -5, 5); // orthographic perspective
 glMatrixMode(GL_MODELVIEW); // change current matrix to MODELVIDE matrix again
 glLoadIdentity(); // reset it to identity matrix
 glPushMatrix(); // push current state of MODELVIEW matrix to stack
 glLoadIdentity(); // reset it again. (may not be required, but it my convention
 glRasterPos2i(x, y); // raster position in 2D
 for(int i=0; i<length; i++){
  glutBitmapCharacter(GLUT_BITMAP_9_BY_15, (int)text[i]); // generation of characters in our text with 9 by 15 GLU font
 }
 glPopMatrix(); // get MODELVIEW matrix value from stack
 glMatrixMode(GL_PROJECTION); // change current matrix mode to PROJECTION
 glLoadMatrixd(matrix); // reset
 glMatrixMode(GL_MODELVIEW); // change current matrix mode to MODELVIEW
}

void DrawScreen(SDL_Surface* screen, int h)
{ 
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 gluLookAt(0,0,-10, 0,0, 3, 0, 1, 0);

 glColor3f(1,0,0);

 glBegin(GL_LINES);
 glVertex3f(0,0,0);
 glVertex3f(1,0,0);
 glEnd();
 
 std::string text;
 text = "This is a simple text.";
 glColor3f(0, 1, 0);
 drawText(text.data(), text.size(), 50, 200);


 SDL_GL_SwapBuffers();
}

static void reshape(int width, int height)
{
 GLfloat h = (GLfloat) height / (GLfloat) width;
 glViewport(0, 0, (GLint) width, (GLint) height);
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 gluPerspective( 45.0, h, 1.0, 1000.0 ); 
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
}

SDL_Surface *surface;
int main(int argc, char **argv)
{

 if (SDL_Init(SDL_INIT_VIDEO || SDL_INIT_AUDIO)<0)
 {
  return 1;
 }

 surface = SDL_SetVideoMode(800, 600, 32, SDL_OPENGL | SDL_RESIZABLE | SDL_DOUBLEBUF);
 glShadeModel(GL_SMOOTH);
 glEnable(GL_DEPTH_TEST);
 glDepthFunc(GL_LEQUAL);

 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);


 glLineWidth(1.5f);


 glMatrixMode(GL_MODELVIEW);

 reshape(800,600);
 SDL_Event event;

 int keypress = 0;
 int h=0; 

 while(!keypress) 
 {

  while(SDL_PollEvent(&event)) 
  {      
   switch (event.type) 
   {
   case SDL_QUIT:
    keypress = 1;
    break;
   case SDL_KEYDOWN:
    switch(event.key.keysym.sym){
    case SDLK_LEFT:
   
     break;
    case SDLK_RIGHT:
   
     break;
    case SDLK_UP:
    
     break;
    case SDLK_DOWN:
    
     break;
    default:
     break;
    }
   default:
    break;
   }

  }
  DrawScreen(surface,h++);
 }

 SDL_Quit();
 return 0;
}

Paralel Programlama ile PI Sayısının Hesaplanması

2010-11-20T00:42:00.020+02:00

PI sayısı küçük yaşımdan beri bana hep gizemli gelmiştir. İrrasyonel yapıda olduğu için tam değeri hesaplanamayışı, bir çok matematiksel ve geometrik hesabın temelini oluşturması, çok eski medeniyetler tarafından kullanılmış olması insanın ister istemez ilgisini çekiyor. İnternetteki bir tanıma göre (bkz: wikipedia) "çapı 1 olan dairenin çevre uzunluğu" dur PI sayısı.

(bkz: http://tr.wikipedia.org/wiki/Dosya:Pi-unrolled-720.gif)

PI sayısının önemi hakkında daha fazla yazıp çizmek isterdim fakat bu yazının konusu dışında kalmaktadır. Asıl konumuz bu sayının yaklaşık değerini Paralel Programlama yöntemlerini kullanarak nasıl hesaplarız. Yaklaşık değerini dedim çünkü tam değerini hesaplayamayacağımızı artık biliyoruz. :) Bu sayı için hesaplayacağımız basamak sayısı yapmak istediğimiz işin büyüklüğüyle doğru orantılı. Arka bahçemizdeki havuzunuz kaç m^3 su aldığını hesaplamamız için 3.1415 değeri yeterken, Ay'a bir araç göndermek isteyen NASA mühendisleri için 3.1415926535 8979323846 2643383279 5028841971 6939937510 5820974944 5923078164 0628620899 8628034825 3421170679 8214808651 3282306647 0938446095 5058223172 5359408128 4811174502 8410270193 8521105559 6446229489 5493038196 4428810975 6659334461 2847564823 3786783165 2712019091 4564856692 3460348610 4543266482 1339360726 0249141273 7245870066 0631558817 4881520920 9628292540 9171536436 7892590360 0113305305 4882046652 1384146951 9415116094 3305727036 5759591953 0921861173 8193261179 3105118548 0744623799 6274956735 1885752724 8912279381 8301194912 9833673362 4406566430 8602139494 6395224737 1907021798 6094370277 0539217176 2931767523 8467481846 7669405132 0005681271 4526356082 7785771342 7577896091 7363717872 1468440901 2249534301 4654958537 1050792279 6892589235 4201995611 2129021960 8640344181 5981362977 4771309960 5187072113 4999999837 2978049951 0597317328 1609631859 5024459455 3469083026 4252230825 3344685035 2619311881 7101000313 7838752886 5875332083 8142061717 7669147303 5982534904 2875546873 1159562863 8823537875 9375195778 1857780532 1712268066 1300192787 6611195909 2164201989 3809525720 1065485863 2788659361 5338182796 8230301952 0353018529 6899577362 2599413891 2497217752 8347913151 5574857242 4541506959 5082953311 6861727855 8890750983 8175463746 4939319255 0604009277 0167113900 9848824012 8583616035 6370766010 4710181942 9555961989 4676783744 9448255379 7747268471 0404753464 6208046684 2590694912 9331367702 8989152104 7521620569 6602405803 8150193511 2533824300 3558764024 7496473263 9141992726 0426992279 6782354781 6360093417 2164121992 4586315030 2861829745 5570674983 8505494588 5869269956 9092721079 7509302955 3211653449 8720275596 0236480665 4991198818 3479775356 6369807426 5425278625 5181841757 4672890977 7727938000 8164706001 6145249192 1732172147 7235014144 1973568548 1613611573 5255213347 5741849468 4385233239 0739414333 4547762416 8625189835 6948556209 9219222184 2725502542 5688767179 0494601653 4668049886 2723279178 6085784383 8279679766 8145410095 3883786360 9506800642 2512520511 7392984896 0841284886 2694560424 1965285022 2106611863 0674427862 2039194945 0471237137 8696095636 4371917287 4677646575 7396241389 0865832645 9958133904 7802759009 değeri yetersiz ya da yanıltıcı olabilir. Bu yüzden sıradışı ihtiyaçlar için (fezaya mekik göndermek gibi) sıradışı çözümler sunmamız gerekmektedir. Bir gün NASA mühendisleri için PI sayısı hesaplarmıyız bilemiyorum fakat gelecekte çok fazla paralel işlem bizleri bekliyor. Şimdiden kendimizi hazırlamalıyız.

Lafı fazla dolandırmadan işe koyulalım. İlk PI hesabımızı Monte Carlo yöntemiyle yapacağız. Bu yöntem oldukça basit bir olasılık hesabına dayanmaktadır.

Bu olasılık hesabını yapmak için C++ programlama dili üzerinden openMP kütüphanesini kullandım. Paylaşımlı bellek üzerinden paralel programlama yapmak için geliştirilmiş olan bu kütüphane kullanması oldukça basittir. Mevcut kodunuza hiç dokunmadan (elbetteki paylaşımlı bellek paralel program mantığı güdülerek yazılmış kod olamalı) doğrudan programınızı paralel çalıştırabilirsiniz. Bu yazacağımız program dağıtık mimariler için değil tek bir süper bilgisayar için programlanmıştır. Makine üzerindeki çekirdek sayısıyla doğru orantılı olarak performans artışı sağlanacaktır.

Programımızı yazmadan önce Visual Studio 2010 üzerinden projemizin openMP desteğini açalım. Project -> Properties ...

(DÜZELTME)

Şimdi programımızı yazalım. Programda açıklamak istediğim tüm noktaları yorum satırı olarak ekledim. Bir göz atalım sonra sonuçları değerlendirelim.


/*
 Monte Carlo yöntemiyle PI sayısının yaklaşık değerinin hesaplanması.

 C++ / openMP

 Ramazan Bellek - Kasım 2010
*/

#include <iostream>
#include <ctime>
#include <math.h>

#define MAX_ITERATION 1000000 // tekrarlama sayısı
#define r 500 // yarıçap
#define R r*2+1 // çap + 1

int main(int argc, char **argv)
{
 srand(time(0));
 clock_t start = clock();

 bool iceride[MAX_ITERATION]; // doğruluk tablomuz
 double x,y;

 /*
  openMP ile birbirinden bağımsız olan hesaplama kısmını işlemciye paralel olarak işletiyoruz.
  x ve y değişkenleri her bir iş parçacığı için kişisel olarak tanımlandı, böylelikle bir iş parçacığı
  diğerinin konum bilgisini görememektedir. Doğruluk tablosunu belirten değişkeni ise ortak olarak
  kullanacaklardır.
 */
#pragma omp parallel for private(x,y) shared(iceride)
 for(int i=0;i<MAX_ITERATION; i++)
 {
  // uzayda bir noktayı (sözde) keyfi seçiyoruz.
  x = rand()%R;
  y = rand()%R;

  double fark = sqrt(pow(x-r,2)+pow(y-r,2)); // seçtiğimiz noktanın dairenin merkezine olan uzaklığını alıyoruz.

  if (fark<=r) // eğer bu uzaklık dairenin yarıçapından küçük ya da eşit ise nokta dairenin içerindedir.
   iceride[i]=true;
  else
   iceride[i]=false;
 }

 long toplamIceride = 0;
 // daire içerisine düşen toplam sayı 
 for(int i=0;i<MAX_ITERATION; i++){
  if (iceride[i]==true)
   toplamIceride++;
 }

 /*
  daire_icine_dusen/toplam = (pi*r^2)/(4*r^2)
         => pi = 4 * daire_icine_dusen/toplam
 */
   std::cout<<"PI ~= "<<4*(double)toplamIceride/MAX_ITERATION<<std::endl;

 printf("Gecen Sure: %f\n", ((double)clock() - start) / CLOCKS_PER_SEC);
 system("pause");
 return 0;
}

Programımızı çalıştırıyoruz.

Sonuç aslında pek istediğim gibi çıkmadı. Beklentim en azından ilk 4 basamağı (3.1415) bulmak üzereydi. İterasyonları arttırarak tekrar denenebilir, ayrıca burada ürettiğimiz rastgele sayılar sözde olduğu için bize tam bir sonuç vermesi beklenemez. İterasyonu arttırarak işlemcinin çekirdeklerindeki değişimi göstermek istiyorum.

Gördüğünüz gibi PI sayısını bir süper bilgisayarda nasıl hesaplayacağımızı basit olarak da olsa görmüş olduk. Daha detaylı görsel uygulama için http://www.eveandersson.com/pi/monte-carlo-demo adresindenki java applete göz atabilirler.

Bir sonraki paralel programlama yazımda paylaşımsız bellekli dağıtık mimari kullaranak PI sayısını hespalamaya çalışacağım. Küçük bir bilgisayar kümesi kurarak dev işlemleri basitleştirmeye çalışacağız. Gelecekteki bir bilgisayar ordusunun komutanı olmanız ümidiyle. Hoşçakalın...

Tic Tac Toe Oyunu - Yapay Zeka - MiniMax Algo.

2010-11-15T23:51:00.010+02:00

Yapay zeka konusuna ilk girişi klasik Minimax algoritmasıyla yapıyorum. Algoritma çok basit ve etkili bir yöntem kullanmaktadır. Oyuncu bir hamle yaptıktan sonra diğer tüm oyunları oynayarak bilgisayarın en az kaybettiği en çok kazandığı hamle tespit edilmiş olur. Uygulamayı Python dilinde gerçeklemeye çalıştım. Doğası itibariyle %100 nesne yönelimli programlandı. Görsel arayüz için OpenGL (pyOpenGL) ve GLUT kütüphanelerini kullandım. Algoritma için daha detaylı bilgiyi http://en.wikipedia.org/wiki/Minimax adresinden edinebilirsiniz. İsterseniz programa ve kodların açıklamasına şöyle bir göz atalım, ardından kaynak kodu vereyim.


# -*- coding: cp1254 -*-


"""
MiniMax algoritmasını kullanarak Tic Tac Toe oyununun gerçeklenmesi

Sakarya Üniversitesi Bilgisayar Mühendisliği Bölümü
Yapay Zeka Dersi Ödevi

Ramazan Bellek - Ekim 2010


"""


from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *
import time
import math
import copy
from Tkinter import *


# MiniMax algoritmasını gerçekleyen sınıf
class MiniMax:
    mevcutDurum = [[]]
    def __init__(self, mevcutDurum): # yapılandırıcı metod
        self.mevcutDurum = copy.deepcopy(mevcutDurum)

    # bilgisayarın bir sonraki yapacağı en mantıklı hareketi belirler
    def sonrakiHamleyiHesapla(self):
        tahta = self.mevcutDurum
        max = [[0 for satir in range(3)] for sutun in range(3)]
        for x in range(3):
            for y in range(3):
                if tahta[x][y] == 0:
                    tahta[x][y] = 1 # boş alana hamle yap
                    max[x][y] = self.__tara(tahta, 1) # alt ağaçları tara
                    tahta[x][y] = 0 # tarama bitince yapılan hamle geri alınır
                else:
                    max[x][y] = -99
        sonuc = -99
        donusDegeri = [0,0]
        for x in range(3):
            for y in range(3):
                if max[x][y]>sonuc:
                    sonuc=max[x][y]
                    donusDegeri = [x, y]
        return donusDegeri

    # alt oyun ağaçlarını tarar
    def __tara(self, t, s):
        tahta = copy.deepcopy(t)
        sonEl = copy.deepcopy(s)
        toplam = [[0 for satir in range(3)] for sutun in range(3)]
        for x in range(3):
            for y in range(3):
                if tahta[x][y] == 0:
                    tahta[x][y] = sonEl*-1
                    kontrolSonucu = Hakem.kontrolEt(tahta)
                    if kontrolSonucu != 5: # -> tahta henüz dolu değil!
                        return kontrolSonucu
                    toplam[x][y] = self.__tara(tahta, sonEl*-1)
                    tahta[x][y] = 0
        if sonEl == 1:
            return self.Min(toplam)
        else:
            return self.Max(toplam)

    # Katardaki azami değeri tespit eder.
    def Max(self, t):
        tahta = copy.deepcopy(t)
        deger = -99
        for x in range(3):
            for y in range(3):
                if tahta[x][y]>deger:
                    deger = tahta[x][y]
        return deger

    # Katardaki asgari değeri tespit eder.
    def Min(self, t):
        tahta = copy.deepcopy(t)
        deger = 99
        for x in range(3):
            for y in range(3):
                if tahta[x][y]                    deger = tahta[x][y]
        return deger
    
class Hakem:
    @staticmethod
    def bosMu(t):
        tahta = copy.deepcopy(t)
        for x in range(3):
            for y in range(3):
                if tahta[x][y] == 0:
                    return True
        return False
    @staticmethod
    def kontrolEt(t):
        tahta = copy.deepcopy(t)

        # oyuncu hamleleri --------------

        # yatay kontrol --
        if tahta[0][0] == tahta[1][0] == tahta[2][0] == -1:
            return -1
        elif tahta[0][1] == tahta[1][1] == tahta[2][1] == -1:
            return -1
        elif tahta[0][2] == tahta[1][2] == tahta[2][2] == -1:
            return -1
        # ----------------

        # dikey kontrol --
        elif tahta[0][0] == tahta[0][1] == tahta[0][2] == -1:
            return -1
        elif tahta[1][0] == tahta[1][1] == tahta[1][2] == -1:
            return -1
        elif tahta[2][0] == tahta[2][1] == tahta[2][2] == -1:
            return -1
        # ----------------

        # çapraz kontrol --
        elif tahta[0][0] == tahta[1][1] == tahta[2][2] == -1:
            return -1
        elif tahta[2][0] == tahta[1][1] == tahta[0][2] == -1:
            return -1
        # -----------------

        # ------------------------------------

        # Bilgisayar hamleleri --------------

        # yatay kontrol --
        if tahta[0][0] == tahta[1][0] == tahta[2][0] == 1:
            return 1
        elif tahta[0][1] == tahta[1][1] == tahta[2][1] == 1:
            return 1
        elif tahta[0][2] == tahta[1][2] == tahta[2][2] == 1:
            return 1
        # ----------------

        # dikey kontrol --
        elif tahta[0][0] == tahta[0][1] == tahta[0][2] == 1:
            return 1
        elif tahta[1][0] == tahta[1][1] == tahta[1][2] == 1:
            return 1
        elif tahta[2][0] == tahta[2][1] == tahta[2][2] == 1:
            return 1
        # ----------------

        # çapraz kontrol --
        elif tahta[0][0] == tahta[1][1] == tahta[2][2] == 1:
            return 1
        elif tahta[2][0] == tahta[1][1] == tahta[0][2] == 1:
            return 1
        # -----------------

        # ------------------------------------

        # Eşitlik durumu
        if Hakem.bosMu(tahta) == False:
            return 0
        return 5 # -> tahta henüz dolu değil!

class Tahta:
    """Oyun tahtası sınıfı"""
    tahta = [ [0 for satir in range(3)] for sutun in range(3)]
    siraBilgisayarda = False
    oyunBitti = False
    
    def __init__(self):
        oyunBitti = False
        self.ilkDefa = True

    def ciz(self):
        if self.oyunBitti == True:
            glColor(0.9, 0.6, 0.1)
            drawText("Oyun bitti... :|", 10 ,5 ,250, 250)
        elif self.ilkDefa == True:
            glColor(0.9, 0.6, 0.1)
            drawText("Oynamaya hazirim, lütfen bir hamle yapiniz... :)", 10 ,5 ,250, 250)
        else:
            glColor(0.9, 0.6, 0.1)
            drawText("Sizin siraniz ?", 10 ,5 ,250, 250)
            
        if self.ilkDefa == True:
            self.ilkDefa = False
        Tahta.cerceveCiz()
        self.__oyunCiz()
        

    @staticmethod
    def cerceveCiz():
        glLineWidth(2.5)
        glColor(0.0, 0.0, 1.0)
        glBegin(GL_LINES)
        
        # dış çerçeve ------------
        glVertex(-0.9, 0.9, 0.0)
        glVertex(0.9, 0.9, 0.0)
        glVertex(-0.9, 0.9, 0.0)
        glVertex(-0.9, -0.9, 0.0)
        glVertex(-0.9, -0.9, 0.0)
        glVertex(0.9, -0.9, 0.0)
        glVertex(0.9, -0.9, 0.0)
        glVertex(0.9, 0.9, 0.0)
        # -------------------------

        # ızgaralar ---------------
        glVertex(-0.3, -0.9, 0.0)
        glVertex(-0.3, 0.9, 0.0)
        glVertex(0.3, -0.9, 0.0)
        glVertex(0.3, 0.9, 0.0)
        glVertex(-0.9, -0.3, 0.0)
        glVertex(0.9, -0.3, 0.0)
        glVertex(-0.9, 0.3, 0.0)
        glVertex(0.9, 0.3, 0.0)
        # -------------------------
        glEnd()       

    def __xCiz(self, x, y):
        x =0.6*x-0.6
        y =-1*(0.6*y-0.6)
        glLineWidth(8.5)
        glColor(0.0, 1.0, 0.0)
        glBegin(GL_LINES)
        glVertex(x-0.175, y-0.175)
        glVertex(x+0.175, y+0.175)
        glVertex(x-0.175, y+0.175)
        glVertex(x+0.175, y-0.175)
        glEnd()

    def __oCiz(self, x, y):
        x =0.6*x-0.6
        y =-1*(0.6*y-0.6)
        glLineWidth(1.5)
        glColor(1.0, 0.0, 0.0)
        glPushMatrix()
        glTranslate(x, y, 0.0)
        glBegin(GL_LINES)
        for i in range(0, 1080):
            glVertex(math.sin(i)*0.2,math.cos(i)*0.2)
        glEnd()
        glPopMatrix()

    def __oyunCiz(self):
        for x in range(3):
            for y in range(3):
                if self.tahta[x][y] == -1:
                    self.__xCiz(x, y)
                elif self.tahta[x][y] == 1:
                    self.__oCiz(x, y)

    ''' tüm hamleler bu metod üzerinden gerçekleştirilir.
        kullanıcı girişleri bu metoda yönlendirilerek kullanıcının hamle yapması
        sağlanırken, her hamleden sonra öz yinelemeli olarak bilgisayar kendi hamlesini yapar.
        Yapacağı hamleyi MiniMax algoritmasınını kullanarak tespit etmeye çalışır.
    '''
    def oyna(self, x, y):
        try:
            if self.oyunBitti == True:
##                Mesaj.msj("Oyun bittiği için hamle yapamazsınız.","Üzgünüm... :(")
                return
            if x not in range(40, 760):
                return
            if y not in range(30, 560):
                return
            x = (x-40)/240
            y = (y-30)/176
            if self.tahta[x][y] == 0:
                if self.siraBilgisayarda:
                    self.siraBilgisayarda = ~self.siraBilgisayarda
                    self.tahta[x][y] = 1
                    self.ciz()
                    glFlush ()
                    glutSwapBuffers()
                    self.__kontrolEt()
                else:
                    self.siraBilgisayarda = ~self.siraBilgisayarda
                    self.tahta[x][y] = -1
                    self.ciz()
                    glFlush ()
                    glutSwapBuffers()
                    self.__kontrolEt()
                    if self.oyunBitti == True:
                        return
                    mm = MiniMax(self.tahta)
                    time.sleep(0.5)
                    xy = mm.sonrakiHamleyiHesapla()
                    self.oyna(xy[0]*240+40, xy[1]*176+30)
                    glutPostRedisplay()
        except:
            print "Beklenmeyen bir hata meydana geldi. Lütfen tekrar deneyiniz."
            raise
        
    def __kontrolEt(self):
        durum = Hakem.kontrolEt(self.tahta)
        if durum == 0:
            self.oyunBitti = True
            Mesaj.msj("Berabere bitti!", "Eşitlik durumu")
            glEnable(GL_LIGHTING)
            glutPostRedisplay()
            return

        # Bilgisayarın hamleleri --------------
        mesaj = "Bilgisayar kazandı! :/\nBiraz daha dikkatli olmalısınız..."
        if durum == 1:
            self.oyunBitti = True
            Mesaj.msj(mesaj, "Oyun bitti...")
            glEnable(GL_LIGHTING)
            glutPostRedisplay()
            return
        # ------------------------------------

        # oyuncu hamleleri --------------
        mesaj = "Tebrikler, siz kazandınız... :)"
        if durum == -1:
            self.oyunBitti = True
            Mesaj.msj(mesaj, "Oyun bitti...")
            glEnable(GL_LIGHTING)
            glutPostRedisplay()
            return
        # ------------------------------------
        if durum == 5: # -> tahta henüz dolu değil
            return

# Mesaj sınıfı ----
class Mesaj:
    root = None
    def __init__(self, root):
        self.root = root
    @staticmethod
    def msj(yazi, baslik):
        root = Tk()
        root.title(unicode(baslik, encoding="cp1254"))
        root.withdraw()
        mesaj = Mesaj(root)
        mesaj.top = Toplevel(root)
        Label(mesaj.top, text=unicode(yazi, encoding="cp1254")).pack()
        Button(mesaj.top, text="OK", command=mesaj.tamam).pack(pady=5)
        root.wait_window(mesaj.top) # pencere Tamam komutu verene kadar bekler.
        root.destroy()
    def tamam(self):
        self.top.destroy()
# -----------------

# Yazı yazma fonksiyonu (pyOpenGL - örneğinden alınmıştır!)
def drawText( value, x,y,  windowHeight, windowWidth, step = 18 ):
    value = unicode(value, encoding="cp1254")
    glMatrixMode(GL_PROJECTION);
    matrix = glGetDouble(GL_PROJECTION_MATRIX)
    glLoadIdentity();
    glOrtho(0.0, windowHeight or 32, 0.0, windowWidth or 32, -1.0, 1.0)
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glRasterPos2i(x, y);
    lines = 0
    for character in value:
        if character == '\n':
            glRasterPos2i(x, y-(lines*18))
        else:
            glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(character));
    glPopMatrix();
    glMatrixMode(GL_PROJECTION);
    glLoadMatrixd(matrix)
    glMatrixMode(GL_MODELVIEW);
# --------------------------------
            
# uygulama giriş fonsiyonları ---------------

resX,resY = (800,600 ) # ekran çözünürlüğü
oyunTahtasi = Tahta() # tahta sınıfı

def goster( ): # openGL render fonksiyonu
    glutSetWindow(window);
    glClearColor (1.0, 1.0, 1.0, 1.0)
    glClear (GL_COLOR_BUFFER_BIT)
    oyunTahtasi.ciz()
    glFlush ()
    glutSwapBuffers()

def ayarla():
    ''' yumuşak çizim '''
    glShadeModel(GL_SMOOTH)
    glDisable(GL_LIGHTING)



def fare(button, state, x, y):
    if button == 0 and state == 1:
        oyunTahtasi.oyna(x, y)


if __name__ == "__main__":
    glutInit([])
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)

    glutInitWindowSize(resX, resY) # pencere genişliği
    glutInitWindowPosition(0, 0)
    window = glutCreateWindow("Tic Tac Toe Oyunu / MiniMax Yapay Zeka Uygulaması - Ramazan Bellek | Ekim 2010")
    glutMouseFunc(fare)
    ayarla()

    
    glutDisplayFunc(goster)
    glutMainLoop()

Game Engine Programming

2010-10-30T18:57:00.013+03:00

3 Boyutlu Oyun Motoru geliştirme seminerim önümüzdeki Salı günü (2 Kasım 2010) başlayacağını büyük bir mutlulukla duyurmak isterim :) Sau Bilgisayar Topluluğu bünyesinde gerçekleştilecek olan organizasyon için zaman 13:00~15:00 saatleri arası (D8 binası - sınıf henüz bana bildirilmedi) şeklinde düşünüldü. Ders yoğunluğuna bakarak en uygun zaman seçilmeye çalışıldı. Bu aralıkta dersi olan arkadaşlardan özür diliyorum. Eğer bir aksilik çıkmaz ise her salı bu seminerler düzenlenecek. Seminerlerle ilgili her türlü görüş ve eleştirilerinizi yorum olarak bu girdinin peşine bekliyorum.

Salı günü görüşmek üzere efendim. :)

-------02.11.2010------------------------------
İlk eğitimin başarılı geçtiğine inanıyorum. Katılan tüm arkadaşlara teşekkür ederim.
1. hafta sunum dosyasını buraya tıklayarak indirebilirsiniz.

Eğitimin bundan sonraki haftalarında tüm etkinliğin kameraya çekilmesi düşünülüyor. Ben de faydalı olacağına inanıyorum.

Haftaya aynı saatte görüşmek üzere.
-----------------------------------------------

-------09.11.2010------------------------------
İkinci hafta eğitim sunumları için:
sunum2
sunum3

sunumda kullanılan videolar:
Blender
Cry Engine 3
UDK

ayrıca sunumun bir kısmı video kameraya çekilmiştir. Görüntüler henüz elime ulaşmadı. Çekim yapan arkadaştan elde ettiğim zaman paylaşacağım.

Katılan herkese teşekkür ederim. Bayramdan sonraki hafta görüşmek üzere.

-------23.11.2010---------------------------------------
sunum4

Eğitim Videoları (YouTube)

Makine dilinde derleyicisiz yazdığımız uygulama.

--------------------------------------------------------

About this playlist

9 videos
Total length: 1 hour, 26 minutes

Description: Sakarya Üniversitesi Bilgisayar Mühendisliği 3 Boyutlu Oyun Motoru Programlama Seminerleri 5. Oturumu
Oturum Konusu: OpenGL
Toplam Uzunluk: 01:30:30

13. MÜSİAD Fuarı / CNR EXPO

2010-10-15T00:15:00.004+03:00

2007 yılında Biltronik bilgi teknolojileri yarışmasında ödül kazandığım projemi tanıtmak üzere CNR EXPO 13. MÜSİAD Fuarı'nda kendim için ayrılan standa bulundum. Projemin gelişimini durdurmuş olsam da, standın arkasında olmanın zorluklarını anlama açısından faydalı bir deneyim olduğunu düşünyorum.

Java ile Nesneleri Dosyaya Kaydetme ve Okuma (Serialization)

2010-09-18T01:11:00.021+03:00

Nesne yönelimli programlamada bellekte yüklü nesnelerin dosyaya kaydedilmesi ve tekrar dosyadan okunarak belleğe yüklenmesi olayına Serialization (Serileştirme olarak tercüme edilebilir) denmektedir.

Örneğimize geçmeden önce bu yöntem ile neler yapabileceğimizi değerlendirelim. Geliştirdiğimiz programlarda tüm işlemleri nesneler üzerinden gerçekleştiririz. Bazı durumlarda uygulamamızda kullanacağımız bilgileri bir dosya üzerinde saklamak isteyebiliriz. Bu noktada aklımıza veritabanı sistemleri gelebilir, fakat burada bahsettiğimiz veriler programın mantıksal verileri olduğu için genelde büyük boyutta olmazlar. Aynı zamanda nesnelerimizi veritabanında da tutabiliriz. Unutmamız gereken nokta Serialization dediğimiz olay nesnelerin hafızadaki yapısını ikili (binary) olarak saklamaktır. Neler yapılabilir sorusuna çok çeşitli cevaplar veribilir benim aklıma gelen şu başlıklar:
- Uygulamanın ayarlarının kaydedilmesi
- Basit bir veritabanı olarak kullanılması
- Programın çökmesi durumunda en son tutarlı yerden devam etmesi için hafızanın kaydedilmesi...

Normalde düşündüğümüz zaman bir nesneyi diskte saklamak çok külfetli bir iştir. Nesnenin tüm bilgilerini tek tek toplayıp bir sıraya koyacaksınız, ardından bunları karıştırmadan ve atlamadan (null değişkenler olabilir, ya da String benzeri dinamik genişleyen generic yapılar olabilir) doğru bir şekilde yazmalısınız. Okuma olayına hiç girmiyorum zaten. Ayrıca her nesnenin iç yapısı farklı olacaktır!

Peki hafızadan direk BYTE dizisi olarak diske yazmak? Java dilinde hafızaya direk erişimimiz olmadığı (işaretçilerin olamaması) için normal şartlar altında mümkün olmaması lazım. Fakat Java bize bu işlemi çok kolay bir şekilde yapacak bir imkan sağlamaktadır.

Java'da yazılan tüm nesneler Serializable arayüzünden (interface) kalıtım aldığı sürece sorunsuz bir şekilde diske yazılabilmektedir. Aynı rahatlıkla diskten okunabilmektedir. Bunun için özel olarak hazırlanmış yazan ve okuyan sınıfları kullanmaktadır.

Lafı fazla dolandırmadan örneğimize geçelim. Yorum satırlarını yeterli gördüğüm için tekrardan açıklama gereği duymadım.


/*
 * Öğrenci Sınıfı
 * Ogrenci.java
 */

package rbellek.blogspot.com;

import java.io.Serializable;

/**
 *
 * @author Ramazan
 */
public class Ogrenci implements Serializable {

    private String isim;

    public String getIsim() {
        return isim;
    }

    public void setIsim(String isim) {
        this.isim = isim;
    }
}


/*
 * Serilazation Örnek
 * Main.java
 */
package rbellek.blogspot.com;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Ramazan
 */
public class Main {

    public static void main(String[] args) {
        Ogrenci o1 = new Ogrenci(); // Yeni bir öğrenci nesnesi oluşturalım.
        o1.setIsim("Ahmet"); // İsmini verelim.
        System.out.println(o1.getIsim()); // Test edelim.
        try {
            // Nesneyi dosyaya kaydedelim.
            FileOutputStream yazmac = new FileOutputStream("Ogrenci1.nesne"); // Dosyaya veri aktarım akışı nesnesi oluşturalım.
            ObjectOutputStream nesneYazmac = new ObjectOutputStream(yazmac); // Nesneleri veri akışlarına yazmaya yarayan nesneyi oluşturalım.
            nesneYazmac.writeObject(o1); // Öğrenci nesnemizi dosyaya yazıyoruz.
            nesneYazmac.close(); // akışı kapatalım.
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }

        o1.setIsim("Mehmet"); // Öğrenci nesnemizin adını değiştirelim.
        System.out.println(o1.getIsim()); // Test edelim.

        Ogrenci o2 = null; // Başka bir öğrenci nesnesi referansı. (Henüz bir nesne oluşturmadık!)

        try {
            FileInputStream okuyucu = new FileInputStream("Ogrenci1.nesne"); // Dosyadan veri alan akış nesnesi.
            ObjectInputStream nesneOkuyucu = new ObjectInputStream(okuyucu); // Dosyada kayıtlı nesneleri okuyan nesne.
            o2 = (Ogrenci) nesneOkuyucu.readObject(); // Öğrenci nesnemizi okuyalım.
            nesneOkuyucu.close(); // akışı kapatalım.
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }

        System.out.println(o2.getIsim()); // Okunan nesne adı Ahmet olmalı...
    }
}

İyi çalışmalar...

Ford OTOSAN - jQuery Sunumu

2010-06-30T23:41:00.008+03:00

Bünyesinde çalışmakta olduğum Ford OTOSAN firması Bilgi İşlem merkezinde geçtiğimiz günlerde jQuery JavaScript kütüphanesi hakkında genel bilgi ve tanıtım amacıyla bir sunum yaptım. Sunumda bahsettiğim uygulamaları video olarak hazırladım.

Genel hatlarıyla sunum içeriğinden bahsetmek gerekirse;

jQuery Nedir?

Kimler Kullanıyor?

Lisans ve Kullanım Koşulları

jQuery Kullanmak için 3 Temel Sebep

Kimlere Hitap Ediyor?

Kurulum Aşamaları

Temel Taşları

Basit Ajax İşlemleri

Asp.NET Web Formlar ve Web Servis Entegrasyonu

jQueryUI ile Etkileşimli Görsel Arayüzler

Eklenti Desteği

jQuery Sunum Dosyaları

Portable Document File - PDF

Microsoft Office PowerPoint File - PPT

Open Office Presentation File - ODP

Uygulama Videoları

Tüm Videolar

Spring Framework - Web MVC / NetBeans 6.8 / Bölüm 2

2010-05-20T15:44:00.018+03:00

Not: Bu yazı Spring Framework - Web MVC / NetBeans 6.8 adlı yazının devamı niteliğindedir.

Bir önceki yazımda kaldığım noktadan devame etmeye çalışacağım. Giriş yazımda bir Spring Web MVC projesini NetBeans 6.8 ile oluşturmuştuk. Şimdi yapıyı incelemeye devam edeceğiz. WEB-INF dizini altındaki ayar dosyalarını inceleyerek devam edelim.

İlk olarak Web.xml den biraz bahsetmek istiyorum. Bu dosya Java Web projelerinde genel ayarların yapıldığı standart bir dosyadır. Tıpkı Asp.NET projelerindeki Web.config dosyası gibi. Arzu ederseniz içeriğine bir gözatalım.


<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>2</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.htm</url-pattern>
    </servlet-mapping>
    <session-config>
        <session-timeout>
            30
        </session-timeout>
    </session-config>
    <welcome-file-list>
        <welcome-file>redirect.jsp</welcome-file>
    </welcome-file-list>
</web-app>

İlk bakışta göze batan karmaşıklık sizi korkutmasın. Aslında anlaması gayet basit. Burada XML formatında ayarlar mevcut. Şimdilik bu dosya salt okunur gibi olmalı. Buradan herhangi bir ayarı değiştirmeyelim. Aksi takdirde uygulamamız doğru çalışmayabilir. Fakat anlamadan da geçemeyiz. Eğer bu detayları iyi kavramazsak, frameworke tam olarak hakim olamayız. context-param kısmında projemiz için içerik ayarlarının yapıldığı düğümdür. Buraya contextConfigLocation adında bir anahatar ve /WEB-INF/applicationContext.xml şeklinde bir değer girilmiştir. Bu dosya Spring projemizde yapacağımız bazı ayarların (veritabanı bağlantı cümleleri vb.) bulunacağı dosya. listener düğümünde dinleyici sınıfları belirtiyoruz. Değer olarak org.springframework.web.context.ContextLoaderListener sınıfı eklenmiş. Daha sonra bir servlet tanımlanmış. dispatcher adındaki bu servlet Spring'in temel çözümleme servlet sınıfıdır. Sınıfın yolu org.springframework.web.servlet.DispatcherServlet şeklinde eklenmiş. servlet-mapping düğümü ile hangi servlet hangi desenle (örüntü - pattern) eşleceği belirtiliyor. dispatcher servleti için *.htm şeklinde bir desen verilmiş. Daha önceki yazımda belirtiğim noktaya geldik. Kullanıcı web tarayıcısıyla web sunucumuza *.htm şeklinde bir sorgu yaptığı zaman web sunucumuz bunu anlayarak ilgili servleta (burada dispatcher oluyor) yönlendirecektir. Son olarak welcome-file-list düğümü ile sitemiz ilk açılışta hangi sayfayı direk gösterecek onu belirtiyoruz. Örneğin Apache web sunucusunda varsayılan karşılama dosyası index.html, index.htm ya da index.php, IIS sunucusunda default.html, default.htm, default.asp ya da default.aspx şeklinde olabilir. NetBeans otomatik olarak redirect.jsp dosyasını seçmiş. Bu kısmı dilediğiniz gibi (desene uygun bir URL ile) edeğiştirebilirsiniz.

NetBeans Web.xml için görsel ayar penceresi

Şimdi gelelim dispatcher-servlet.xml dosyamıza. Bu dosya Web.xml dosyasında belirtiğimiz dispathcer servlet sınıfı için ayar niteliğindedir. Vakit kaybetmeden içeriğine bir göz atalım.


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    
    <bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>
    
    <!--
    Most controllers will use the ControllerClassNameHandlerMapping above, but
    for the index controller we are using ParameterizableViewController, so we must
    define an explicit mapping for it.
    -->
    <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <prop key="index.htm">indexController</prop>
            </props>
        </property>
    </bean>
    
    <bean id="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          p:prefix="/WEB-INF/jsp/"
          p:suffix=".jsp" />
    
    <!--
    The index controller.
    -->
    <bean name="indexController"
          class="org.springframework.web.servlet.mvc.ParameterizableViewController"
          p:viewName="index" />
    
</beans>

İlk baştaki uzun tanımlamaları direk atlıyorum. Şimdilik bu ayarlar konumuz değil. Olduğu gibi bırakıyoruz.

bean tagıyla başlayan satırda yeni Spring bean sınıfını (org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping) tanımlıyoruz. Alt satırdaki yorum bu satırları anlamamız için önemli. Yorum satırında bu eklediğimiz sınıfın (ControllerClassNameHandlerMapping) bir çok kontrollör sınıf tarafından kullanıldığından fakat indexController sınıfı için ParameterizableViewController sınıfının kullanıldığını bu yüzden harici bir rota belirlememiz gerektiğinden bahsetmektedir.
Bir alt satırda org.springframework.web.servlet.handler.SimpleUrlHandlerMapping sınıfının tanımlanmasıyla görebiliyoruz. Verdiği değerler önemli. index.htm şeklinde gelen bir isteğin indexController nesnesi tarafından yorumlanacağı bu satırda belirtilmektedir. Siz burayı dilediğiniz gibi değiştirebilirsiniz. Örneğin merhaba.htm yapabilirsiniz. Dikkat etmeniz gereken bir nokta olarak dosya uzantısı .htm olaması söylenebilir. Unutmayalım Web.xml dosyasında dispatcher servlet için *.htm şeklinde bir desen belirlemiştik. Buna uymak zorundayız.
Bir sonraki satırda viewResolver sınıfının tanımlandığını görüyoruz. Bu çok önemli özellikle yapıyı idrak etme hususunda. class="org.springframework.web.servlet.view.InternalResourceViewResolver" Spring'in dahili kaynak görüntü çözümleyici sınıfı. p:prefix="/WEB-INF/jsp/" ve p:suffix=".jsp" satırları dışardan gelen istekleri uygulamamızın iç yapısında nereye karşılık geldiğini gösterir. prefix (öntakı) değeri ile görüntülerin dizinini suffix(son ek) ile yerel dosyaların uzantısını belirtiyoruz. Yani dışarıdan gelen index.htm şeklindeki bir sorgu dispatcher servleta söylediğimiz *.htm şeklindeki desene uygun olarak parçalanır ve index kelimesi görüntü olarak elde edilir. Bir önceki satırda belirtilen rotaya uyun olarak (index.htm -> indexController), bir sonraki satırda inceleyeceğimiz görüntü<->kontrollör tanımlaması ile index görüntüsü olduğu karar kılınır. Sonra /WEB-INF/jsp/index.jsp dosyası (indexController denetiminde) görüntü olarak açılır.
Bir sonraki satırda (az önce de söylediğim gibi) görüntü<->kontrollör tanımlaması yapılmakta. name="indexController" ile kontrollör adını, class="org.springframework.web.servlet.mvc.ParameterizableViewController" ile kullanılacak sınıfı (burada hazır sınıf kullandık, kendi sınıfımızı oluşturup bu sınıftan kalıtım da alabilirdik), p:viewName="index" ile görüntü adını belirtiyoruz.

Ayarlarla ilgili kısmı burada noktalıyorum. Bir sonraki yazımda görüntü ve kontrollör oluşturma ve kullanma konularına değineceğim inşallah. Anlatımda kusurum varsa affınıza sığınıyorum.
Görüşmek üzere...

Yığın Veri Yapısı

2010-05-16T00:48:00.008+03:00

Merhabalar,
Bu yazımda yığın veri yapısından bahsetmek istiyorum. Çalışması LIFO (Last In First Out - Son Giren İlk Çıkar) ilkesine dayanmaktadır. Fiziksel bir örnek vermek gerekirse yalnızca bir tek arabanın geçebileceği kadar genişlikte olan çıkmaz bir sokağa arabaların ard arda girmesi gibidir. Son giren araba ilk çıkmalıdır ki diğer arabalar çıkabilsin.

Peki Ne İşe Yarar?
Günümüzde bir çok sistem hafıza yönetiminde bu veri yapısını kullanmaktadır. Özellikle sıranın önemli olduğu durumlarda. Mesela, programlama dillerinde açtığımız parantezlerin kapatılıp kapatılmadığının kontrolü, işletim sistemi düzeyinde fonksiyonların çağrımı sırasında parametrelerin aktarımı, aritmetik işlemlerde işlem önceliğinin sağlanması ( çarpmanın toplamaya üstünlüğü), karakter katarlarının ters çevrilmesi vb. bir çok alanda kullanılmaktadır.

Teknik olarak açıklamak gerekirse...
Belirli bir hafıza bölgesini programcıdan soyutluyoruz. Direk erişimi engelliyoruz. Programcıya hafızaya erişmesi için fonksiyonlar veriyoruz. Bunlar push, pop ve isEmpty olabilir. Sırasıyla açıklayalım.

Push

Yığına bir eleman eklemek istediğimizde bu fonksiyonu çağırırız. Fonksiyona veridiğimiz değer yığının en sonuna eklenir.

Yığından bir eleman çekmek için kullanılır. Bu fonksiyon bize yığının en sonundaki yani son eklediğimiz elemanı yığından alır bize verir. Daha önceki elemanlara erişmek için Pop fonksiyonunu çağırmaya devam etmeliyiz. Bu fonksiyon herhangi bir parametre almaz.

isEmpty

Bu fonksiyon ile yığının boş olup olmadığını kontrol edebiliriz.
Siz fonksiyonlarınıza istediğiniz ismi verebilirsiniz. Korumanız gereken tek şey LIFO ilkesidir. Geri kalan kısmı değiştirmekte özgürsünüz.

Hemen Java ile bir örnekleme yapalım:


package test;

import java.util.ArrayList;

class Stack
{
 private ArrayList<Object> objectList; // nesneleri tutacak generic yapımız.
 
 public Stack()
 {
  objectList = new ArrayList<Object>(); // nesnemizi üretelim.
 }
 
 public boolean isEmpty()
 {
  return objectList.isEmpty(); // liste boş ise yığında boştur.
 }
 
 public void Push(Object obj)
 {
  objectList.add(obj); // yığına eleman ekleyelim.
 }
 
 public Object Pop()
 {
  if (objectList.isEmpty())
   return null; // yığın boş ise eleman çekemeyiz. Sonuç null değeri.
  Object o = objectList.get(objectList.size()-1); // sondan bir elemanı alalım.
  objectList.remove(objectList.size()-1); // sonra bu elemanı yığından çıkartalım.
  return o; // geriye döndürelim.
 }
}


public class Main{

 public static void main(String[] args) {

  Stack s = new Stack();
  if (s.isEmpty())
   System.out.println("yığın boş.");
  s.Push(5);
  if (s.isEmpty())
   System.out.println("bu satırı görmememiz gerekiyor.");
  s.Push(45);
  System.out.println(s.Pop());
  System.out.println(s.Pop());
  System.out.println(s.Pop());
  System.out.println(s.Pop());
  if (s.isEmpty())
   System.out.println("yığında eleman yok.");
 }

}

En basit haliyle böyle gerçeklenebilirdi sanırım. Veri yapılarını açıklamaya devam edeceğim.
Görüşmek üzere...

Intel 8085 Mikroişlemci / Başlangıç

2010-05-15T22:34:00.013+03:00

Herkese merhaba,
Bu yazımda Intel firması tarafından geliştirilmiş olan 8085 mikroişlemcisi yapısı, çalışma prensibi ve programlanması ile ilgili genel bilgi vereceğim. Başlıkta da belirttiğim gibi bu mikroişlemciler ve micro programlama konusuna girişimin imgesidir. Öncelikle bu basit mikroişlemciyi inceleyip programlamasına değineceğim. Daha sonra yine Intel firmasının 8051 mikrodenetleyicisinden bahsedeceğim. Daha sonraki yazılarımda sayısal sistemleri en başından alıp bir mikroişlemci nasıl çalıştığını anlatacağım. Daha sonra kendi mikroişlemcimi tasarlayacağım. Umarım atlamadan anlaşır bir biçimde anlatabilirim. Siz de üzerinde çalışıp kendi mikroişlemcinizi geliştirebilirsiniz.

Intel 8085 8-bit Microprocessor

Her konuda olduğu gibi bu konuda da tarihsel bilgilerle vaktinizi çalmak gibi bir niyetim yok. Merak edenler varsa http://en.wikipedia.org/wiki/8085 adresinden gerekli bilgileri alabilir. Programlama kısmına geçmeden önce işlemcinin yapısı hakkında bilgi vermek doğru olacaktır. Başlamadan önce belirtmeliyim. Bu yazımda sadece mikroişlemcinin yapısı ve programlamasından bahsedeceğim. Elektronik bir devrede nasıl kullanıldığından vb. diğer işlemlerden bahsetmeyeceğim. Genel olarak soyut sorunlar üzerinden yola çıkacağız.

Yukarıdaki şema mikroişlemcinin iç yapısını göstermektedir. Sırayla açıklayalım...

8 bit veri yolu

İşlemci birimleri arası haberleşmeyi sağlayan ortak kanal olarak tanımlanabilir. Bir seferde 8-bit veri taşıyabilir ve yalnızca tek bir birim kullanabilir. Bu birim kanala veriyi bırakır, veri yolunun bağlı olduğu tüm birimlere veri iletiri fakat yalnızca o anda ona ihtiyacı olan birim o veriyi kullanır. Tıpkı Ethernet (IEEE 802.3) protokolünde olduğu gibi. Burada farklı bir durum olarak veriyi kullanacak birimin aktif diğerlerinin pasif olamasını işlemci ayarlamaktadır. Toparlamak gerekirse, bir broadcast (yayın) tipi iletişim var fakat bu yayına yalnızca ilgili birim aldırış ediyor.

ALU (Arithmetic Logic Unit)

Diğer bir değişle Ardışıl Mantık Birimi. Bu birimde tüm mantıksak ve aritmetik işlemler yapılmaktadır. Toplama, çıkarma, karşılaştırma vb.

Accumulator (Akümülatör)

Temel kaydedici olarak tanımlasam çok yanlış olmaz sanırım. Tüm aritmetik işlem sonuçları bu kaydedicide saklanmaktadır. 8-bit veri saklayabilmektedir. Bir çok işlemde bu kaydedici kullanılmaktadır. Yeri geldikçe detaylandıracağım.

Instruction Register

Bu saklayıcı mikroişlemcinin işleyeceği komutu tutar. 8 bitliktir. Bu mikroişlemcinin 8 bit kelime işlemci olduğunu belirtmiştik. Bir seferde bir tek komutu işleyebilmektedir ve bu komut 8 bit (1 byte) olmak zorundadır. Zaten hafıza birimimizin (RAM / ROM) her bir gözü 1 byte boyutundadır.

Program Counter

İşlemcinin bir sonraki işleyeceği komutun adresini saklayan kaydedicidir. Boyutu 16 bittir. Buradan şu sonucu çıkartabiliriz, 8085 mikroişlemcisi 16 bit ile adreslenebilecek kadar hafıza alanında kod koşturabilmektedir. 2^16 ~= 64 kb hafıza alanı.

Stack Pointer

Yığın hafıza bölgesinin adresini tutar. Buraya FILO (First In Last Out - İlk Giren Son Çıkar) mantığıyla veri ekleyip çıkartabiliyoruz. Boyut 16 bit.

Flag Register

Bazı komutlar sonrasında durum kontrolü yapılması gerekmektedir. Örneğin bir toplama işleminde sonuç saklayıcının boyutunu aşabilir. Bu durumda işlemci kilitlenmez işleme devam eder, fakat programcı bu durumdan haberdar olması gerekmektedir. Programcı böyle bir durumun gerçekleşip gerçekleşmediğini Bayrak Saklayıcısındaki taşma bayrağının 1 - 0 durumunu inceleyerek anlayabilir. Bayraklardan kısaca bahsetmek gerekirse;
Sıfır Bayrağı = çıkarma işleminin sonucu 0 ise,
Taşma Bayrağı = toplama işlemi saklayıcıya sığmıyorsa, ya da çıkarılan çıkandan küçükse,
İşaret Bayrağı = Akümülatördeki sayı negatif ise (yani 8. bit 1 ise)
bu bayraklar 1 değerini alır. Aksi durumda 0 değerindelerdir.

Yazıma burada ara veriyorum. Bir sonraki yazımda kaldığım yerden tanıtmaya devam edeceğim. Daha sonra programlama kısmına geçeceğiz. Vaktim olursa bellek organizasyonu konusuna da değineceğim.
Görüşmek üzere...

Bağlı Listeler

2010-05-15T02:50:00.012+03:00

Merhabalar,
Bu yazımda sizlere bağlı liste veri yapısından bahsedeceğim. Veri yapısı deyince kulağa egzotik gelebilir. Ama inanın bildiğiniz şeylerden farklı bir şey anlatmayacağım. "Bildiklerimizi bir araya getirerek bilmediğimiz bir yapıyı tanımlama" şeklinde anlıyorum veri yapılarını...

Nedir? Neden gerek duyulmuştur?
Bağlı liste veri yapısı hafızanın farklı bölgelerinde bulunan verileri birbirine katar şeklinde bağlayan yapıdır.Dizi vb. yapılar zaten bu işi sağlamıyor mu? şeklinde bir soru aklınıza tam bu satırda gelmiş olmalı. Evet sağlıyor ama bir yere kadar. Diziler hafızanın belirli bir noktasında ardışıl olarak gelir. Yani dizinin ilk elemanı hafızanın 100 nolu adresinde bulunuyorsa dizinin ikinci elemanı 101 nolu gözde bulunacaktır. Ayrıca diziler ilk oluşturulduğunda uzunluğu belli olmak zorundadır. Daha sonra genişleme imkanı yoktur. Ancak tekrar boyutlandırma yapılabilir ki bu iş oldukça maliyetlidir. İşte böyle dinamik genişleyen ucuz maliyetli bir yapıya ihtiyaç duyulduğu sırada keşfedilmiş olmalı bağlı listeler.

Bağlı derken?
Bağlı listenin her bir elemanı hafızada birbirine bir sonraki elemanın aderesini gösterecek bilgiye sahiptir. Biz yalnızca ilk elemanın adresini biliriz. İkinci elemana ulaşmak için önce birinci elemana gideriz, ondan bir sonraki yani ikinici elemanın adresini alırız daha sonra ikinci elemana ulaşabiliriz. Üç, dört, beş ... hafıza dolana kadar üretilebilir, ulaşım mekanizması hep aynı. Bağlı derken bu mekanizma kastediliyor.

İhtiyaca göre...
Sorunlar farklı olunca çözümler, dolayısıyla gereksinimler de farklı oluyor. Bağlı liste veri yapısı iki çeşittir. Tek yönlü ve çift yönlü. İlkinde sadece ileri yönlü haraket yapmak mümkünken ikinci tipde geri gelme de mümkündür. Siz kendi probleminize en uygun tipi seçmelisiniz.

Bırak gevezeliği de biraz kod yaz!

Tek yönlü bağlı liste, C örneği


#include <stdio.h>
#include <stdlib.h>

typedef struct _eleman
{
 struct _eleman *sornakiEleman; // bir sonraki elemanı işaret eder.
 int veri; // yapının sakladığı veri. istenilen tipte istenildiği kadar veri eklenebilir.
} eleman;

typedef struct
{
 eleman *ilkEleman; // bağlı listeyi temsil eden yapı. Yalnızca ilk elemanı işaret ediyor.
} bagliListe;

bagliListe *bagliListeUret();
void elemanEkle(bagliListe*,int);
void elemanCikart(bagliListe*,int);
void listele(bagliListe*);

int main()
{
 bagliListe * bl = bagliListeUret(); // yeni bir bağlı liste ürettik.
 elemanEkle(bl,6); // eleman ekleyelim.
 elemanEkle(bl,34);
 elemanEkle(bl,987);
 elemanEkle(bl,5);
 elemanEkle(bl,2);
 listele(bl); // listele.
 system("pause");
 elemanCikart(bl,3); // 3. elemanı çıkart. ( ilk eleman 0'dan başlar)
 listele(bl); // tekrar listele, farkı gör.
 system("pause");
}

bagliListe *bagliListeUret()
{
 bagliListe* bl = (bagliListe*)malloc(sizeof(bagliListe)); // yeni bir bağlı listeyi hafızada oluşturup ilgili adresi alıyoruz.
 bl->ilkEleman = NULL;
 return bl;
}

void elemanEkle(bagliListe* bl,int veri)
{
 eleman *e = (eleman*)malloc(sizeof(eleman)); // yeni bir eleman oluşturalım.
 e->sornakiEleman = NULL;
 e->veri = veri;
 eleman *son = NULL; // katarın son elemanı.
 son = (eleman *)bl->ilkEleman; // başlangıç elemanını bağlı listeden alalım.
 if (son==NULL) // listemiz boş mu?
 {
  bl->ilkEleman = e;
  return;
 }
 while(son!=NULL) // değilse özyinelemeli olarak son elemana erişmeye çalış.
 {
  if (son->sornakiEleman==NULL)
   break;
  son = (eleman*)son->sornakiEleman; // düğümler arası atlama.
 }
 son->sornakiEleman = e; // nihayet son düğümün işaretçisine kendi adresimizi yazıyoruz.
}

void listele(bagliListe* bl)
{
 eleman *e = NULL;
 e=(eleman *)bl->ilkEleman;
 int i=0;
 while(e!=NULL) // özyinelemeli listeleme fonksiyonu.
 {
  printf("%i. eleman verisi = %i\n",i++,e->veri);
  e = (eleman*) e->sornakiEleman;
 }
}

void elemanCikart(bagliListe * bl, int sira)
{
 eleman *e = NULL;
 e=(eleman *)bl->ilkEleman;
 eleman *onceki = NULL;
 int i=0;
 if (e==NULL) // listemiz boş mu?
 {
  printf("Liste bos oldugu icin cikartma yapilamiyor!\n");
  return;
 }
 while(e!=NULL)
 {
  if (i==sira)
   break;
  i++;
  onceki = e;
  e = (eleman*) e->sornakiEleman; 
 }
 onceki->sornakiEleman = e->sornakiEleman; // silmek istediğimiz elemanın bir önceki düğümü ile bir sonraki düğümü birbirine bağlıyoruz. Böylelikle aradan çekilerek silinmiş izlenimi oluşturuluyor.
 free(e); // hafıza sızıntısını önlemek için serbert bıraktığımız elemanı hafızadan silmeyi unutmayalım.

}

Diğer yüksek seviyeli dillerde (Java, C# vb.) bu veri yapısını yapmak çok daha kolay. Mantıktan yola çıkarak o dillerde de sorunsuz bir şekilde bağlı liste veri yapısını oluşturabileceğinize inanıyorum.
Görüşmek üzere...

JQuery ve Sanat

2010-05-15T01:33:00.011+03:00

Tekrar merhaba,
Bu yazımda JQuery ile sanat nasıl yapılır konusuna ışık tutmaya çalışacağım. Sanat yapmak derken belki biraz abartmış olabilirim ama abartı çoğu insanın ilgilini çeken bir olgudur. Klasik, nedir - ne değildir zamazingosunu yapalım. Öncelikle resmi sitesini vererek kaynak belirtebiliriz - http://jquery.com/
not: indirirken size 2 seçenek sunmaktadır. Production / development şeklinde. Farkı, ilkinde gereksiz boşluk ve satır atlama karakterleri silinerek dosyanın boyutu küçültülmüş, bir nevi sıkıştırma yapılmış. Fakat kodun okunması neredeyse imkansız çünkü herşey birbirine geçmiş durumda. İkinci seçenekte ise kodlar okunaklı bir şekilde yayınlanıyor. Boyutu ilkine göre daha fazla ama bir geliştirici için çok değerli.
JQuery kütüphane içerisindeki kopyalama hakkı yazısını değiştirmediğiniz sürece ticari uygulamalarda dahi kullanabilirsiniz. Tamamen ücretsiz. Lisans detayları için resmi sitesinden bilgi alabilirsiniz.

Bu aralar çok duymaya başladım, nedir bu JQuery?
Özetle javascript yazımını kolaylaştıran kütüphane. İçerisinde bir çok javascript fonksiyonu barındırıyor. En önemli özelliği tarayıcı bağımsız olması. Yani JQuery ile yazdığımız javascript komutları tüm tarayıcılarda aynı şekilde sorunsuz olarak çalışmaktadır. Web ortamında javascript geliştirenler tarayıcı uyumsuzluğu sorununu bilmektedir. JQuery ile bu ortadan kalkmaktadır. Pratikte JQuery bize yeni birşey değil. Normal javascript komutlarıyla yapacaklarımızdan ötesi yok. O bize hızlı, güvenilir ve tarayıcı bağımsız javascript geliştirme imkanı sunmaktadır.

Hızlı bir giriş


 $(document).ready(function(){
   $("a").click(function(event){
     alert("Tum linkler bu yaziyi gosterir!");
   });
 });

Sırayla inceleyelim. Öncelikle $ karakterinden başlamak istiyorum. Bu fark edebileceğiniz gibi bir fonksiyon aslında. Bildiğimiz javascript fonksiyonu. JQuery için temel ifade ediyor. Tüm çağrılarımızı bu fonksiyon üzerinden yapıyoruz. Reguler Expression tanımlamalarını çok iyi kullandıkları için bu fonksiyonun içerisine verebileceğimiz parametrelerin sayısı oldukça fazla. $(document) ile javascript'in çalıştığı dosyayı seçiyoruz. Daha sonra gelen .ready(... ifadesiyle sayfamızın işlem için hazır olduğunu garantiliyoruz.
function() { } neden gerekli?
.ready olayında çalışmasını istediğimiz kodları direk parantez içerisinde yazsaydık kodumuz çalışmayacaktı. Çünkü JQuery çalışma mantığında bir iş yapmak için o işi yapacak fonksiyonun adını ilgili JQuery fonksiyonuna vermeliyiz. Aynı fonksiyon işaretçileri gibi ya da diğer bir benzetmeyle klasik setTimeout javascript komutunda olduğu gibi.
Şimdi biraz toparlayalım:
$(document) // sayfamız
.ready( // hazır olunca çalıştır
function() { ... } // yeni bir fonksiyon ürettik ve bağladık
);

İyi gidiyoruz, ya sonra?
Yeni oluşturduğumuz fonksiyonun içeriğini inceleyelim.
$("a") // a taglı elemanları seç.
.click( // tıklayınca çalıştır.
function() { ... } // yeni bir fonksiyon ürettik ve bağladık
);
Burada oluşturduğumuz fonksiyonun içerisine alert komutumuzu yerleştirdik.
Kodumuzu çalıştırdığımızda sayfamızdaki tüm linkler tıklandığında bu mesajı alacaklar.
Giriş olarak bu kadarla yetineceğim. Daha sonraki yazılarımda detaylı incelemeler ve yeni örnekler sunacağım.
Görüşmek üzere...

Spring Framework - Web MVC / NetBeans 6.8

2010-05-15T00:10:00.021+03:00

Herkese merhaba,
Bu yazımda sizlerle Spring Framework ile mvc web uygulamalarına giriş yapacağız. Amacım framework altyapısını uzun uzun anlatmak, çıkış hikayesi vb. yazılarla aklınızı karıştırmak değil. Detaylı bilgi almak isteyenler http://www.springsource.com/ adresinden ya da arama motorlarını kullanarak bilgi alabilirler. Arama yaptığınızda siz de anlayacaksınız, tüm sitelerde bu konuya giriş yapılmış. Framework alt yapısı çalışma mantığı anlatılmış fakat elle tutulur bir proje yok. En büyük sorun çalışan uygulama eksikliği. Elimden geldiğince sizlere gerçek şartlarda çalışan uygulamalar göstermeye çalışacağım.

Hangi IDE?
Ben bu örnekte Netbeans 6.8 üzerinden anlatacağım. Bu geliştirme ortamını seçmemin sebebi kolay olması. İçeresinde bir çok gerekli kütüphane hazır olarak geliyor. Olayı kavradıktan sonra Eclipse ile projelerimizi geliştirmeye devam edeceğiz. Buradaki tek amacımız Spring, IDE kaynaklı sorunlarla kafamızı yoramayız.

Ortamın Hazırlanması
Netbeans 6.8 Web EE içeren bir paketini kurmanız yeterli. Ayrıca Java kodlarının derlenmesi için JDK gerekli konumuz Java olmadığı için bundan bahsetme gereği duymuyorum.
File | New
Netbeans geliştirme ortamını açtıktan sonra yeni bir Dynamic Web Application projesi oluşturuyoruz.

Daha sonra dikkat etmeniz gereken tek nokta projemize dahil edeceğimiz kütüphanelerdir. Burada Spring Web MVC 2.5 seçeneğini işaretliyoruz.

Finish diyerek projemizi oluşturuyoruz. Sonra karşınıza şu şekilde bir görüntü çıkmalı.

Şimdi projemizi Run menüsünden ya da F6 kısayol tuşu ile çalıştıralım. Karşınıza aşağıdaki gibi bir ekran çıktıysa merak etmeyin doğru yoldasınız :)

Dur bir dakika! Burada neler oluyor?
Hemen izah edeyim. Az önce bir Spring Web MVC projesi oluşturduk. Netbeans bizim yerimize varsayılan bazı ayarlamaları ve iskelet yapıyı oluşturdu. Bu Netbeans'in özelliği. Sol taraftaki klasör yapısına bakmamız yapıyı anlamada faydalı olacaktır. Web Pages klasörü altında WEB-INF, META-INF klasörleri ve redirect.jsp dosyası var. WEB-INF ve META-INF dışarıdan erişilemeyen (dışarıdan derken, projeyi siteye yüklediğimizde internetten sitemize giren kullanıcıları kastediyorum) özel ayar klasörleridir. Bu klasörlerden bahsetmeden önce ana dizinde bulunan tek dosya olan redirect.jsp ye bakalım. Bildiğimiz gibi Java Dynamic Web projelerinde bütün JSP dosyaları Web Pages altında olurdu ve biz buradaki dosyalara web tarayıcımız vasıtasıyla erişebiliyorduk. Fakat burada yalnız bir dosya var? Öyle ise hemen merakımızı redirect.jsp dosyasına bakarak giderelim.

Buyurun efendim:

Hiçbir şey anlamadım?
Kesinlikle çok saçma! index.htm nerede? Olmayan bir dosyaya yönlendirme mi yapılıyor? Burada bir gariplik var sanki. Evet durum biraz garip ama biraz incelediğimizde ve detaylara dikkat ettiğimizde aslında ne kadar güzel bir yapı olduğunu daha iyi anlayacağız. Burada index.htm dosyasına yönlendirerek aslında index.htm dosyasını açmıyoruz, index adındaki görüntüyü çağırıyoruz.
Görüntü mü? Nasıl yani?
MVC tasarım şablonunun (Model View Controller) ortasındaki View olayından bahsediyoruz. Bu tasarım desenini anlamak biraz sancılı olabilir ama anladıktan sonra hele bir de nimetlerinden faydalandıktan sonra ne kadar güzel bir şey olduğunu siz de anlayacaksınız. Görüntü dediğimiz kavram, önceden hazırlanmış tasarım dosyalarıdır. Herbiri bir controller nesnesine bağlıdır. Onun yetkisi olamadan ilgili görüntüye erişmek mümkün değildir.
İyice karıştı, Controller derken?
Controller sınıflar görüntüleri kullanıcıdan gelen talepler doğrultusunda göstermek ve şekillendirmek adına geliştirilmiştir. Daha detaylı bilgiyi ilerleyen kısımlarda vereceğim.

Tamam ama hâlâ olmayan bir index.htm dosyasını nasıl açtığımızı anlayamadım?
Sır perdesi WEB-INF klasörünü açmamızla aralanacaktır. Bildiğimiz gibi WEB-INF klasörü özel bir ayar klasörü.

xml uzuntılı dosyalar ayarlama için gerekli dosyalar. Sorumuzun cevabı ise jsp klasörü altında gizli. Evet haklısınız, index.jsp :D
Görüntü dosyalarımızı bu klasör altına atmamızın sebebi dış dünyadan soyutlamak. Yalnızca controller nesnesi tarafından erişilmesini sağlamak için yapılmış bir sarmalama mekanizması. Zekice!
Hmm.. Peki ya uzantı?
Sizden de hiçbir şey kaçmıyor :) ama yine de dikkatsizsiniz. Projemizi ilk oluşturduğumuz zamana geri dönelim. Orada Spring Web MVC 2.5 kütüphanesini seçerken Dispatcher Mapping: *.htm şeklinde bir desen girmiştik. İşte bu *.htm şeklinde gelen istekleri .jsp uzantılı görüntülere aktarılmasını sağlıyor. Bu desen çok farklı şekilde olabilir bunları daha sonra inceleyeceğiz. Tüm bu ayarlar WEB-INF altındaki xml uzantılı dosyalarda tanımlanıyor. Bu konuya da daha sonra değineceğim.
Kafam karıştı, böylece bırakıp gidemezsin!
Bu yazımı burada noktalayacağım. Amacım çalışan örneklerle bu konuya değinmekti. Tam olarak hedefime ulaştığım söylenemez, fakat parça parça anlatmak daha faydalı olacak gibi. Konu hakkında yazmaya kaldığım yerden devam edeceğim.
Görüşmek üzere...

Dynamic-Link Library (DLL) / Giriş

2010-04-27T23:53:00.020+03:00

DLL dosyaları Microsoft'un Windows ve OS/2 işletim sistemleri için gerçeklediği kütüphane paylaşım konsepti olarak tanımlanabilir. Bu kütüphaneler genellikle DLL, OCX ya da DRV uzuntasındadır.

DLL dosyaları aynen EXE dosyaları gibi kod, veri ve kaynak bölümlerine (ve bunların herhangi bir kombinasyonunda) olabilir.

Windows işletim sisteminin ilk sürümlerinde tüm programlar tek bir bellek bölgesinde koşturuluyordu. İşletim sistemi düzeyindeki tüm işlemler MS-DOS tarafından gerçekleştirilirken yüksek seviyeli hizmetler Windows DLL leri tarafından sağlanıyordu. Çizim API'leri yani GDI.EXE, kullanıcı arayüzü işlemleri USER32.EXE adlı kütüphane dosyasında gerçeklenmiştir.

Günümüzde daha farklı bir yaklaşım kullanılmaktadır. Sistem tarafından sunulan kütüphaneler uygulamalara ayrı ayrı yüklenmektedir. Korumalı modda olduğu için bir program başka bir programın hafıza alanına doğrudan bir müdehalede bulunamıyor.

Assembly dilinde basit bir mesaj gösteren DLL uygulaması şu şekilde olabilir:


.386 ; intel x86 architecture
.model flat,stdcall ; use flat memory management
option casemap:none ; ignore letter case

include \masm32\include\windows.inc 
include \masm32\include\user32.inc ; for MessageBox func.
include \masm32\include\kernel32.inc

includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib

.data
message db "Test message...",0 ; content of our simple message

.code
DllEntry proc hInstance:HINSTANCE, reason:WORD, reserved1:WORD ; DLL entry point function
mov eax,TRUE
ret
DllEntry Endp

SimpleMessage proc
invoke MessageBox,NULL,addr message,NULL,MB_OK ; win32 MessageBox func.
ret
SimpleMessage Endp

End DllEntry

Bu programı derlemek için birde def dosyası oluşturmalıyız. Bu dosyada 2 satır bilgi gerekiyor. Birinci satırda kütüphanenin ismini ikinci satırda ise kütüphaneden dışarı aktarılacak yani diğer programların hizmetine sunuculacak olan fonksiyonların isimleri.

örnek olarak


LIBRARY Simple
EXPORTS SimpleMessage

Projemizi derlemek için komut satırına bazı komutlar girmemiz gerekecek. Bu işlemin otomasyonu için şöyle bir batch dosya oluşturabiliriz.


c:\masm32\bin\ml.exe /c /coff /Cp "%CD%\Simple.asm"
c:\masm32\bin\link.exe /DLL /DEF:"%CD%\Simple.def" /SUBSYSTEM:WINDOWS /LIBPATH:c:\masm32\lib "%CD%\Simple.obj"

Not: Bu uygulamayı derleyebilmeniz için sisteminizde Masm32 derleyicisi yüklü durumda olmalıdır. http://www.masm32.com/

Şimdi oluşturduğumuz bu DLL dosyasını başka bir programdan çağıralım. Bunun için çağırı yapacak programımızı derlerken DLL dosyamızın yapısını bildirmek üzere bir .lib dosyası vereceğiz. Bu dosya DLL projemizi derlerken derleyici tarafından otomatik olarak oluşturulmaktadır.

Kısa basit bir örnek:


.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
includelib Simple.lib ; lib file of Simple.dll to inform linker 
includelib \masm32\lib\kernel32.lib

SimpleMessage PROTO ; name of the function in DLL

.code
start:
        invoke SimpleMessage ; invoke the function in DLL
        invoke ExitProcess,NULL ; terminate process
end start

Şimdi benzer bir çağırı programını C++ dilinde dinamik çağırma yöntemiyle yapalım.


#include <stdio.h>
#include <windows.h>

typedef void (WINAPI *SimpleMessage)(); // type defination to call dll function.

int main(int argc, char **argv)
{
 HINSTANCE hDLL = LoadLibrary(L"simple.dll"); // loads our DLL into application memory section.
 SimpleMessage sm = (SimpleMessage)GetProcAddress(hDLL,"SimpleMessage"); // gets address of our function in the dll.
 if (!sm) // function address validation.
 {
  printf("Couldn't load library!\n");
 }
 else
 {
  sm(); // simple call.
 }
 return 0;
}

C# tarafında işler çok daha kolay:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace SimpleCall
{
    class Program
    {
        [DllImport("simple.dll")]
        static extern void SimpleMessage();

        static void Main(string[] args)
        {
            SimpleMessage();
        }
    }
}

Java tarafında direk bir erişim şekli mevcut değil. Bunun yerine bazı 3. parti kütüphaneleri kullabiliriz. Bunlar JNI (Java Native Interface) tabanlı kütüphaneler. Biz bu örnekte JNA (Java Native Access) kullanacağız.

Bu kütüphanenin açıklamasını daha önceki bir yazımda (Bkz: http://rbellek.blogspot.com/2010/04/java-native-access-basit-ornek.html) bahsettiğim için burada yüzeysel geçiyorum.

Örnek uygulama:


//Main.java
package simple;

import com.sun.jna.Native;

public class Main {

    public static void main(String[] args)
    {
        Simple simpleDLL = (Simple)Native.loadLibrary("e:\\Simple.dll", Simple.class);
        simpleDLL.SimpleMessage();
    }
}


//Simple.java
package simple;

import com.sun.jna.Library;

public interface Simple extends Library {
    void SimpleMessage();
}

DLL dosyasının aynı EXE dosyaları gibi bir giriş noktları mevcuttur. Bu noktanın adı DllEntry adlı bir fonksiyondur. Ve giriş parametreleri olarak şu 4 değerden birini almaktadır.

DLL_PROCESS_ATTACH
DLL_PROCESS_DETACH
DLL_THREAD_ATTACH
DLL_THREAD_DETACH

Basit bir toplama kütüphanesi:


.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib

.data
AppName db "Simple 2",0
HelloMsg db "Hello, you're calling a function in this DLL",0
LoadMsg db "The DLL is loaded",0
UnloadMsg db "The DLL is unloaded",0
ThreadCreated db "A thread is created in this process",0
ThreadDestroyed db "A thread is destroyed in this process",0

.code
DllEntry proc hInstance:HINSTANCE, reason:DWORD, reserved1:DWORD
 .if reason==DLL_PROCESS_ATTACH
  invoke MessageBox,NULL,addr LoadMsg,addr AppName,MB_OK
 .elseif reason==DLL_PROCESS_DETACH
  invoke MessageBox,NULL,addr UnloadMsg,addr AppName,MB_OK
 .elseif reason==DLL_THREAD_ATTACH
  invoke MessageBox,NULL,addr ThreadCreated,addr AppName,MB_OK
 .else        ; DLL_THREAD_DETACH
  invoke MessageBox,NULL,addr ThreadDestroyed,addr AppName,MB_OK
 .endif
 mov  eax,TRUE
 ret
DllEntry Endp

Addition proc param1:DWORD, param2:DWORD
 mov ebx,param1
 mov eax,param2
 add eax,ebx
 ret 
Addition endp
End DllEntry

Bu toplama fonksiyonunu (parametreli) çağıran C++ uygulaması:


#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

typedef int (WINAPI* Addition)(int,int); // two DWORD (32-bit integer) in parameters
           // WINAPI same as __stdcall
              // __stdcall gives order of parameters in stack
int main(int argc, char **argv)
{
 HINSTANCE hDLL = LoadLibrary(L"calculator.dll");
 Addition addition = (Addition)GetProcAddress(hDLL,"Addition");
 if (!addition)
 {
  printf("Couldn't load library!");
 }
 else
 {
  printf("5 + 9 = %i",addition(5,9)); // simple two parameter call
 }
 return EXIT_SUCCESS;
}

Şimdilik basit bir girişle yetiniyorum. Umarım devamında detaylandırabilirim...

Java Native Access Basit Örnek

2010-04-04T16:04:00.014+03:00

Java ile program geliştirmek çok rahat ve güvenilir olabilir. Fakat diğer tüm yorumlamaya dayalı diller gibi(C# vs.) Java'da doğrudan makine diline çevrilen programlama dilleri kadar hızlı değildir. Hız söz konusu değilse tabiki hiç bir sorun yok. Fakat bizim için hız önemli olduğunda ne yapacağız?
a)Java vb. dilleri bırak, C/C++ ya da Delphi gibi dilleri kullan.
b)Kullandığın dillerden vazgeçme gerekli bölgeyi soyutla.

Ben b şıkkını seçiyorum :) Peki b şıkkında anlatamak istediğim nedir?

Örneğin bir program geliştreceğiz. Bu programda çok ağır matematiksek işlemler var. Bunları Java ile yaptığımız zaman istediğimiz sürede istediğimiz verimlilikte sonuçlar alamıyoruz. Öyle ise bize sıkıntı çıkartan kısmı alıp, C/C++, Delphi ya da bir başka donanıma yakın olan bir dil ile yazıyoruz. Bu yazdığımız bölümü DLL olarak oluşturuyoruz. Artık tek yapmamız gereken Java projemizden bu DLL içerisindeki gerekli fonksiyonları zamanı geldiğinde çağırmak.

Bunu yapmamız için Sun Microsystems tarafından yazılmış bir kütüphane mevcut. JNA (Java Native Access). Bu kütüphane ile sabit disk üzerideki (başka bir dil ile yazılmış) DLL dosyalarındaki fonksiyınları çağırabiliyoruz.

Şimdi yamamız gereken temel adımlardan bahsedeyim.

1) Bir java projesi oluşturalım.
2) https://jna.dev.java.net/ adresinden JAR dosyasını sabit diskimize indirelim.
3) İndirdiğimiz kütüphaneyi projemize ekleyelim.
(NetBeans 6.8 için ekleme)
Libraries (sağ tık) -> Add JAR/Folder...

4) Projemizde bir interface oluşturarak kullanacağımız fonksiyonların tanımlamasını yapmalım.
5) İhtiyacımız olan fonksiyonu çağıralım. :)

Örnek bir kod parçası:


import com.sun.jna.*;

public class testMessage {

    public interface Simple extends Library
    {
        public void TestMessage();
    }

    public static void main(String[] args)
    {
        Simple dll = (Simple)Native.loadLibrary("Simple.dll", Simple.class);
        dll.TestMessage();
    }

}

Bu kadar basit. JNA ile yalnızca Windows değil MacOS X, Linux ve Unix platformlarında da çalışabilirsiniz. Yanlız hata kontrolünü çok iyi tutmak gerekiyor. Lakin benim bir kaç denememde JVM (java.exe) çökmesi gibi durumlarla karşılaştım. Çünkü direk düşük seviye işlemleri yapılıyor. Java için son olarak birde JNI (Java Native Interface) var. Kendi yazdığımız C programlarına direk erişim için. Onu kısmet olursa başka bir zaman anlatmayı düşünüyorum.

C# tarafında da aynı olayın mümkün olduğunu söyleyebilirim. Orada işler biraz daha basit. Herhangi bir kütüphane kullanmanıza gerek yok. Yapı şu şekilde:


[DllImport("Simple.dll")]
static extern int TestMessage();

static void Main(string[] args)
{
     TestMessage();
}

Sonuç olarak Java, C# vb. dillerin görsellik, güvenilirlik ve diğer mükemmel özelliklerini alıp, hantallık gibi diğer kötü özelliklerini bu sistemle değiştirmiş oluyoruz. Her sistemin güzel özelliğini bir araya getirerek çok kaliteli ürünler ortaya çıkarmak mümkün.

Cesar Algoritması Spam Postalara Karşı

2010-04-04T04:37:00.015+03:00

Herkese merhaba,

Sanırım herkesin ortak derdidir önemsiz (spam) postalar. En büyük sıkıntı e-posta aderesimizi bir kere kötü insalara kaptırdığımızda artık geri dönüşü olmayan bir gereksiz e-posta yağmuruna tutuluyoruz. Birçok yöntem olmasına karşın ben burada sizlere bir web geliştirici olarak sitemizde yayınlayacağımız e-posta adreslerini spam mail atanlardan nasıl koruyacağımızı basit bir yöntemle anlatmaya çalışacağım.

Sitemizde yayınladığımız e-posta adresleri özel geliştirilmiş programlar tarafından taranıp toplanıyor. Daha sonra spam listesine yeni bir kurban olarak ekleniyor. Peki bunun önüne nasıl geçilebilir? İlk akla gelen mail adresimizi bir resim olarak yerleştirmek ya da bozuk bir formatta email (at) domain.com gibi kullanmaktır. Böyle yapmak bir çözüm olabilir. Ama biz direk sayfamızda mail adresinimiz görünsün ya da mailto: şeklide link vermek istiyorsak ne yapmalıyız?

Bilgi Günveliği Seminerinde Huzeyfe Önal'ın bahsettiği bir yöntem vardı. Sayfa üzerinde normal mail adresleri dışında bir de spam@domain.com gibi bir adres daha veriyormuş. Böylelikle normal adreslerin yanında bu adresi de listeye ekleyen spam mesaj gönderici programlar bu adresede reklam içerikli mail atıyorlar. Yalnız şöyle bir sistem geliştirmiş kendileri; o mail hesabına mail atan tüm mail adresleri kara listeye alınıyormuş. Böylelikle diğer adresler en fazla 1 tane spam alıyorlar. Zekice ve etkili bir yöntem olabilir. Ama ben hem maliyetli buluyorum hem de her ne koşulda olursa olsun mail adresimin spam uygulamaları tarafından yakalanmasını istemiyorum.

Peki ne yapabiliriz? Spam robotları sayfalar üzerinde düz yazıları okurlar. Resim, ses, video ya da çalıştıralabilir kodları (javascript, vb.) okuyamazlar ( en azından şimdilik:) ). Bu noktadan hareket edersek biz e-mail aderesinimizi basit bir Cesar algoritmasıyla şifreleyip istemc tarafında javascript ile çözümlersek hem robotları atlatmış oluruz hem de kullanıcıya korkmadan mail adresimizi sunmuş oluruz.

Ben bir örneği PHP dilinde vereceğim. Siz istediğiniz dil ile istediğiniz platformda gerçekleyebilirsiniz.


<?php
$xor_key = 19;
$email = '<a href="mailto:epostam@websitem.com">epostam@websitem.com</a>'; 
  $sonuc ="";
  for($i=0; $i<strlen($email); $i++)
  {
   $sonuc.= chr(ord($email[$i]) ^ $xor_key);
  }
?>


<script language="javascript">
function decrypt()
{
 var obje = document.getElementById('e_pos_ta');
 var text = "<?php echo str_replace('"','\"', $sonuc); ?>";
 var code="";
 for(var i=0; i<text.length; i++)
 {
  code+=String.fromCharCode(text.charCodeAt(i) ^ <?php echo $xor_key; ?>);
 }
 obje.innerHTML = code;
 
}
</script>


<body onload="decrypt()">
...

<span id="e_pos_ta"><?php echo htmlspecialchars($sonuc); ?></span>

Ben algoritmayı biraz değiştirdim. Cesar kusura bakmasın :) Harfleri kaydırmak yerine basit XOR işlemi uyguladım. İsterseniz algoritmayı karıştırıp işi daha da zorlaştırabilirsiniz. Spam robotları artık sitenizdeki eposta adreslerini göremeyecekler.