Today's post presents a predicate defined for lists that is as simple as yesterdays rem_dups/2. flatten/2 is concerned with flattening an arbitrary list to a one-dimensional list/array.The idea behind flatten is pretty simple, i.e. if a list is non-flat we lower its dimensionality by taking theinner of that list and process it further until we reach a one-dimensional list.
%flatten/2
flatten([], []).
flatten([[]], []).
flatten([[HT]], X) :- flatten([HT], X).
flatten([[H]T], X) :- flatten([HT], X).
flatten([H[T]], X) :- flatten([HT], X).
flatten([HT], X) :-
flatten(T, Y),
append([H], Y, X).
Now, that we know how to inspect the type of some Prolog symbol, we may take a look onto today's task. Given some summation, the task is to simplify this summation, using some predicate called simplify_sum or simp_sum (for short).
For example:
So in short, the summation should be ordered with atoms first and aggregated numbers last. The original task by Bratko is concerned with the aggration of atoms as well, such as x +x = 2*x, but I will keep this for the next post.
So based on the above statement of the problem, we must consider some elementary cases, such as:
These cases will act as the recursion anchor in our simp_sum clauses. Based on this reduction to the simplest form of the problem (please note, that we do not consider a case where only one atom or one number is passed to simp_sum), we identify more advanced incarnations of the problem.
We must consider the following:
cases as well. The reason for compound term occuring only on the left-hand side is the associativity of the + operator. For example. 3 + 4 + 5 is (3 + 4) + 5 and consuequently we have 3+ 4 +5 = compound + number where compound = number + number.
Putting together all this information we might come up with the following ...
simp_sum(X + Y, R) :- number(X), number(Y), R is X + Y.
simp_sum(X + Y, X + Y) :- atom(X), number(Y).
simp_sum(X + Y, Y + X) :- atom(Y), number(X).
simp_sum(X + Y, X + Y) :- atom(X), atom(Y), X \== Y.
%Result of simpsum is not compound
simp_sum(X + Y, Z) :-
simp_sum(X, X0), number(X0), number(Y), Z is X0 + Y.
simp_sum(X + Y, Y + X0) :-
simp_sum(X, X0), number(X0), atom(Y).
%Result of simpsum is compound
simp_sum(X + Y, A + Y0) :-
simp_sum(X, X0), number(Y), X0 = A + B,
number(B), simp_sum(B+Y, Y0).
simp_sum(X + Y, A + B + Y) :-
simp_sum(X, X0), number(Y), X0 = A + B, atom(B).
simp_sum(X + Y, A + Y + B) :-
simp_sum(X, X0), atom(Y), X0 = A + B, number(B).
simp_sum(X + Y, A + B + Y) :-
simp_sum(X, X0), atom(Y), X0 = A + B, atom(B).
When Prolog is asked:
simp_sum(1 + b + 2 + c + a + 4 + d + 39 + e+ f + 122, X).
It answers correctly:
X = b+c+a+d+e+f+168 .
%power/3
power(X, 0, 1).
power(X, 1, X).
power(X, Y, Z) :-
Y1 is Y - 1,
power(X, Y1, Z1),
Z is X * Z1.
%power10/2
power10(P, R) :- power(10, P, R).
%power2/2
power2(P, R) :- power(2, P, R).
:- dynamic(fib/2).
fib(0, 1).
fib(1, 1).
fib(F, X) :-
F1 is F-1,
F2 is F-2,
fib(F1, X1),
fib(F2, X2),
X is X1 + X2,
asserta(fib(F, X)).
namespace CBHerbivore
[<assembly: OrganismClass("CBHerbivore.CBHerbivore")>]
//The class that derives from Animal
[<assembly: AuthorInformation("Christian Bitter", "x@y.z")>]
//It's an herbivore
[<CarnivoreAttribute(false)>]
//This value must be between 24 and 48, 24 means faster
//reproduction
//while 48 would give more defense and attack power
//Make it smaller for reproduction
[<MatureSize(26)>]
//AnimalSkin = AnimalSkinFamilyEnum.Beetle, you can be a Beetle
//an Ant, a Scorpion, an Inchworm, or a Spider
//MarkingColor = KnownColor.Red, you can choose to mark your
//creature with a color.
//This does not affect appearance in the game.
[<AnimalSkin(AnimalSkinFamily.Beetle)>]
[<MarkingColor(KnownColor.Red)>]
//You get 100 points to distribute among these attributes to define
//what your organism can do.
//Choose them based on the strategy your organism will use.
//This organism hides and has good eyesight to find plants.
[<MaximumEnergyPoints(0)>]
//Don't need to increase this as it just sits next to plants
[<EatingSpeedPoints(0)>] //Ditto
[<AttackDamagePoints(0)>] //Doesn't ever attack
[<DefendDamagePoints(0)>]
//This attribute changes the skin of our herbivore,
//which is now going to be a beetle.
//Point Based Attributes
//Doesn't even defend
[<MaximumSpeedPoints(0)>] //Doesn't need to move quickly
[<CamouflagePoints(50)>] //Try to remain hidden
[<EyesightPoints(50)>] //Need this to find plants better
type CBHerbivore () =
inherit Animal()
override sh.Initialize() = ()
override sh.SerializeAnimal (m:MemoryStream) = ()
override sh.DeserializeAnimal (m:MemoryStream) = ()As you may see, the main difference between this herbivore and the previous plant, is the base type our herbivore type needs to implement, and some attributes declared on our animal. In this case the abstract Animal class, declares 3 abstract members (Initialize, SerializeAnimal, DesirializeAnimal), which need to be implemented by our herbivor. Attributes control some of the properties of our herbivore, such as its moving speed, etc.
Again, if you compile this type and introduce it to your terrarium, do not be surprised, to see, that the animal is stiff and not moving like an animal during hibernation. This is due to not implemented event handlers. These event handlers are responsible for your animal's interaction with its environment.
Recently, my beloved Terrarium-game has reappeared from the neatherworlds of software. As some of you may know, Terrarium's intend was to showcase the back then rather new and exciting .NET platform version 1.x (not that it is not still exciting). Although from a gamer's perspective, the graphics weren't all to great, from a technology standpoint, it featured great things, such as Webservices, Reflection, etc.
At some point Terrarium ceased to exist, which was a shame, since the community was quite active developing plants, herbivores and carnivores for the virtual ecosystem that Terrarium simulates. I for myself, developed some simple creatures too (a simple decision-based/state-based agent), as part of a project I did during university for my AI course. More advanced (in comparison to my creature) could be imported showcasing great AI stuff such as A*, neural networks, planning, etc.
However, in an community effort, Terrarium was relaunched lately on codeplex and will hopefully see great new additions, such as a port to a more current version of the .NET platform and DirectX.
In a small attempt I tried to put my superficial F# skills to work, and decided to port a plant organism to F#. My attempt can be seen in the following lines of code. For a C# version, see the codeplex discussion here. I decided to leave the comments from the discussion as is.
namespace CBPlant
We open a namespace for the plant organism
#light
#r "E:\\Path to OrganismBase.dll\\OrganismBase.dll"
We set the environment to lightweight and reference the OrganismBase.dll, which contains all the Terrarium2 stuff.
open System;;
open System.Drawing;;
open System.Collections;;
open System.IO;;
open OrganismBase;;
We open some namespaces, which we are going to use later and dive right into the code.
// Sample Herbivore
//Strategy//This animal moves until it finds a food source and
//then stays there
// The following Assembly attributes must be applied to each
//Organism Assembly
[<assembly: OrganismClass("CBPlant.CBPlant")>] // The class that derives from Animal
[<assembly: AuthorInformation("XYZ", "x@y.z")>] // Provide Author Information
do()
Assembly-level attributes have to be declared via a global do() statement. See the discussion here.
//3.2 Plants
//The definition of a plant is relatively easy since plants do not have to have any sort of movement defined to allow them to locate sources of food.
//Each plant has three basic functions:
//1. Grow
//2. Reproduce by spreading seeds
//3. Be eaten by herbivores
//A plant organism does not need to contain any methods, it just has three properties that define how a plant functions.
//4
//1. The “MaximumEnergyPoints” property allows the developer to state how many energy points a herbivore will gain by consuming this plant. The maximum allowed is 10.
//2. The “MatureSize” property which must be a number between 24 and 48 states the maximum size a plant can grow to when it has survived for some amount of time without being consumed. The smaller a plant is, the faster it will be able to reproduce. As a plant gets larger it will become easier for herbivores to see and will more likely be consumed.
//3. The “SeedSpreadDistanceAttribute” states the maximum distance a plant can spread seeds from its current location. The maximum allowed is 100. These three properties alone are enough to define a functioning plant for the Terrarium game.
// This value must be between 26 and 48, 26 means faster reproduction
// while 48 would give more defense and attack power
// Make it smaller for reproduction*)
[<MatureSize(26)>]
[<SeedSpreadDistance(100)>]
// Point Based Attributes
// You get 100 points to distribute among these attributes to define
// what your organism can do.Choose them based on the strategy your organism
// will use. This organism hides and has good eyesight to find plants
[<MaximumEnergyPoints(10)>]
type CBPlant () =
inherit Plant ()
override cb.SerializePlant (m:MemoryStream) = ()
override cb.DeserializePlant (m:MemoryStream) = ()
;;
We define a new plant type, called CBPlant (full CBPlant.CBPlant). This type is a subclass of the abstract class Plant. We have to implement Plant's two abstract members, which according to the example is just an empty method body. If we compile this by invoking
fsc OrganismBase.dll CBPlant.fs -a
A new library will be created, containing just this simple type.
Hopefully, I will get to play some more with F# and Terrarium doing some other stuff, like porting the Herbivore, Carnivore and start to add some real behaviour.
Today's post is rather simplistic in what it does, but it illustrates some key language elements of F#, such as exception handling.
The task to accomplish is quite it easy, nameley, to connect to a SQL Server 2005 database called "TestDB" on my local machine, using ADO.NET to pull out some rows of the "Person" table having the following schema:
Person (
PersonID: int;
FirstName nvarchar(50);
LastName nvarchar (50);
Street nvarchar(50);
City nvarchar(50);
ZIP int
)
The code we use in F# is a rather straightforward conversion of some typical C# code, and as such is probably not the best way to do things, but it gets the task done, and may illustate the point.
#light
We use the lightweight syntax option.
open System.Data;
open System;
open System.Data.SqlClient;
As a next step, we have to open the correct namespaces.
let ADONetTest =
let conStringBuilder = new SqlConnectionStringBuilder()
conStringBuilder.IntegratedSecurity <- true
conStringBuilder.["Data Source"] <- "localhost"
conStringBuilder.InitialCatalog <- "TestDB"
let con = new SqlConnection(conStringBuilder.ConnectionString)
These lines create the connection to the SQL Server 2005 database "TestDB" on my local machine. As you may see I use a mixture of passing values to properties (IntegratedSecurity, InitialCatalog) and the indexer (["Data Source"]) that is defined on the SqlConnectionStringBuilder type.
try
con.Open()
let cmdString = "SELECT * FROM [dbo].[Person]"
let cmd = new SqlCommand(cmdString, con)
cmd.CommandType <- CommandType.Text
using (cmd.ExecuteReader()) (fun reader ->
if (reader.HasRows) then
(
printfn "Queried: %s" cmdString
while (reader.Read()) do
(
let id = reader.GetInt32(0)
let firstName = reader.GetString(1)
let lastName = reader.GetString(2)
let street = reader.GetString(3)
let city = reader.GetString(4)
let zip = reader.GetInt32(5)
printfn "%d %s %s %s %s %d" id firstName lastName street city zip
)
done
)
else (printfn "Empty result")
)
con.Close()
with
| :? System.Data.SqlClient.SqlException as sqlEx -> printfn "%A" sqlEx.Message
| _ -> printfn "Unknown Exception"
(con :> IDisposable).Dispose ()
;;
This part is responsible for the main functionality. We open the previously specified connection. We do this in a try-with block, to be prepared in case of exceptions. We actually try to handle one exceptio, the SqlExceptio. In the with block, we use type/pattern matching rule (|:? SqlException) to catch this particular exception. Since we do not have a handling strategy in place, a printf command is issued.The next with rule gets executed on whatever type not matching SqlException. We indicate that we do not even care about what it is (| _) using an anonymous rule.
Inside our try block, we declare a SqlCommand and pass in the Sql query stored in the cmdString. variable. This command encapsulates a Select-From-Where SQL-query. We execute the query, using one of F#'s equivalent's of the C# using statement - the using statement (the other one would be use).
The using keeps track for us, that in the case of an exception the "Dispose" method of the object used in the using statement is called - in this case it would be the Dispose declared by the result of SqlCommand.ExecuteReader() - a DataReader object.
Inside the using block, it is asked whether the result of the query (DataReader) actually has rows that were returned by our particular query. This is done by if (reader.HasRows) then () else ().In case rows were returned by that query,they are enumerated by the while do () done loop. This loop does nothing but print each row present in the DataReader.
The last statement to mention is the (con :> IDisposable).Dispose (). This statement casts the connection object into the IDisposable and calls the Dispose method on it. This has to be done, since it is not automatically called by a try-with block, and we have to ensure that all used objects are properly disposed of - espacially those that abstract native resources, such as database or file connections.
SET SSUSER=<your SourceSafe Account>
SET SSPWD=<your SourceSafe Account's Password>
SET SSDIR=<the path to your SourceSafe DB>
"SOURCESAFEDIR\ss.exe" Workfold $/<Path to XYZ>/XYZ "<Target Directory>"
"SOURCESAFEDIR\ss.exe" get $/<Path to XYZ>/XYZ -R
SET SSUSER=<your SourceSafe Account>
SET SSPWD=<your SourceSafe Account's Password>
SET SSDIR=<the path to your SourceSafe DB>
cd "<Target Directory>"
"SOURCESAFEDIR\ss.exe" Workfold $/<Path to XYZ>/XYZ "<Target Directory>"
"SOURCESAFEDIR\ss.exe" get $/<Path to XYZ>/XYZ -R
let rec FibRec n =
if n = 0 then 0
else if n = 1 then 1
else (FibRec (n-2) + FibRec(n-1))
;;
let FibIt n =
if n = 0 then 0
else if n = 1 then 1
else
let fibA = Array.create (n+1) 0
fibA.[0] <- 0 fibA.[1] <- 1 for i = 2 to n do
fibA.[i] <- fibA.[i-2] + fibA.[i-1] fibA.[n] ;;
let rec ReverseList (l: int list) =
match l with
¦ H::T -> (ReverseList T) @ [H]
¦ [] -> []
Posts
All Comments
