Bug fix

.projections.json

@@ -19,10 +19,18 @@
         "type": "laser-example-header",
         "alternate": "src/example/{}.cpp"
     },
+    "include/service/*.h": {
+        "type": "laser-service-header",
+        "alternate": "src/service/{}.cpp"
+    },
     "include/rule/*.h": {
         "type": "laser-rule-header",
         "alternate": "src/rule/{}.cpp"
     },
+    "include/acyclicity/*.h": {
+        "type": "laser-acyclicity-header",
+        "alternate": "src/acyclicity/{}.cpp"
+    },
 
 
 
@@ -46,29 +54,17 @@
         "type": "laser-example-source",
         "alternate": "include/example/{}.h"
     },
+    "src/service/*.cpp": {
+        "type": "laser-service-source",
+        "alternate": "include/service/{}.h"
+    },
     "src/rule/*.cpp": {
         "type": "laser-rule-source",
         "alternate": "include/rule/{}.h"
     },
-
-
-
-    "app_bench/include/*.h": {
-        "type": "benchapp-header",
-        "alternate": "app_bench/src/{}.cpp"
-    },
-    "app_bench/src/*.cpp": {
-        "type": "benchapp-source",
-        "alternate": "app_bench/include/{}.h"
-    },
-
-    "app_simple/include/*.h": {
-        "type": "simpleapp-header",
-        "alternate": "app_simple/src/{}.cpp"
-    },
-    "app_simple/src/*.cpp": {
-        "type": "simpleapp-source",
-        "alternate": "app_simple/include/{}.h"
+    "src/acyclicity/*.cpp": {
+        "type": "laser-acyclicity-source",
+        "alternate": "include/acyclicity/{}.h"
     },
 
 }

CMakeLists.txt

@@ -1,68 +1,47 @@
 cmake_minimum_required(VERSION 3.7)
 
-# comment out the following 2 lines to use system's default C/C++ compiler
+# comment out the following lines to use system's default C/C++ compiler
 # set(CMAKE_C_COMPILER "clang")
 # set(CMAKE_CXX_COMPILER "clang++")
+# set(CMAKE_C_COMPILER "gcc")
+# set(CMAKE_CXX_COMPILER "g++")
 
-project(LaserPP VERSION 0.0.1 LANGUAGES CXX)
+project(Laser++ VERSION 0.1.1 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 17)
-set( CMAKE_EXPORT_COMPILE_COMMANDS ON )
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 ################################### LASER ###################################
 include_directories(include/)
+include_directories(~/tools/llvm/include/c++/v1/)
+
 file(GLOB LASER_SOURCES
         "src/formula/*.cpp"
         "src/formula/extended/*.cpp"
         "src/util/*.cpp"
         "src/rule/*.cpp"
+        "src/rule/filter/*.cpp"
+        "src/rule/math/*.cpp"
+        "src/rule/math/evaluator/*.cpp"
         "src/core/*.cpp"
         "src/example/*.cpp"
+        "src/service/*.cpp"
+        "src/acyclicity/*.cpp"
         )
-
 find_package(Threads)
 
-################################## TESTAPP ##################################
-include_directories(test/include/)
-file(GLOB TESTAPP_SOURCES
-        "test/src/*.cpp"
-    )
 
-set(TESTAPP_LASER_SOURCES ${LASER_SOURCES} ${TESTAPP_SOURCES})
-add_executable(testapp test/main.cpp ${TESTAPP_LASER_SOURCES})
+################################## TESTAPP ##################################
+add_executable(testapp test/main.cpp ${LASER_SOURCES})
 target_link_libraries(testapp ${CMAKE_THREAD_LIBS_INIT})
-
-################################## BENCHAPP ##################################
-include_directories(app_bench/include/)
-file(GLOB BENCHAPP_SOURCES
-        "app_bench/src/*.cpp"
-    )
-
-set(BENCHAPP_LASER_SOURCES ${LASER_SOURCES} ${BENCHAPP_SOURCES})
-add_executable(benchapp app_bench/main.cpp ${BENCHAPP_LASER_SOURCES})
-target_link_libraries(benchapp ${CMAKE_THREAD_LIBS_INIT})
-
-################################## SIMPLEAPP ##################################
-include_directories(app_simple/include/)
-file(GLOB SIMPLEAPP_SOURCES
-        "app_simple/src/*.cpp"
-    )
-
-set(SIMPLEAPP_LASER_SOURCES ${LASER_SOURCES} ${SIMPLEAPP_SOURCES})
-add_executable(simpleapp app_simple/main.cpp ${SIMPLEAPP_LASER_SOURCES})
-target_link_libraries(simpleapp ${CMAKE_THREAD_LIBS_INIT})
-
 ################################### TESTS ###################################
 
 find_package(GTest)
 if(GTEST_FOUND)
     file(GLOB TEST_SOURCES
-        "test/src/*.cpp"
         "test/testcase/*.cpp"
     )
     include_directories(${GTEST_INCLUDE_DIRS})
-    add_executable(run_test test/test.cpp ${LASER_SOURCES} ${TEST_SOURCES})
-    target_link_libraries(run_test ${GTEST_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+    add_executable(run_gtest test/test.cpp ${LASER_SOURCES} ${TEST_SOURCES})
+    target_link_libraries(run_gtest ${GTEST_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
 endif(GTEST_FOUND)
-
-

README.md

@@ -3,26 +3,21 @@
 **Laser++** is a C++ implementation of the [Laser](https://research.vu.nl/en/publications/expressive-stream-reasoning-with-laser) a stream reasoning engine 
 based on the [LARS logic framework](http://www.kr.tuwien.ac.at/research/projects/dhsr/pub/2015/bdef2015-aaai.pdf)   
 
-
 ### Prerequisites
 Laser++ requires:
 * C++ compiler compliant with C++17 standard (tested on GCC 7.3.0 and 
 Clang 6.0.0)
-* GTest suite (tested on version 1.8.0)
 * CMake (minimum version: 3.7, tested on 3.10)
-
-Optional tools:
-* gprof (for profiling)
-* gdb (for debugging)
-* python (for generating benchmark input)
+* GTest suite (tested on version 1.8.0) (optional)
+* gdb (optional)
 
 ## Getting Started
 
 Interact with Laser++ by using the `laser.sh` script. 
 
-Build Laser++ by executing:
+Build and test Laser++ by executing:
 ```
-./laser.sh b
+./laser.sh r 
 ```
 
 Run all test cases by executing:
@@ -35,35 +30,61 @@ See all options by running:
 ./laser.sh h 
 ```
 
-### Benchmarking 
+**Program**
+
+Programs are composed of one or more rules, separated by new-line character '\n'.
+
+Each rule is written as: `head := body`. Both *head* and *body* are formulas. 
+
+The simplest type of formula is an Atom, which is composed of a predicate and
+some variables, e.g.: `a(X, Y, X)`. In this atom, *a* is the predicate, while 
+*X*, *Y*, and *Z* are variables.
 
-Benchmarking requires an input file from which the stream will be read. 
-This file can be generated by using `gen.py` script:
+More complex formulas can be represented by adding a unary operator in front 
+of another
+formula, or a binary operator between two formulas. 
+These operators are written as: 
 ```
-python gen.py
+Diamond: [D]
+Box: [B]
+Time Window: [$, size]
+Tuple Window: [#, size]
+Time reference: [@, time_variable]
+Conjunction: &&
 ```
-
-Benchmark by running:
+Please note that the head of a Laser++ rule is limited to conjunctions of atomic 
+and time reference formulas.
+Example program:
 ```
-./laser.sh bench test_name end_time_of_stream number_of_facts_per_timepoint window_size stream_file_path [output_file_path] 
+u(X) := [#, 1][D]f(X)
+f(Y) := [$, 5] [B] e(Y, Y)
+a(T, Z) := [@, T] b(Z)
+[@, T]c(S) := [@, T] d(S)
+i(V, W) := g(W) && h(V)
 ```
 
-The parameter test_name can be selected from this list:
-[*atom*, *diamond*, *box*, *conjunction*, *tref*, *multiatom*, *multiall*, 
-*atom_window*]. 
-For details on each test, see *app-bench/main.cpp*
-
-The parameter *output_file_path* is optional. In case it is missing, no output
-will be written. 
+**Input Stream**
 
-Example use:
+The file containing the input stream needs to start with a line containing two 
+numbers: the first and last time-point in the stream.
+Each line after has the following format: `time-point : facts`. Facts are grounded
+atoms separated by commas. Time-points should be in order.
+Example input stream:
 ```
-./laser.sh bench atom 1000000 100 0 ~/stream_file.txt
+1 14 
+1 : q(1), p(1), e(a4, b6)
+2 : p(2), a(3, 1, 8)
+3 : 
+4 : p(41), q(1) 
+4 : p(8)
+5 : a(4, 8, 12)
+12 : a(56, 99, 0), p(1)
 ```
 
 ### Project organization
-The code of Laser++ can be found in directories **include** (header files) and **src** 
-(C++ source files). The project is divided in 4 modules (*core*, *rule*, *forumula*, 
+The code of Laser++ can be found in directories **include** (header files) and 
+**src** (C++ source files). 
+The project is divided in 4 modules (*core*, *rule*, *forumula*, 
 *util*). Each module can be found in a dedicated sub-directory of *include*
 and *src* respectively. The sub-directory *example* contains implementations of 
 *rule::RuleReader* and *core::IOManager* interfaces. 
@@ -73,20 +94,15 @@ The directory **test** contains contains some test cases which can be found in
 hardcoded programs on hard-coded input. The source-code of this application can 
 be found in *test/main.cpp*.
 
-The directory **app-bench** contains a Laser++-based application. This 
-application is used for benchmarking the performance of the Laser++ reasoning
-engine. It can also be used for profiling.  
-
-### Laser++ modules:
+### Laser++ modules: (!outdated)
 
 **Core** - handles input-output as well as execution of the Laser++ program. 
-References modules: Rule, Util.
 
 **Rule** - parses laser programs and evaluates the rules on the input facts
-provided by the stream. References modules: Formula, Util.
+provided by the stream. 
 
 **Formula** - Evaluates the different formulas found in the program and stores
-the result. References module Util.
+the result. 
 
 **Util** - Contains classes useful in other modules such as exceptions, timeline.
 Instances of the Grounding class present in this module are used as the basic 
@@ -99,81 +115,45 @@ formulas present in the program being evaluated.
 Laser++ is a reasoning engine that can be used to implement systems capable of
 real-time semantic inference on stream of data. 
 
-In order to implement a reasoning application, the user need only to implement the 
-`laser::core::IOManager` and `laser::rule::RuleReader` interfaces found in 
-*include/core/io_manager.h* and *include/rule/rule_reader.h*. This 
+In order to implement a reasoning application, the user need only to implement 
+the 
+`laser::core::IOManager` interface found in 
+*include/core/io_manager.h*. This 
 implementation should reflect the application specific needs regarding reading
 and parsing of the input stream, as well as formatting and writing of the output
 stream. An example of such an implementation can be found in the folder 
 *include/example* and *src/example*.  
 
-Once the *IOManager* and *RuleReader* interfaces are implemented, 
+Laser comes with a built in *RuleParser* class found in the _rule_ module. 
+If the application requires a diferent syntax for expressing logic rules, 
+users can implement their own rule parser instead.
+
+Once the *IOManager* interface is implemented, 
 an application can use the Laser++
 reasoning engine by constructing an instance of the `laser::core::Reasoner` class
 found in *include/core/reasoner.h* and *src/core/reasoner.cpp* respectively.
-An example application can be found in *app-sample/main.cpp*
 
-### Quick start with Sample reasoning application
+Laser stores global settings in the `laser::util::Settings` class.
+The class includes settings such as the chase algorithm used to materialize 
+existentially quantified values. 
+This settings should be set before parsing the rules and intantiating the 
+_Reasoner_ class. 
 
-The Laser++ source-code includes **Simpleapp**, a Laser++-based application that 
-is meant as a demo. It can be used to test the Laser++ reasoning
-engine on programs and input streams provided in text files. To run this 
-application first compile Laser++ as well as simpleapp by running `./laser.sh b`,
-then execute:
-```
-cmake-build-release/simpleapp PROGRAM INPUT OUTPUT
-```
-The three arguments represent the paths to the respective input and output files.
-The source code of *Simpleapp* can be found in *app-simple/main.cpp*, as well as
-the sub directories *include* and *src* of the *app-simple* directory. Some 
-sample programs and inputs can be found in *app-simple/samples/*.
-
-**Program**
-
-Programs are composed of one or more rules, separated by new-line character '\n'.
+### TODO: example!!!
 
-Each rule is written as: `head := body`. Both *head* and *body* are formulas. 
 
-The simplest type of formula is an Atom, which is composed of a predicate and
-some variables, e.g.: `a(X, Y, X)`. In this atom, *a* is the predicate, while 
-*X*, *Y*, and *Z* are variables.
+### Debuging
 
-More complex formulas can be represented by adding a unary operator in front of another
-formula, or a binary operator between two formulas. The result is an extended
-formula. These operators are written as: 
+Laser++ comes with a testing application. 
+The source code for this application can be found in the directory 
+*test/* and can be executed by running:
 ```
-Diamond: [D]
-Box: [B]
-Time Window: [$, size]
-Tuple Window: [#, size]
-Time reference: [@, time_variable]
-Conjunction: &&
-```
-Please note that the head of a Laser++ rule is limited to only atomic and time 
-reference formulas.
-Example program:
-```
-u(X) := [#, 1][D]f(X)
-f(Y) := [$, 5] [B] e(Y, Y)
-a(T, Z) := [@, T] b(Z)
-[@, T]c(S) := [@, T] d(S)
-i(V, W) := g(W) && h(V)
+./laser.sh r 
 ```
 
-**Input Stream**
-
-The file containing the input stream needs to start with a line containing two 
-numbers: the first and last time-point in the stream.
-Each line after has the following format: `time-point : facts`. Facts are grounded
-atoms separated by commas. Time-points should be in order.
-Example input stream:
-```1 14 "
-1 : q(1), p(1), e(a4, b6)
-2 : p(2), a(3, 1, 8)
-3 : 
-4 : p(41), q(1) 
-4 : p(8)
-5 : a(4, 8, 12)
-12 : a(56, 99, 0), p(1)
+The test application runs a series of hardcoded Laser programs on hardcoded input.
+This is useful for debuging, as a specific Laser program can be run in GDB. 
+Simply edit the code in *test/main.cpp*, build and execute:
+```
+./laser.sh d 
 ```
-