ODIn
/
MayBMS_Mirror
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: ODIn:289f5d47514d16bd6523a5a2480e10cf2b7bacaf
Branches Tags
ODIn:master
...
compare: ODIn:266258b79c498391b1a55d0deae9509e77aaf5ad
Branches Tags
ODIn:master

10 Commits
289f5d4751 ... 266258b79c

Author SHA1 Message Date
Boris Glavic (as perm@debussy) 266258b79c new 2020-07-01 21:15:08 -05:00
Boris Glavic f3dad74848 index 2020-07-01 18:53:45 -05:00
Boris Glavic f832972cde installpip 2020-07-01 18:47:38 -05:00
Boris Glavic a8cd7db58a make 2020-07-01 17:55:57 -05:00
Boris Glavic 96e1fcc4b8 make 2020-07-01 17:21:31 -05:00
Boris Glavic 30f52dc680 make 2020-07-01 17:20:36 -05:00
Boris Glavic 5bee5408a0 pip install sql update 2020-07-01 17:18:20 -05:00
Boris Glavic ff3ca7e7f1 docker 2020-07-01 16:56:23 -05:00
Boris Glavic dc798e901b createDB 2020-07-01 00:23:24 -05:00
Boris Glavic 4f7bd38d07 createDB 2020-07-01 00:23:01 -05:00
8 changed files with 156 additions and 131 deletions
Show Stats Expand all files Collapse all files

23
docker/Dockerfile
View File

@ -44,9 +44,21 @@ RUN cd /home/maybms/src/postgresql-8.3.3 \
&& make install \
&& cp -r /home/maybms/src/postgresql-8.3.3/src/include/maybms /home/maybms/install/include/postgresql/server/maybms/
########################################
# Add datadir as volume to persist across container restarts
########################################
RUN ["/home/maybms/src/docker/createDB.sh","maybms"]
########################################
# Build patched version
########################################
# RUN cd /home/maybms/src/postgresql-ctype \
# && ./configure --prefix=/home/maybms/install-patched \
# && make -j16 \
# && make install \
# && cp -r /home/maybms/src/postgresql-ctype/src/include/maybms /home/maybms/install-patched/include/postgresql/server/maybms/
########################################
# Environment
########################################
ENV PGDATA /home/maybms/data
ENV PGDATA /home/maybms/datadir
ENV PATH /home/maybms/install/bin:$PATH
########################################
# Expose postmaster port
@ -57,10 +69,9 @@ EXPOSE 5432
########################################
RUN cd /home/maybms/src/pip_plugin && make && make install
########################################
# Add datadir as volume to persist across container restarts
# install pip functions
########################################
RUN ["/home/maybms/src/docker/createDB.sh","maybms"]
#RUN /home/maybms/install/bin/initdb -D /home/maybms/data
RUN ["/home/maybms/src/docker/installPipFuncs.sh","maybms"]
########################################
# Per default start postgres
########################################
@ -68,5 +79,5 @@ ENTRYPOINT ["/home/maybms/install/bin/postgres"]
########################################
# Per default connect to the example cluster
########################################
CMD ["-D", "/home/maybms/data"]
VOLUME /home/maybms/data
CMD ["-D", "/home/maybms/datadir"]
VOLUME /home/maybms/datadir

5
docker/createDB.sh
View File

@ -13,11 +13,10 @@ ${INSTALLBINDIR}/initdb -D ${DATADIR}
####################
echo - start server
${INSTALLBINDIR}/pg_ctl -D ${DATADIR} -w start
sleep 10
${INSTALLBINDIR}/psql -h localhost -p 5432 -U maybms -d template1 -c 'CREATE LANGUAGE plpgsql'
${INSTALLBINDIR}/psql -h localhost -p 5432 -U maybms -d template1 -c '\i /home/maybms/src/contrib/xml2/pgxml.sql'
####################
echo - create user and testdb
${INSTALLBINDIR}/createuser -s -l -U $PGUSER maybms
echo - create testdb
${INSTALLBINDIR}/createdb -U $PGUSER maybms
####################
echo - shutdown server

17
docker/installPipFuncs.sh Executable file
View File

@ -0,0 +1,17 @@
#!/bin/bash
PGUSER=$1
MAYBMSHOME=/home/maybms
SRCDIR=${MAYBMSHOME}/src
INSTALLBINDIR=${MAYBMSHOME}/install/bin
DATADIR=${MAYBMSHOME}/datadir
####################
echo - start server
${INSTALLBINDIR}/pg_ctl -D ${DATADIR} -w start
sleep 10
####################
echo - create testdb
${INSTALLBINDIR}/psql -h localhost -p 5432 -U $PGUSER -d maybms -f /home/maybms/src/pip_plugin/pip-noctype.sql
${INSTALLBINDIR}/psql -h localhost -p 5432 -U $PGUSER -d template1 -f /home/maybms/src/pip_plugin/pip-noctype.sql
####################
echo - shutdown server
${INSTALLBINDIR}/pg_ctl -w stop

21
pip_plugin/Makefile
View File

@ -24,7 +24,7 @@ OBJS =$(subst .c,.o,$(SOURCEFILES))
PG_CONFIG=pg_config
MODULE_big:= pip
DATA_built:= pip.sql # install.test.sql install.sql uninstall.sql $(SCRIPTS)
DATA_built:= pip.sql pip-noctype.sql pip-uninstall.sql pip-test.sql # install.test.sql install.sql uninstall.sql $(SCRIPTS)
PIP_CFLAGS+= -I$(shell $(PG_CONFIG) --includedir) \
-I$(shell $(PG_CONFIG) --includedir)/server \
-Isrc/include
@ -42,18 +42,17 @@ src/disttable.c: $(DISTRIBUTIONS) scripts/gen_disttable.sh
src/dist/normal.dist: scripts/normal.rb
./scripts/normal.rb > src/dist/normal.dist
install.sql: src/pip.source
rm -f $@; \
C=$(INSTALL_DIR); \
sed -e "s:_OBJWD_:$$C/libpip:g" < $< > $@
cat $@ | grep -v "HACKED_SQL_ONLY" > `basename $@ .sql`.noctype.sql
pip.sql.in: src/pip.source
cat $< > $@
install.test.sql: src/pip.source
rm -f $@; \
C=`pwd`; \
sed -e "s:_OBJWD_:$$C/libpip:g" < $< > $@
pip-noctype.sql: pip.sql
cat $< | grep -v "HACKED_SQL_ONLY" > $@
uninstall.sql: src/pip.source scripts/gen_uninstall.sh
pip-test.sql.in: src/pip.source
rm -f $@; \
cat $< > $@
pip-uninstall.sql.in: src/pip.source scripts/gen_uninstall.sh
./scripts/gen_uninstall.sh > $@
# let postrgres extension build system install

8
pip_plugin/scripts/patch_postgres.sh
View File

@ -23,7 +23,7 @@ fi
echo "================ Identifying Patches For CTYPE Postgres ===================";
cd $MAYBMSDIR
for i in $(find $PIPDIR/src/patch -type f | grep -v CVS | grep -v '.original' | sed "s:^$PIPDIR/src/patch/::"); do
for i in $(find $PIPDIR/src/patch -type f | grep -v CVS | grep -v '.original' | sed "s:^$PIPDIR/src/patch/::"); do
if [ -f $CTYPEDIR/src/$i ] ; then
if diff -q $PIPDIR/src/patch/$i $CTYPEDIR/src/$i > /dev/null ; then
echo "Ignoring up-to-date file $i";
@ -31,15 +31,15 @@ for i in $(find $PIPDIR/src/patch -type f | grep -v CVS | grep -v '.original' |
if [ ! -f $PIPDIR/src/patch/$i.original ] ; then
echo "Replacing file $i";
cp $PIPDIR/src/patch/$i $CTYPEDIR/src/$i
else
else
echo "Patching file $i";
merge $CTYPEDIR/src/$i $PIPDIR/src/patch/$i.original $PIPDIR/src/patch/$i
fi
fi
else
else
echo "Copying new file $i";
cp $PIPDIR/src/patch/$i $CTYPEDIR/src/$i;
fi
done
cd $ORIGINALWD
cd $ORIGINALWD

2
pip_plugin/src/patch/test/regress/sql/type_sanity.sql
View File

@ -60,7 +60,7 @@ WHERE p1.typtype in ('b','e') AND p1.typname NOT LIKE E'\\_%' AND NOT EXISTS
p2.typelem = p1.oid and p1.typarray = p2.oid);
-- Make sure typarray points to a varlena array type of our own base
SELECT p1.oid, p1.typname as basetype, p2.typname as arraytype,
SELECT p1.oid, p1.typname as basetype, p2.typname as arraytype,
p2.typelem, p2.typlen
FROM pg_type p1 LEFT JOIN pg_type p2 ON (p1.typarray = p2.oid)
WHERE p1.typarray <> 0 AND

185
pip_plugin/src/pip.source
View File

@ -12,114 +12,114 @@ CREATE TYPE pip_expectation;
CREATE TYPE pip_atomset;
--------------- pip_var FUNCTIONS ---------------
CREATE FUNCTION pip_var_in(cstring) RETURNS pip_var AS '_OBJWD_','pip_var_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_var_out(pip_var) RETURNS cstring AS '_OBJWD_','pip_var_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION create_variable(cstring, integer, cstring) RETURNS pip_eqn AS '_OBJWD_','pip_var_create_str' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION create_variable(cstring, integer, record) RETURNS pip_eqn AS '_OBJWD_','pip_var_create_row' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_var_in(cstring) RETURNS pip_var AS 'MODULE_PATHNAME','pip_var_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_var_out(pip_var) RETURNS cstring AS 'MODULE_PATHNAME','pip_var_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION create_variable(cstring, integer, cstring) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_var_create_str' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION create_variable(cstring, integer, record) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_var_create_row' LANGUAGE C VOLATILE STRICT;
--------------- pip_eqn FUNCTIONS ---------------
CREATE FUNCTION pip_eqn_in(cstring) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_out(pip_eqn) RETURNS cstring AS '_OBJWD_','pip_eqn_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION expectation(pip_eqn, record) RETURNS double precision AS '_OBJWD_','pip_expectation' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation(pip_eqn, record, integer) RETURNS double precision AS '_OBJWD_','pip_expectation' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_max_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS '_OBJWD_','pip_expectation_max_g' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_max_g_one(pip_atomset, double precision, record) RETURNS pip_atomset AS '_OBJWD_','pip_expectation_max_g_one' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_max_f_one(pip_atomset) RETURNS double precision AS '_OBJWD_','pip_expectation_max_f_one' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_sum_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS '_OBJWD_','pip_expectation_sum_g' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record) RETURNS double precision AS '_OBJWD_','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record, integer) RETURNS double precision AS '_OBJWD_','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_eqn_in(cstring) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_out(pip_eqn) RETURNS cstring AS 'MODULE_PATHNAME','pip_eqn_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sum(pip_eqn,pip_eqn) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_sum_ee' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sum(pip_eqn,integer) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_sum_ei' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sum(integer,pip_eqn) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_sum_ie' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sum(pip_eqn,double precision) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_sum_ef' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sum(double precision,pip_eqn) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_sum_fe' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn,record) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn ) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION expectation(pip_eqn, record) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation(pip_eqn, record, integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_max_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_expectation_max_g' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_max_g_one(pip_atomset, double precision, record) RETURNS pip_atomset AS 'MODULE_PATHNAME','pip_expectation_max_g_one' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_max_f_one(pip_atomset) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_max_f_one' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_sum_g(pip_sample_set, pip_eqn, record) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_expectation_sum_g' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION expectation_sum_g_one(double precision, pip_eqn, record, integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_expectation_sum_g_one' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_eqn_mul(pip_eqn,pip_eqn) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_mul_ee' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_mul(pip_eqn,integer) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_mul_ei' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_mul(integer,pip_eqn) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_mul_ie' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_mul(pip_eqn,double precision) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_mul_ef' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_mul(double precision,pip_eqn) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_mul_fe' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sum(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ee' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sum(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ei' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sum(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ie' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sum(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_ef' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sum(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sum_fe' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn,record) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_compile_sum(pip_eqn,pip_eqn ) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_compile_sum' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_neg(pip_eqn) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_neg' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sub(pip_eqn,pip_eqn) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_sub_ee' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sub(pip_eqn,integer) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_sub_ei' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sub(integer,pip_eqn) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_sub_ie' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sub(pip_eqn,double precision) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_sub_ef' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sub(double precision,pip_eqn) RETURNS pip_eqn AS '_OBJWD_','pip_eqn_sub_fe' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_mul(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ee' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_mul(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ei' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_mul(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ie' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_mul(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_ef' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_mul(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_mul_fe' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_neg(pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_neg' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sub(pip_eqn,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ee' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sub(pip_eqn,integer) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ei' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sub(integer,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ie' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sub(pip_eqn,double precision) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_ef' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_eqn_sub(double precision,pip_eqn) RETURNS pip_eqn AS 'MODULE_PATHNAME','pip_eqn_sub_fe' LANGUAGE C IMMUTABLE STRICT;
--------------- pip_expectation FUNCTIONS ---------------
-- Expectation is a semantic sugar hack to cheat the parser...
-- Consequently the IO operations here are identical to those for pip_eqn
CREATE FUNCTION pip_expectation_in(cstring) RETURNS pip_expectation AS '_OBJWD_','pip_exp_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_expectation_out(pip_expectation) RETURNS cstring AS '_OBJWD_','pip_exp_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_expectation_make(pip_eqn) RETURNS pip_expectation AS '_OBJWD_','pip_exp_make' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_expectation_fix(pip_expectation,record) RETURNS pip_expectation AS '_OBJWD_','pip_exp_fix' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_expectation_expect(pip_expectation) RETURNS double precision AS '_OBJWD_','pip_exp_expect' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_expectation_in(cstring) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_expectation_out(pip_expectation) RETURNS cstring AS 'MODULE_PATHNAME','pip_exp_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_expectation_make(pip_eqn) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_make' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_expectation_fix(pip_expectation,record) RETURNS pip_expectation AS 'MODULE_PATHNAME','pip_exp_fix' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_expectation_expect(pip_expectation) RETURNS double precision AS 'MODULE_PATHNAME','pip_exp_expect' LANGUAGE C IMMUTABLE STRICT;
--------------- pip_atom FUNCTIONS ---------------
CREATE FUNCTION pip_atom_in(cstring) RETURNS pip_atom AS '_OBJWD_','pip_atom_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_atom_out(pip_atom) RETURNS cstring AS '_OBJWD_','pip_atom_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_atom_create_gt(pip_eqn,pip_eqn) RETURNS pip_atom AS '_OBJWD_','pip_atom_create_gt_ee' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_create_gt(pip_eqn,double precision) RETURNS pip_atom AS '_OBJWD_','pip_atom_create_gt_ef' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_create_gt(double precision,pip_eqn) RETURNS pip_atom AS '_OBJWD_','pip_atom_create_gt_fe' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_create_lt(pip_eqn,pip_eqn) RETURNS pip_atom AS '_OBJWD_','pip_atom_create_lt_ee' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_create_lt(pip_eqn,double precision) RETURNS pip_atom AS '_OBJWD_','pip_atom_create_lt_ef' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_create_lt(double precision,pip_eqn) RETURNS pip_atom AS '_OBJWD_','pip_atom_create_lt_fe' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_in(cstring) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_atom_out(pip_atom) RETURNS cstring AS 'MODULE_PATHNAME','pip_atom_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_atom_create_gt(pip_eqn,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_ee' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_create_gt(pip_eqn,double precision) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_ef' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_create_gt(double precision,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_gt_fe' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_create_lt(pip_eqn,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_ee' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_create_lt(pip_eqn,double precision) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_ef' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_atom_create_lt(double precision,pip_eqn) RETURNS pip_atom AS 'MODULE_PATHNAME','pip_atom_create_lt_fe' LANGUAGE C VOLATILE STRICT;
--------------- pip_atomset FUNCTIONS ---------------
CREATE FUNCTION pip_atomset_in(cstring) RETURNS pip_atomset AS '_OBJWD_','pip_atomset_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_atomset_out(pip_atomset) RETURNS cstring AS '_OBJWD_','pip_atomset_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_atomset_in(cstring) RETURNS pip_atomset AS 'MODULE_PATHNAME','pip_atomset_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_atomset_out(pip_atomset) RETURNS cstring AS 'MODULE_PATHNAME','pip_atomset_out' LANGUAGE C IMMUTABLE STRICT;
--------------- pip_sample_set FUNCTIONS ---------------
CREATE FUNCTION pip_sample_set_in(cstring) RETURNS pip_sample_set AS '_OBJWD_','pip_sample_set_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_sample_set_out(pip_sample_set) RETURNS cstring AS '_OBJWD_','pip_sample_set_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_sample_set_generate(record,integer) RETURNS pip_sample_set AS '_OBJWD_','pip_sample_set_generate' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_sample_set_explode(pip_sample_set) RETURNS SETOF double precision AS '_OBJWD_','pip_sample_set_explode' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_sample_set_expect(pip_sample_set) RETURNS double precision AS '_OBJWD_','pip_sample_set_expect' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_sample_set_in(cstring) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_sample_set_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_sample_set_out(pip_sample_set) RETURNS cstring AS 'MODULE_PATHNAME','pip_sample_set_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_sample_set_generate(record,integer) RETURNS pip_sample_set AS 'MODULE_PATHNAME','pip_sample_set_generate' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_sample_set_explode(pip_sample_set) RETURNS SETOF double precision AS 'MODULE_PATHNAME','pip_sample_set_explode' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_sample_set_expect(pip_sample_set) RETURNS double precision AS 'MODULE_PATHNAME','pip_sample_set_expect' LANGUAGE C IMMUTABLE STRICT;
--------------- INTEGRATION FUNCTIONS ---------------
CREATE FUNCTION conf_one (record) RETURNS double precision AS '_OBJWD_','conf_one' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION conf_sample_g (pip_conf_tally,record,pip_sample_set) RETURNS pip_conf_tally AS '_OBJWD_','pip_atom_conf_sample_g' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION conf_naive_g (pip_world_presence,record,pip_sample_set) RETURNS pip_world_presence AS '_OBJWD_','pip_atom_sample_set_presence' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION conf_one (record) RETURNS double precision AS 'MODULE_PATHNAME','conf_one' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION conf_sample_g (pip_conf_tally,record,pip_sample_set) RETURNS pip_conf_tally AS 'MODULE_PATHNAME','pip_atom_conf_sample_g' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION conf_naive_g (pip_world_presence,record,pip_sample_set) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_atom_sample_set_presence' LANGUAGE C IMMUTABLE STRICT;
--------------- pip_conf_tally FUNCTIONS ---------------
CREATE FUNCTION pip_conf_tally_in(cstring) RETURNS pip_conf_tally AS '_OBJWD_','pip_conf_tally_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_conf_tally_out(pip_conf_tally) RETURNS cstring AS '_OBJWD_','pip_conf_tally_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_conf_tally_result(pip_conf_tally) RETURNS double precision AS '_OBJWD_','pip_conf_tally_result' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_conf_tally_in(cstring) RETURNS pip_conf_tally AS 'MODULE_PATHNAME','pip_conf_tally_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_conf_tally_out(pip_conf_tally) RETURNS cstring AS 'MODULE_PATHNAME','pip_conf_tally_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_conf_tally_result(pip_conf_tally) RETURNS double precision AS 'MODULE_PATHNAME','pip_conf_tally_result' LANGUAGE C IMMUTABLE STRICT;
--------------- pip_world_presence FUNCTIONS ---------------
CREATE FUNCTION pip_world_presence_in(cstring) RETURNS pip_world_presence AS '_OBJWD_','pip_world_presence_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_world_presence_out(pip_world_presence) RETURNS cstring AS '_OBJWD_','pip_world_presence_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_world_presence_create(integer) RETURNS pip_world_presence AS '_OBJWD_','pip_world_presence_create' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_world_presence_count(pip_world_presence) RETURNS double precision AS '_OBJWD_','pip_world_presence_count' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_world_presence_union(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS '_OBJWD_','pip_world_presence_union' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_world_presence_in(cstring) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_world_presence_out(pip_world_presence) RETURNS cstring AS 'MODULE_PATHNAME','pip_world_presence_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_world_presence_create(integer) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_create' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_world_presence_count(pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_world_presence_count' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_world_presence_union(pip_world_presence,pip_world_presence) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_world_presence_union' LANGUAGE C IMMUTABLE STRICT;
--------------- pip_value_bundle FUNCTIONS ---------------
CREATE FUNCTION pip_value_bundle_in(cstring) RETURNS pip_value_bundle AS '_OBJWD_','pip_value_bundle_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_out(pip_value_bundle) RETURNS cstring AS '_OBJWD_','pip_value_bundle_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_create(pip_eqn,integer) RETURNS pip_value_bundle AS '_OBJWD_','pip_value_bundle_create' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,integer,pip_value_bundle) RETURNS pip_world_presence AS '_OBJWD_','pip_value_bundle_cmp_iv' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,double precision,pip_value_bundle) RETURNS pip_world_presence AS '_OBJWD_','pip_value_bundle_cmp_fv' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,integer) RETURNS pip_world_presence AS '_OBJWD_','pip_value_bundle_cmp_vi' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,double precision) RETURNS pip_world_presence AS '_OBJWD_','pip_value_bundle_cmp_vf' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,pip_value_bundle) RETURNS pip_world_presence AS '_OBJWD_','pip_value_bundle_cmp_vv' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,double precision) RETURNS pip_value_bundle AS '_OBJWD_','pip_value_bundle_add_vf' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS '_OBJWD_','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle,pip_world_presence) RETURNS pip_value_bundle AS '_OBJWD_','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE;
CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,double precision) RETURNS pip_value_bundle AS '_OBJWD_','pip_value_bundle_mul_vf' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS '_OBJWD_','pip_value_bundle_mul_vv' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_max(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS '_OBJWD_','pip_value_bundle_max' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle) RETURNS double precision AS '_OBJWD_','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,pip_world_presence) RETURNS double precision AS '_OBJWD_','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer) RETURNS double precision AS '_OBJWD_','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer,pip_world_presence) RETURNS double precision AS '_OBJWD_','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_in(cstring) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_in' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_out(pip_value_bundle) RETURNS cstring AS 'MODULE_PATHNAME','pip_value_bundle_out' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_create(pip_eqn,integer) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_create' LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,integer,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_iv' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,double precision,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_fv' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,integer) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vi' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,double precision) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vf' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_cmp(pip_world_presence,pip_value_bundle,pip_value_bundle) RETURNS pip_world_presence AS 'MODULE_PATHNAME','pip_value_bundle_cmp_vv' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,double precision) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vf' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_add(pip_value_bundle,pip_value_bundle,pip_world_presence) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_add_vv' LANGUAGE C IMMUTABLE;
CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,double precision) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_mul_vf' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_mul(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_mul_vv' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_max(pip_value_bundle,pip_value_bundle) RETURNS pip_value_bundle AS 'MODULE_PATHNAME','pip_value_bundle_max' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_value_bundle_expect(pip_value_bundle,integer,integer,pip_world_presence) RETURNS double precision AS 'MODULE_PATHNAME','pip_value_bundle_expect' LANGUAGE C IMMUTABLE STRICT;
--------------- DEBUG/TEST FUNCTIONS ---------------
CREATE FUNCTION pip_cdf_enabled(integer) RETURNS integer AS '_OBJWD_','pip_set_cdf_sampling_enabled' LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION pip_cdf_enabled(integer) RETURNS integer AS 'MODULE_PATHNAME','pip_set_cdf_sampling_enabled' LANGUAGE C IMMUTABLE STRICT;
--------------- VARIABLE DEFINITIONS ---------------
CREATE TYPE pip_var (
@ -148,7 +148,7 @@ CREATE TYPE pip_value_bundle (
OUTPUT = pip_value_bundle_out,
STORAGE = external
);
CREATE TYPE pip_world_presence (
CREATE TYPE pip_world_presence (
INPUT = pip_world_presence_in,
OUTPUT = pip_world_presence_out,
STORAGE = external
@ -170,7 +170,7 @@ CREATE TYPE pip_atomset (
);
--------------- AGGREGATE FUNCTIONS ---------------
CREATE AGGREGATE expectation_max (pip_eqn, record)
CREATE AGGREGATE expectation_max (pip_eqn, record)
(
CONSTRAINTTYPE, --HACKED_SQL_ONLY
sfunc = expectation_max_g,
@ -178,7 +178,7 @@ CREATE AGGREGATE expectation_max (pip_eqn, record)
finalfunc = pip_sample_set_expect,
initcond = '?1000/1'
);
CREATE AGGREGATE expectation_max_hist (pip_eqn, record)
CREATE AGGREGATE expectation_max_hist (pip_eqn, record)
(
CONSTRAINTTYPE, --HACKED_SQL_ONLY
sfunc = expectation_max_g,
@ -186,21 +186,21 @@ CREATE AGGREGATE expectation_max_hist (pip_eqn, record)
initcond = '?1000/1'
);
CREATE AGGREGATE expectation_sum (pip_eqn, record, integer)
CREATE AGGREGATE expectation_sum (pip_eqn, record, integer)
(
CONSTRAINTTYPE, --HACKED_SQL_ONLY
sfunc = expectation_sum_g_one,
stype = double precision,
initcond = '0.0'
);
CREATE AGGREGATE expectation_sum (pip_eqn, record)
CREATE AGGREGATE expectation_sum (pip_eqn, record)
(
CONSTRAINTTYPE, --HACKED_SQL_ONLY
sfunc = expectation_sum_g_one,
stype = double precision,
initcond = '0.0'
);
CREATE AGGREGATE expectation_sum_hist (pip_eqn, record)
CREATE AGGREGATE expectation_sum_hist (pip_eqn, record)
(
CONSTRAINTTYPE, --HACKED_SQL_ONLY
sfunc = expectation_sum_g,
@ -232,17 +232,17 @@ CREATE AGGREGATE conf_naive (record,pip_sample_set)
finalfunc = pip_world_presence_count,
initcond = '?0'
);
CREATE AGGREGATE sum (pip_value_bundle)
CREATE AGGREGATE sum (pip_value_bundle)
(
sfunc = pip_value_bundle_add,
stype = pip_value_bundle
);
CREATE AGGREGATE sum (pip_value_bundle,pip_world_presence)
CREATE AGGREGATE sum (pip_value_bundle,pip_world_presence)
(
sfunc = pip_value_bundle_add,
stype = pip_value_bundle
);
CREATE AGGREGATE expectation_max (pip_value_bundle)
CREATE AGGREGATE expectation_max (pip_value_bundle)
(
CONSTRAINTTYPE, --HACKED_SQL_ONLY
sfunc = pip_value_bundle_max,
@ -305,4 +305,3 @@ CREATE OPERATOR < ( PROCEDURE=pip_atom_create_lt, LEFTARG=double precision, R
CREATE OPERATOR << ( PROCEDURE=pip_expectation_make, RIGHTARG=pip_eqn );
CREATE OPERATOR @ ( PROCEDURE=pip_expectation_fix, LEFTARG=pip_expectation, RIGHTARG=record );
CREATE OPERATOR >> ( PROCEDURE=pip_expectation_expect, LEFTARG=pip_expectation );

26
website/pip/index.html
View File

@ -49,7 +49,7 @@ $> initdb
<h3><a name="installing_pip_plugin">Installing the PIP Library</a></h3>
<ul>
<li>Compile PIP.
<li>Compile PIP.
<pre>
$> cd pip_plugin
$> make
@ -78,12 +78,12 @@ $> psql template_1 -f install[.ctype].sql
<p>For example:
<pre>
CREATE TABLE my_probabilistic_data(
name varchar(100),
name varchar(100),
data pip_eqn
);
INSERT INTO my_probabilistic_data
SELECT input.name,
CREATE_VARIABLE("Normal", vector(input.mean, input.stddev))
SELECT input.name,
CREATE_VARIABLE("Normal", ROW(input.mean, input.stddev))
FROM input;
</pre>
This example creates a random variable by iterating over each row of the table 'input'. The Normal distribution requires two parameters: a mean and a standard deviation, both of which are drawn from the corresponding row of the input table.<p>
@ -194,23 +194,23 @@ FROM results;</pre>
<h2><a name="reference_dist_list">Reference: Predefined Distributions</a></h2>
<dt>Zero</dt>
<dd>A distribution that is always zero (i.e., the <a href="http://en.wikipedia.org/wiki/Dirac_delta">Dirac Delta</a> as a distribution).
<pre>CREATE_VARIABLE("Zero", vector())</pre></dd>
<pre>CREATE_VARIABLE("Zero", ROW())</pre></dd>
<dt>Exponential</dt>
<dd><a href="http://en.wikipedia.org/wiki/Exponential_distribution">The Exponential Distribution</a>. The Exponential Distribution takes one parameter, lambda: the <b>inverse</b> of the expectation of the variable being created.
<pre>CREATE_VARIABLE("Exponential", vector(lambda))</pre></dd>
<pre>CREATE_VARIABLE("Exponential", ROW(lambda))</pre></dd>
<dt>Normal</dt>
<dd><a href="http://en.wikipedia.org/wiki/Normal_distribution">The Normal Distribution</a>. The Normal Distribution takes two parameters, the mean, and the standard deviation of the variable being created.
<pre>CREATE_VARIABLE("Normal", vector(mean, stddev))</pre></dd>
<pre>CREATE_VARIABLE("Normal", ROW(mean, stddev))</pre></dd>
<dt>Poisson</dt>
<dd><a href="http://en.wikipedia.org/wiki/Poisson_distribution">The Poisson Distribution</a>. The Poisson distribution takes one parameter, lambda: the expectation of the variable being created.
<pre>CREATE_VARIABLE("Poisson", vector(lambda))</pre></dd>
<pre>CREATE_VARIABLE("Poisson", ROW(lambda))</pre></dd>
<dt>Uniform</dt>
<dd><a href="http://en.wikipedia.org/wiki/Uniform_distribution_(continuous)">The Uniform Distribution</a>. The uniform distribution takes two parameters, the endpoints of the distribution; The endpoints may be provided in any order.
<pre>CREATE_VARIABLE("Uniform", vector(low, high))</pre></dd>
<pre>CREATE_VARIABLE("Uniform", ROW(low, high))</pre></dd>
</dl>
<hr />
@ -230,7 +230,7 @@ The components of a PIP distribution are as follows:
<dt><code>init_fn</code></dt>
<dd>A pointer to a constructor function for your distribution with the following schema:<pre>
void init_fn(pip_var *var, HeapTupleHeader params)</pre>
When your initializer is invoked, <code>var</code> will contain a pointer to initialized pip variable. <code>var->group_state</code> will contain a pointer to an allocated, but uninitialized block of [paramsize] bytes. <code>params</code> is a pointer to the postgres vector() of parameters. See below for information on utility functions for parsing the parameter vector.</dd>
When your initializer is invoked, <code>var</code> will contain a pointer to initialized pip variable. <code>var->group_state</code> will contain a pointer to an allocated, but uninitialized block of [paramsize] bytes. <code>params</code> is a pointer to the postgres ROW() of parameters. See below for information on utility functions for parsing the parameter vector.</dd>
<dt><code>gen_fn</code></dt>
<dd>A pointer to a generator function for your distribution with the following schema: <pre>
@ -262,7 +262,7 @@ When invoked, <code>str</code> will contain a pointer to a (large) allocated, bu
<dt><code>input_fn</code></dt>
<dd>NULL, or a pointer to a function for parsing a human-readable representation of the distribution's parameters, with the following schema:<pre>
int input_fn(pip_var *var, char *str)</pre>
When the input function is invoked, <code>var</code> will contain a pointer to initialized pip variable. <code>var->group_state</code> will contain a pointer to an allocated, but uninitialized block of [paramsize] bytes. <code>str</code> references a C string containing a human-readable representation of this distribution's parameters, as used in [output_fn]. The input function should parse this string (e.g., using sscanf) and initialize <code>var->group_state</code> in the same way as [init_fn]. <b>Note:</b> Although this function is optional, be aware that not including it will prevent users from being able to import data defined in terms of this distribution.
When the input function is invoked, <code>var</code> will contain a pointer to initialized pip variable. <code>var->group_state</code> will contain a pointer to an allocated, but uninitialized block of [paramsize] bytes. <code>str</code> references a C string containing a human-readable representation of this distribution's parameters, as used in [output_fn]. The input function should parse this string (e.g., using sscanf) and initialize <code>var->group_state</code> in the same way as [init_fn]. <b>Note:</b> Although this function is optional, be aware that not including it will prevent users from being able to import data defined in terms of this distribution.
</dl>
</p>
<hr />
@ -286,7 +286,7 @@ PIP includes a library of utility functions for use in defining distributions.
</dd>
<dt><code>void pip_box_muller(float8 *X, float8 *Y, int64 *seed)</code></dt>
<dd>Generate two random (but deterministic based on <code>seed</code>), independent, normally distributed floating point numbers (with mean of 0 and standard deviation of 1) using the <a href="http://en.wikipedia.org/wiki/Box-Muller_transform">Box-Muller method</a>. The <b>independent</b> variables will be stored in <code>X</code> and <code>Y</code> -- either or both may be used. The <code>seed</code> value is passed by reference, and is stepped to its next value automatically (note that the Box-Muller method requires two random numbers as input and as a consequence, <code>seed</code> is actually stepped twice).
<dd>Generate two random (but deterministic based on <code>seed</code>), independent, normally distributed floating point numbers (with mean of 0 and standard deviation of 1) using the <a href="http://en.wikipedia.org/wiki/Box-Muller_transform">Box-Muller method</a>. The <b>independent</b> variables will be stored in <code>X</code> and <code>Y</code> -- either or both may be used. The <code>seed</code> value is passed by reference, and is stepped to its next value automatically (note that the Box-Muller method requires two random numbers as input and as a consequence, <code>seed</code> is actually stepped twice).
</dd>
</body></html>
</body></html>