#coding = utf-8 turkishConsonants = ['b', 'c', 'ç', 'd','f','g','ğ','h','j','k','l','m', 'n','p','r','s','ş','t','v','y','z'] word = "ağla" print word[-3] in turkishConsonants

The reason for this was the letter ‘ğ’ is stored as two array elements and word[-3] returns only half of it. Proper way to make comparison is [...]]]> I realized in some part of a program of mine following statements print False:


#coding = utf-8
turkishConsonants = ['b', 'c', 'ç', 'd','f','g','ğ','h','j','k','l','m',
'n','p','r','s','ş','t','v','y','z']
word = "ağla"
print word[-3] in turkishConsonants


The reason for this was the letter ‘ğ’ is stored as two array elements and word[-3] returns only half of it.
Proper way to make comparison is decoding the string before indexing. So fixed version is


#coding = utf-8
def contains(charArray,letter):
for c in charArray:
if(letter == c.decode('utf_8')):
return True
return False

turkishConsonants = ['b', 'c', 'ç', 'd','f','g','ğ','h','j','k','l','m',
'n','p','r','s','ş','t','v','y','z']
word = "ağla"
letter = word.decode('utf_8')[-3]
print contains(turkishConsonants,letter)


The situation is similar while calling len() on a string, make sure to decode it first in such sensitive cases.

When these classes are prepared, other classes can subscribe to events  by providing their event listener.

An event class must extend java.util.EventObject class. Below you [...]]]> To create custom Java events we need basicly three classes:

1. The event class which will be fired
2. An interface which indicating responsibility of event listeners of this event
3. The class which fires the Java events

When these classes are prepared, other classes can subscribe to events  by providing their event listener.

An event class must extend java.util.EventObject class. Below you can see an event class example which I used in an application that exchanges messages over TCP/IP sockets.


package prototype.communication.events;

public int getEventType() {
return eventType;
}
}


Coding the interface is usually trivial, note that this interface must extend java.util.EventListener interface which is a tagging interface.


package prototype.communication.events;

/**
*
* @author Server
*/
public interface CommunicationEventListener extends EventListener{
public void communicationEventReceived(CommunicationEvent event);
}


The third class which will fire should provide following functions to enable other class to subscribe to events:


public synchronized void addEventListener(CommunicationEventListener l);
public synchronized void removeEventListener(CommunicationEventListener l);


Following field can be used to store event listeners:

private List eventListeners;

Then implementation of add and remove functions follows intuitively:

public synchronized void addEventListener(CommunicationEventListener l) {
eventListeners.add(l);
}

public synchronized void removeEventListener(CommunicationEventListener l) {
eventListeners.remove(l);
}


Whenever this class needs to fire an event it will iterate over listeners and will call communicationEventReceived method of EventListener interface. You can see an example function that fires an event:


private synchronized void fireCommunicationEvent(int eventType) {
CommunicationEvent event = new CommunicationEvent(this, eventType);
Iterator listeners = eventListeners.iterator();
while (listeners.hasNext()) {
listeners.next().communicationEventReceived(event);
}
}


In a DL Safe rule execution, only explicitly named individuals are bound to the variables in the rule.

Lets say we have a transitive object property named ancestorOf.

Can we simulate this transitivity using a DL-Safe SWRL rule rather than defining the ancestorOf property as transitive?

At [...]]]> Here is a simple example to understand the meaning of DL Safety.

In a DL Safe rule execution, only explicitly named individuals are bound to the variables in the rule.

Lets say we have a transitive object property named ancestorOf.

Can we simulate this transitivity using a DL-Safe SWRL rule rather than defining the ancestorOf property as transitive?

At the first glance it seems possible since transitivity is simply: transitive_property(?X, ?Y), transitive_property(?Y, ?Z) –> transitive_property(?X, ?Z)

To illustrate more clearly lets create the following ontology. I used Protégé 4.0 and Pellet Reasoner Plug-in 1.0 for Protégé.


test:AncestorOfOlympian
a owl:Class ;
owl:equivalentClass
[ a owl:Restriction ;
owl:onProperty test:ancestorOf ;
owl:someValuesFrom test:Olympian
] .test:Olympian
a owl:Class .test:AncestorOfChronos
a owl:Class ;
owl:equivalentClass
[ a owl:Restriction ;
owl:hasValue test:Chronos ;
owl:onProperty test:ancestorOf
] .
a owl:Ontology .test:ancestorOf
a owl:TransitiveProperty , owl:ObjectProperty .test:Uranus
a owl:Thing ;
test:ancestorOf test:Chronos .

As expected the inferred class hierarchy is :

Now remove the transitive characteristic of ancestorOf. And Add the rule shown below.

Now classify the ontology again and look at the inferred class hierarchy.

In the first case the inference mechanism determines that AncestorOfOlympian is a super class of AncestorOfChronos.

Because Chronos is already an ancestor of some unknown individual of type Olympian and ancestorOf is transitive, then ancestor of Chronos is already an ancestor of Olympian.

Also Uranus is listed as an instance of AncestorOfOlympian.

In the second case , since there is no individual of Olympian is present, the inferences mentioned above can not be done.

Note that if we add an instance of Olympian (e.g. Zeus) and make Chronos ancestor of Zeus then Uranus is listed as an instance of AncestorOfOlympian however the inferred class hierarchy remains unchanged.

P.S. This example is a simplified version of weblog entry of Bijan Parsia.

First lets have a look at basics of java character encodings.

Having BlazeDS deployed on an application server (Tomcat is used here) , following steps shows the server and client side coding for a simple scenario where a flex application is used to display instances of  Person and [...]]]> Remoting Object Service of BlazeDS , is used for making remote procedure calls from Flex applications to Java Server.

Having BlazeDS deployed on an application server (Tomcat is used here) , following steps shows the server and client side coding for a simple scenario where a flex application is used to display instances of  Person and Car classes send by Java Web Application as a result of remote procedure call.

Server Side Coding and Configuration

Net Beans is used for creating Java Web Application. Here are the classes of the application

Class definition of the Java class of which methods will be invoked from Flex application must conform following specification :

• Access modifier of the class must be “public”
• Access modifier of the methods to be invoked must be “public”

Here is my deneme.Manager class that will send some Person instances to Flex application :


package deneme;

There are two things left to do on the server side :

• Copy the folders under directory {Project_Root}/build/web/WEB-INF/classes to {BlazeDS_Root}/WEB-INF/classes
• Add the following XML element as a child of {BlazeDS_Root}/WEB-INF/flex/remoting-config.xml ‘s “service“ element

Client Side Coding

I used a flex project with J2EE as server technology and LiveCycle Data Services as remote object access service with following server configuration :

• Root Folder   : {BlazeDS_Root}
• Root URL      : http://{host}:{port}/blazeds
• Context Root : /blazeds

The only thing we need to make remote procedure call is to create a mx.rpc.remoting.RemoteObject in ActionScript and call getPersons() method.

The call is asynchronous and server will respond this call in one of following forms (How to handle these events are shown in the code) :

• An mx.rpc.events.ResultEvent of which result field  contains the return value of the invoked method
• An mx.rpc.events.FaultEvent if any error occurs during remote procedure call

Here is the .mxml and .as files of the Flex application:




import deneme.Car;
import mx.events.ListEvent;
import mx.events.DataGridEvent;
import mx.controls.Alert;
import mx.rpc.events.FaultEvent;
import mx.rpc.events.ResultEvent;
import mx.rpc.remoting.RemoteObject;
import mx.collections.ArrayCollection;
import deneme.Person;


package deneme
{
//Remote Class alias should be the fully qualified name of the Remote Class
[RemoteClass(alias="deneme.Car") ]

}
}


package deneme
{
import mx.collections.ArrayCollection;

}
}


Here is the .java files for Person and Car

package deneme;


package deneme;

java.awt.Robot class can be used to generate false input in Java. You can [...]]]> Too many clicks are needed while playing games like farmville. To this automatically, firstly I used a tool named xdotools which generates false keyboard and mouse input. But, since xdotools only supports X11, I switched to Java to have a platform independent program.

java.awt.Robot class can be used to generate false input in Java. You can easily imitate effects of moving mouse, rotating mouse wheel, pressing keyboard buttons or mouse buttons by utilizing this class.

Below, you can see a very simple Java program that moves mouse and clicks.

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.InputEvent;

public class Main {

        public static void main(String[] args) throws AWTException {
                Robot robot = new Robot();

                robot.mouseMove(100, 100); //move mouse
                robot.mousePress(InputEvent.BUTTON1_MASK); //press left button of mouse
                robot.mouseRelease(InputEvent.BUTTON1_MASK); //release left button
        }
}

Here is the full code for a farm of one of my friends.


package farmville;

λx.λy.+ x y,

intermediate expressions like

S (S (K S) (S (K (S (K +))) (S (λx K) (λx x)))) (λx I)

can be encountered. While dealing with such expression text [...]]]> While dealing with lambda calculus expression that I mentioned in my previos post, from time to time many paranthesis appears. Exampli gratia: While trying to SKI equivalent of

λx.λy.+ x y,

intermediate expressions like

S (S (K S) (S (K (S (K +))) (S (λx K) (λx x)))) (λx I)

can be encountered. While dealing with such expression text editor of KDE named Kate may help you. Use highlighting support of Kate for Scheme language which colors nested paranthesis with seven different colors. To enable this feature select Tools->Highlighting->Scripts->Scheme from menu of Kate. The same effect can also be achieved by changing extension of the file you are working on to “scm”, “scheme”, “guile” or “ss”.

You can see calculation of SKI equivalent of λx.λy.+ x y with colored paranthesis

S x y z = x z (y z)

K x y = x

I x = x

Apply following transformations to lambda calculus expression until the expression becomes free of lambda abstractions and variables.

1) λx.e1 e2 => S (λx e1) (λx e2)

2) λx.x => I

3) λx.c => K c [Here, c should [...]]]> Define S, K and I as

S x y z = x z (y z)

K x y = x

I x = x

Apply following transformations to lambda calculus expression until the expression becomes free of lambda abstractions and variables.

1) λx.e1 e2 => S (λx e1) (λx e2)

2) λx.x => I

3) λx.c => K c [Here, c should not contain any free variable x.]

E.g.:

Lets find SKI equivalent of λx.+ x x

Since function application is left-associative in lambda calculus

λx.+ x x = (λx(+x) x)

Apply transformation 1:

(S (λx + x) (λx x))

Apply transformation 1, again:

(S (S (λx +) (λx x)) (λx x))

Appyle transformation 3,2 and 2 again:

(S (S (K +) I) I)

We are done, since we have a variable and lambda abstraction free expression. Now we can check our result by applying a number.

For example, apply 3:

(S (S (K +) I) I) 3 [Use definition of combinators to evaluate this expression. We began with S x y z = x z (y z)]

(S (K +) I 3) (I 3)

(K + 3) (I 3) (I 3)

+ 3 3

6