debian/0000775000000000000000000000000012267510362007174 5ustar debian/libdds-dev.manpages0000664000000000000000000000002411363416546012727 0ustar debian/SolveBoard.3 debian/README.source0000644000000000000000000000353511361036750011355 0ustar This package uses quilt to manage all modifications to the upstream source. Changes are stored in the source package as diffs in debian/patches and applied during the build. To configure quilt to use debian/patches instead of patches, you want either to export QUILT_PATCHES=debian/patches in your environment or use this snippet in your ~/.quiltrc: for where in ./ ../ ../../ ../../../ ../../../../ ../../../../../; do if [ -e ${where}debian/rules -a -d ${where}debian/patches ]; then export QUILT_PATCHES=debian/patches break fi done To get the fully patched source after unpacking the source package, cd to the root level of the source package and run: quilt push -a The last patch listed in debian/patches/series will become the current patch. To add a new set of changes, first run quilt push -a, and then run: quilt new where is a descriptive name for the patch, used as the filename in debian/patches. Then, for every file that will be modified by this patch, run: quilt add before editing those files. You must tell quilt with quilt add what files will be part of the patch before making changes or quilt will not work properly. After editing the files, run: quilt refresh to save the results as a patch. Alternately, if you already have an external patch and you just want to add it to the build system, run quilt push -a and then: quilt import -P /path/to/patch quilt push -a (add -p 0 to quilt import if needed). as above is the filename to use in debian/patches. The last quilt push -a will apply the patch to make sure it works properly. To remove an existing patch from the list of patches that will be applied, run: quilt delete You may need to run quilt pop -a to unapply patches first before running this command. debian/README.Debian0000664000000000000000000000117511361024117011231 0ustar dds for Debian -------------- This package is a composition of three zip files, the dds double dummy solver library, the ddd double dummy driver (frontend), and the pydds python extension. As there is already a ddd package in Debian (the gdb frontend) both the ddd binary and the package were renamed to dds. There is no shared library yet as the API/ABI is likely to change again. pydds was patched to also accept target, solutions, and mode as parameters in addition to trump and first. Users might want to read the API documentation in the libdds-dev package. -- Christoph Berg Thu, 25 Jan 2007 13:09:48 +0100 debian/compat0000664000000000000000000000000212267510024010365 0ustar 9 debian/source/0000775000000000000000000000000012215353704010472 5ustar debian/source/format0000664000000000000000000000001411677630475011716 0ustar 3.0 (quilt) debian/rules0000775000000000000000000000360111677657315010272 0ustar #!/usr/bin/make -f PYVERSIONS:=$(shell pyversions -vr) build-indep: build build-arch: build-stamp build-stamp: # libdds $(MAKE) # dds $(MAKE) -C ddd sed -ne '/^\/\* =/,/^\*\//p' ddd/giblib.h > ddd/giblib.txt # pydds -ln -s ../dll.h ../dds.cpp python cd python && set -ex && for v in $(PYVERSIONS) ; do python$$v setup.py build ; done touch $@ install: build-stamp dh_testroot dh_prep # libdds $(MAKE) install PREFIX=/usr DESTDIR=$(CURDIR)/debian/libdds-dev # dds $(MAKE) -C ddd install PREFIX=/usr DESTDIR=$(CURDIR)/debian/dds # pydds cd python && set -ex && for v in $(PYVERSIONS) ; do python$$v setup.py install --root $(CURDIR)/debian/python-pydds --install-layout=deb ; done test-ddd: build-stamp @echo Running ddd test ... ddd/ddd -giblib=1-100 ddd/test.gib @echo ddd test passed. test-python: build-stamp @echo Running pydds test ... cd python && set -ex && for v in $(PYVERSIONS) ; do set $(CURDIR)/python/build/lib.*$$v ; PYTHONPATH=$$1 python$$v trydds.py ; done @echo pydds test passed. binary-indep: binary binary-arch: install test-ddd test-python dh_installchangelogs -a release_notes.txt dh_installdocs -a -A debian/README.Debian dh_installman -a dh_installexamples -a dh_strip -a dh_compress -a dh_python2 -p'python-pydds' dh_fixperms -a dh_shlibdeps -a dh_installdeb -a dh_gencontrol -a dh_md5sums -a dh_builddeb -a clean: dh_testdir $(MAKE) clean $(MAKE) -C ddd clean rm -rf python/build dh_clean build-stamp ddd/giblib.txt python/dll.h python/dds.cpp VERSION:=$(shell head -n1 debian/changelog | sed -e 's/dds .//' -e 's/-.*//') origtgz: test ! -e ../dds_$(VERSION).orig.tar.gz test ! -d dds-$(VERSION) test ! -d .pc svn export . dds-$(VERSION) rm -rf dds-$(VERSION)/debian tar -czf ../dds_$(VERSION).orig.tar.gz dds-$(VERSION) rm -rf dds-$(VERSION) .PHONY: build build-indep build-arch clean binary binary-indep binary-arch install configure debian/dds.examples0000664000000000000000000000001211361024117011467 0ustar ddd/*.gib debian/dds.docs0000664000000000000000000000003611361024117010607 0ustar ddd/readme.txt ddd/giblib.txt debian/libdds-dev.docs0000664000000000000000000000003711361024117012053 0ustar DDS* DLL* mode2.txt readme.txt debian/control0000664000000000000000000000263712267510023010601 0ustar Source: dds Section: games Priority: extra Maintainer: Christoph Berg Build-Depends: debhelper (>> 9), python-all-dev (>= 2.6.6-3~) Standards-Version: 3.9.5 Homepage: http://privat.bahnhof.se/wb758135/ Vcs-Browser: http://svn.df7cb.de/bridge/dds/trunk Vcs-Svn: http://svn.df7cb.de/bridge/dds/trunk Package: dds Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends} Description: bridge double dummy solver - frontend dds is a double dummy solver. This package contains the driver frontend (originally named ddd). . A double dummy solver computes the optimal line of play for a bridge deal, with all hands open (both sides dummy). Package: libdds-dev Section: libdevel Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends} Description: bridge double dummy solver - library dds is a double dummy solver. This package contains the static library and the documentation. . A double dummy solver computes the optimal line of play for a bridge deal, with all hands open (both sides dummy). Package: python-pydds Section: python Architecture: any Depends: ${shlibs:Depends}, ${misc:Depends}, ${python:Depends} Provides: ${python:Provides} Description: bridge double dummy solver - Python extension dds is a double dummy solver. This package contains pydds, the Python extension. . A double dummy solver computes the optimal line of play for a bridge deal, with all hands open (both sides dummy). debian/python-pydds.examples0000664000000000000000000000003311361024117013362 0ustar python/trydds.py python/t1 debian/copyright0000664000000000000000000000472112215422123011121 0ustar This package was debianized by Christoph Berg on Thu, 25 Jan 2007 12:50:45 +0100. The orig.tar.gz tarball is composed of the zip files for the dds library and the ddd frontend, both downloaded from http://privat.bahnhof.se/wb758135/. The python module was fetched from http://www.aleax.it/Bridge/. Authors: dds: Bo Haglund , Bob Richardson pydds: Alex Martelli ddd: P.M.Cronje Copyright: dds: Copyright (C) 2006-2012 by Bo Haglund Cleanups and porting to Linux and MacOSX (C) 2006 by Alex Martelli. The code for calculation of par score / contracts is based upon the perl code written by Matthew Kidd for ACBLmerge. He has kindly given me permission to include a C++ adaptation in DDS. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. On Debian systems, the complete text of the Apache License, Version 2.0 can be found in the file /usr/share/common-licenses/Apache-2.0. ddd: Copyright 2003-2006 P.M.Cronje This file is part of the Double Dummer Driver (DDD). DDD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. DDD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. python-pydds: Copyright 2006 by Alex Martelli (aleaxit@gmail.com) This work is licensed under the Creative Commons Attribution 2.5 License (see http://creativecommons.org/licenses/by/2.5/). The code, being a derivative work of Bo Haglund's DDS 1.0 which was licensed under GPL, is of necessity also licensed under the GPL. On Debian systems, the complete text of the GNU General Public License can be found in the file /usr/share/common-licenses/GPL. debian/patches/0000775000000000000000000000000012267505704010627 5ustar debian/patches/series0000664000000000000000000000033712267505666012056 0ustar # dds patches makefile-gnu99 dll.h-extern_c # pydds patches pydds-initstart python-keywords pydds-dds120 sanitize-trydds.py # ddd patches ddd-gibware-url ddd-exitcode ddd-dds120 ddd-fix-testsuite ddd-initstart ddd-openmp debian/patches/ddd-openmp0000664000000000000000000000030311452057012012562 0ustar --- a/ddd/Makefile +++ b/ddd/Makefile @@ -30,7 +30,7 @@ CXX=g++ CXXFLAGS=-g -Wall -O2 LDFLAGS=-L.. -LIBS=-ldds +LIBS=-ldds -lgomp OBJ=ddd.o defs.o timer.o giblib.o rng.o PREFIX=/usr/local debian/patches/ddd-dds1200000664000000000000000000000514011361030324012261 0ustar --- a/ddd/ddd.cpp +++ b/ddd/ddd.cpp @@ -344,7 +344,7 @@ int main(int argc, char *argv[]) timer.start(); InitStart(); - sbcode = SolveBoard(dl,target,solutions,mode,&fut); + sbcode = SolveBoard(dl,target,solutions,mode,&fut,0); timer.check(); if(testSBCode(sbcode) == false) exit(-1); @@ -362,21 +362,9 @@ void cleanSB() { // this is the detach code from DDS - if(bestMove) - free(bestMove); - bestMove = 0; - if(nodeCards) - free(nodeCards); - nodeCards = 0; - if(winCards) - free(winCards); - winCards = 0; if(ttStore) free(ttStore); ttStore = 0; - if(rel) - free(rel); - rel = 0; } // cleanSB // ***************************************************************************** @@ -496,7 +484,7 @@ bool generate(int gen, unsigned int gens if(setDDS(&gib,&dl) == false) return false; InitStart(); - sbcode = SolveBoard(dl,target,sol,mode,&fut); + sbcode = SolveBoard(dl,target,sol,mode,&fut,0); if(testSBCode(sbcode) == false) return false; getSBScore(fut,&maxscore,bscore,m); @@ -693,7 +681,7 @@ bool giblib(char *pszfile, int target, i return false; InitStart(); - sbcode = SolveBoard(dl,target,sol,mode,&fut); + sbcode = SolveBoard(dl,target,sol,mode,&fut,0); timer.check(); if(testSBCode(sbcode) == false) return false; @@ -827,7 +815,7 @@ void playDD(cGIBLib *pgib, int target, i timer.check(); InitStart(); - sbcode = SolveBoard(dl,target,sol,1,&fut); + sbcode = SolveBoard(dl,target,sol,1,&fut,0); timer.check(); if(testSBCode(sbcode) == false) exit(-1); @@ -1078,7 +1066,7 @@ bool timeAll(char *pszfile, int trumps, timer.start(); InitStart(); - sbcode = SolveBoard(dl,target,sol,mode,&fut); + sbcode = SolveBoard(dl,target,sol,mode,&fut,0); timer.check(); if(testSBCode(sbcode) == false) return false; @@ -1252,7 +1240,7 @@ bool timeg(char *pszfile, int target, in return false; InitStart(); - sbcode = SolveBoard(dl,target,sol,mode,&fut); + sbcode = SolveBoard(dl,target,sol,mode,&fut,0); timer.check(); if(testSBCode(sbcode) == false) return false; @@ -1375,7 +1363,7 @@ bool tricks(cGIBLib *pgib, int ideal, in return false; InitStart(); - sbcode = SolveBoard(dl,target,sol,mode,&fut); + sbcode = SolveBoard(dl,target,sol,mode,&fut,0); timer.check(); if(testSBCode(sbcode) == false) return false; debian/patches/ddd-gibware-url0000664000000000000000000000113011361024117013502 0ustar --- a/ddd/readme.txt +++ b/ddd/readme.txt @@ -14,7 +14,7 @@ Description DDD is a driver for Bo Haglund's Double Dummy Solver (DDS), released separately under the GPL, -at http://web.telia.com/~u88910365/. +at http://web.telia.com/~u07502278/. This program is a command line interface for testing and using the DDS. @@ -39,6 +39,8 @@ Two sample files are provided --- test.g You can get the huge giblib file from the gibware site, Note that it must be the text version, not the binary version. +http://www.cirl.uoregon.edu/ginsberg/gibresearch.html + Compile and Link ---------------- debian/patches/ddd-fix-testsuite0000664000000000000000000000070611361024117014107 0ustar # '8' is just wrong here; the tricks line as a '7' in that position --- a/ddd/test.gib +++ b/ddd/test.gib @@ -21,7 +21,7 @@ k97..2.9 jt5...q6 q...a854 a86..3.7 {name=gib10 trumps=s tricks: 7575 8777 8888 5555 8888 (max=10) } -q98.2.qjt98.8 kj5.akq3..j65 t76.jt98.3.kt a42.7654.5.a2:-------8------------ +q98.2.qjt98.8 kj5.akq3..j65 t76.jt98.3.kt a42.7654.5.a2:75758777888855558888 {name=gin trumps=n tricks: 9998 9898 9999 6666 7777 (max=13) debian/patches/pydds-initstart0000664000000000000000000000031311452054316013702 0ustar --- a/python/pydds.c +++ b/python/pydds.c @@ -332,5 +332,7 @@ initpydds(void) PyType_Ready(&deal_type); PyObject_SetAttrString(m, "deal", (PyObject*)&deal_type); + + InitStart(1, 1); } debian/patches/pydds-dds1200000664000000000000000000000113611361031660012656 0ustar --- a/python/pydds.c +++ b/python/pydds.c @@ -6,6 +6,10 @@ #include /* type-definition & utility-macros */ +struct dealType { + unsigned short int deal[4][4]; +}; + typedef struct { PyObject_HEAD int noOfCards; @@ -226,7 +230,7 @@ deal_solve(PyObject *self, PyObject *arg showdist(d.remainCards); // printf(" 4"); fflush(0); struct futureTricks futp; - int status = SolveBoard(d, target, solutions, mode, &futp); + int status = SolveBoard(d, target, solutions, mode, &futp, 0); // printf(" 5 %d", status); fflush(0); if (status!=1) { char buf[80]; debian/patches/python-keywords0000664000000000000000000000230611361024117013725 0ustar Index: trunk/python/pydds.c =================================================================== --- trunk.orig/python/pydds.c 2007-01-19 00:56:59.997057440 +0100 +++ trunk/python/pydds.c 2007-01-19 00:57:09.336637608 +0100 @@ -207,11 +207,12 @@ deal_str(PyObject *self) static PyObject* deal_solve(PyObject *self, PyObject *args, PyObject *kwds) { - static char* nams[] = {"trump", "first", NULL}; - int trump=4, first=1; + static char* nams[] = {"trump", "first", "target", "solutions", "mode", NULL}; + int trump=4, first=1, target=-1, solutions=1, mode=0; int i, j; - if(!PyArg_ParseTupleAndKeywords(args, kwds, "|ii", nams, &trump, &first)) + if(!PyArg_ParseTupleAndKeywords(args, kwds, "|iiiii", nams, + &trump, &first, &target, &solutions, &mode)) return 0; deal_cell* me = (deal_cell*)self; struct deal d; @@ -225,7 +226,7 @@ deal_solve(PyObject *self, PyObject *arg showdist(d.remainCards); // printf(" 4"); fflush(0); struct futureTricks futp; - int status = SolveBoard(d, -1, 1, 0, &futp); + int status = SolveBoard(d, target, solutions, mode, &futp); // printf(" 5 %d", status); fflush(0); if (status!=1) { char buf[80]; debian/patches/dll.h-extern_c0000664000000000000000000000074712215360050013352 0ustar --- a/dll.h +++ b/dll.h @@ -459,7 +459,7 @@ EXTERN_C DLLEXPORT int STDCALL CalcParPB EXTERN_C void InitStart(int gb_ram, int ncores); /* For usage with ctypes in Linux. */ #endif -void InitStart(int gb_ram, int ncores); +EXTERN_C void InitStart(int gb_ram, int ncores); void InitGame(int gameNo, int moveTreeFlag, int first, int handRelFirst, int thrId); void InitSearch(struct pos * posPoint, int depth, struct moveType startMoves[], int first, int mtd, int thrId); debian/patches/sanitize-trydds.py0000664000000000000000000000277311361024117014333 0ustar Index: trunk/python/trydds.py =================================================================== --- trunk.orig/python/trydds.py 2007-01-19 01:02:23.212921160 +0100 +++ trunk/python/trydds.py 2007-01-19 01:05:49.711528600 +0100 @@ -1,4 +1,4 @@ -#!/usr/local/bin/python +#!/usr/bin/python import sys import pydds @@ -10,10 +10,10 @@ timer = time.time def dod(ds): t = timer() d = timer() - # deal = [h.split(' ') for h in ds.split('|')] - deal = [h.split('.') for h in ds.split()[1::2]] + deal = [h.split(' ') for h in ds.split('|')] + #deal = [h.split('.') for h in ds.split()[1::2]] d = timer() - d - print 'D', 8*'.','|'.join(' '.join(s) for s in deal) + #print 'D', 8*'.','|'.join(' '.join(s) for s in deal) # sys.stdout.flush() a = timer() dd = pydds.deal(deal) @@ -26,17 +26,17 @@ def dod(ds): b = timer() - b t = timer() - t print 'T%d' % s[-1][0], - print '%.2f %.2f %.2f %.2f' % (d, a, b, t) + #print '%.2f %.2f %.2f %.2f' % (d, a, b, t) # print '|'.join(' '.join(s) for s in deal), print s return t -# ds = 'AQ9 AQ9 8643 KQ8|T82 T6542 AKT A7|K653 K83 Q92 543|J74 J7 J75 JT962' -ds='n AQ3.T653.KQ4.AJ5 e KJT4.AKQ8.JT86.8 s 862.974.A73.KQ72 w 975.J2.952.T9643' -print ds -dod(ds) -sys.exit() +#ds = 'AQ9 AQ9 8643 KQ8|T82 T6542 AKT A7|K653 K83 Q92 543|J74 J7 J75 JT962' +##ds='n AQ3.T653.KQ4.AJ5 e KJT4.AKQ8.JT86.8 s 862.974.A73.KQ72 w 975.J2.952.T9643' +#print ds +#dod(ds) +#sys.exit() def main(): handsfile = open('t1') debian/patches/ddd-initstart0000664000000000000000000000444411451722653013330 0ustar --- a/ddd/ddd.cpp +++ b/ddd/ddd.cpp @@ -343,7 +343,11 @@ int main(int argc, char *argv[]) fflush(stdout); timer.start(); +#if DDS_VERSION >= 20101 + InitStart(1, 1); +#else InitStart(); +#endif sbcode = SolveBoard(dl,target,solutions,mode,&fut,0); timer.check(); if(testSBCode(sbcode) == false) @@ -483,7 +487,11 @@ bool generate(int gen, unsigned int gens gib.Leader = leader; if(setDDS(&gib,&dl) == false) return false; +#if DDS_VERSION >= 20101 + InitStart(1, 1); +#else InitStart(); +#endif sbcode = SolveBoard(dl,target,sol,mode,&fut,0); if(testSBCode(sbcode) == false) return false; @@ -680,7 +688,11 @@ bool giblib(char *pszfile, int target, i if(setDDS(&gib,&dl) == false) return false; +#if DDS_VERSION >= 20101 + InitStart(1, 1); +#else InitStart(); +#endif sbcode = SolveBoard(dl,target,sol,mode,&fut,0); timer.check(); if(testSBCode(sbcode) == false) @@ -814,7 +826,11 @@ void playDD(cGIBLib *pgib, int target, i return; timer.check(); +#if DDS_VERSION >= 20101 + InitStart(1, 1); +#else InitStart(); +#endif sbcode = SolveBoard(dl,target,sol,1,&fut,0); timer.check(); if(testSBCode(sbcode) == false) @@ -1065,7 +1081,11 @@ bool timeAll(char *pszfile, int trumps, return false; timer.start(); +#if DDS_VERSION >= 20101 + InitStart(1, 1); +#else InitStart(); +#endif sbcode = SolveBoard(dl,target,sol,mode,&fut,0); timer.check(); if(testSBCode(sbcode) == false) @@ -1239,7 +1259,11 @@ bool timeg(char *pszfile, int target, in if(setDDS(&gib,&dl) == false) return false; +#if DDS_VERSION >= 20101 + InitStart(1, 1); +#else InitStart(); +#endif sbcode = SolveBoard(dl,target,sol,mode,&fut,0); timer.check(); if(testSBCode(sbcode) == false) @@ -1362,7 +1386,11 @@ bool tricks(cGIBLib *pgib, int ideal, in if(setDDS(pgib,&dl) == false) return false; +#if DDS_VERSION >= 20101 + InitStart(1, 1); +#else InitStart(); +#endif sbcode = SolveBoard(dl,target,sol,mode,&fut,0); timer.check(); if(testSBCode(sbcode) == false) debian/patches/makefile-gnu990000664000000000000000000000050312235015102013255 0ustar Description: Use -std=gnu99 instead of -std=c99 to get popen() Author: Adam Conrad Bug: #727777 --- dds-2.3.0+ddd105.orig/Makefile +++ dds-2.3.0+ddd105/Makefile @@ -1,4 +1,4 @@ -CFLAGS=-g -Wall -O2 -std=c99 -fopenmp +CFLAGS=-g -Wall -O2 -std=gnu99 -fopenmp PREFIX=/usr/local all: libdds.a python debian/patches/ddd-exitcode0000664000000000000000000000373511361024117013103 0ustar # make ddd exit with code 1 if something goes wrong, especially the test suite --- a/ddd/ddd.cpp +++ b/ddd/ddd.cpp @@ -151,6 +151,7 @@ int main(int argc, char *argv[]) unsigned int genseed=0; FILE *fp; cTimer timer; + int success = true; struct deal dl; struct futureTricks fut; @@ -282,19 +283,19 @@ int main(int argc, char *argv[]) } if(gen > 0) - { generate(gen,genseed,gencards,gentricks); + { success = generate(gen,genseed,gencards,gentricks); goto cleanup; } if(btimeall) - { timeAll(pszfile,trumps,leader); + { success = timeAll(pszfile,trumps,leader); goto cleanup; } else if(pszxcn) - { timeg(pszfile,-1,1,1,pszxcn,(leader==-1?0:leader),bverbose); + { success = timeg(pszfile,-1,1,1,pszxcn,(leader==-1?0:leader),bverbose); goto cleanup; } else if(pszgiblib) - { giblib(pszfile,-1,1,1,pszgiblib); + { success = giblib(pszfile,-1,1,1,pszgiblib); goto cleanup; } @@ -312,7 +313,7 @@ int main(int argc, char *argv[]) } if(btricks) - { tricks(&gib,deal,-1,1,1); + { success = tricks(&gib,deal,-1,1,1); goto cleanup; } @@ -330,7 +331,7 @@ int main(int argc, char *argv[]) } // set up dds10 - if(setDDS(&gib,&dl) == false) + if(success = setDDS(&gib,&dl) == false) return -1; printf("\n"); @@ -352,7 +353,7 @@ int main(int argc, char *argv[]) cleanup: cleanSB(); - return 0; + return !success; } // main // ***************************************************************************** @@ -757,8 +758,11 @@ bool giblib(char *pszfile, int target, i pszgiblib,format64(totalnodes,sz1), ntotal?format64(totalnodes/ntotal,sz2):format64(totalnodes,sz2), totalelapsed,ntotal?totalelapsed/(double)ntotal:totalelapsed); - if(nerror) + if(nerror) + { printf("*** ERROR: nerror=%d, tricks and score different\n",nerror); + return false; + } printf("\n"); fclose(fp); debian/SolveBoard.30000664000000000000000000004632212267504744011336 0ustar .TH SolveBoard 3 2014-01 .\"Bo Haglund, Bob Richardson .\"Rev S, 2014-01-18 .\"Latest DLL issue with this description is available at http://www.bahnhof.se/wb758135/ .SH NAME InitStart, SolveBoard, SolveBoardPBN, CalcDDtable, CalcDDtablePBN, CalcAllTables, CalcAllTablesPBN, SolveAllBoards, CalcPar, CalcParPBN - calculate number of possible tricks in a Bridge hand .SH SYNOPSIS .B #include .B void InitStart(int gb_ram, int ncores); .B int SolveBoard(struct deal, int target, int solutions, int mode, struct futureTricks *futp, int threadIndex); .B int SolveBoardPBN(struct dealPBN, int target, int solutions, int mode, struct futureTricks *futp, int threadIndex); .B int CalcDDtable(struct ddTableDeal tableDeal, struct ddTableResults *tablep); .B int CalcDDtablePBN(struct ddTableDealPBN tableDealPBN, struct ddTableResults *tablep); .B int CalcAllTables(struct ddTableDeals *dealsp, int mode, int trumpFilter[5], struct ddTablesRes *resp, struct allParResults*presp); .B int CalcAllTablesPBN(struct ddTableDealsPBN *dealsp, int mode, int trumpFilter[5], struct ddTablesRes *resp, struct allParResults *presp); .B int SolveAllBoards(struct boardsPBN *bop, struct solvedBoards *solvedp); .B int CalcPar(struct ddTableDeal tableDeal, int vulnerable, struct ddTableResults * tablep, struct parResults *presp); .B int CalcParPBN(struct ddTableDealPBN tableDealPBN, struct ddTableResults * tablep, int vulnerable, struct parResults *presp); .SH DESCRIPTION Short description of the DLL functions supported in Double Dummy Problem Solver 2.1.2 .B InitStart Initialize data structures for \fBSolveBoard\fP. If either \fBgb_ram\fP or \fBncores\fP are zero, autoconfiguration is done. This is currently only supported on Windows; other platforms exit fatally when attempted. .B SolveBoard Before \fBSolveBoard\fP can be called, a structure of type "\fBfutureTricks\fP" must be declared. SolveBoard returns a status integer, "no fault" means the DLL supplies the trick data in the "\fBfutureTricks\fP" type structure. Status codes: 1=No fault -1=Unknown fault -2=No of cards = 0 -3=target > Number of tricks left -4=Duplicated cards -5=target < -1 -7=target > 13 -8=solutions < 1 -9=solutions > 3 -10=No of cards > 52 -11=Not used -12=Suit or rank value out of range for deal.currentTrickSuit or deal.currentTrickRank -13=Card already played in the current trick is also defined as a remaining card to play -14=Wrong number of remaining cards for a hand -15=threadIndex < 0 or >=noOfThreads, noOfThreads is the configured maximum number of threads. Structure ”\fBdeal\fP” defines all data needed to describe the deal to be analyzed. \fBstruct deal { int trump;\fP /* I.e. which suit that is trump or if contract is NT, Spades=0, Hearts=1, Diamonds=2, Clubs=3, NT=4 */ \fBint first;\fP /* 0-3, 0=North, 1=East, 2=South, 3=West , Leading hand for the trick.*/ \fBint currentTrickSuit[3];\fP /* 0-2 for up to 3 cards in the order played */ \fBint currentTrickRank[3];\fP /* 2-14 for up to 3 cards */ \fBunsigned int remainCards[4][4];\fP /* 1st index hand (0-3), 2nd index suit (0-3), values as bitstring of ranks bit 0=0, bit 1=0, bit 2=rank 2, ………. bit 14=rank 14, bit 15=0 for cards remaining after already played cards (cards already played to the current trick are not included in this bitstring). The decimal value for a card then range between 4 (=rank 2) and 16384 (Ace=rank 14). */ \fB};\fP Parameter ”\fItarget\fP” is the number of tricks to be won by the side to play, -1 means that the program shall find the maximum number. For equivalent cards only the highest is returned. Parameter ”\fIsolutions\fP” defines how many card solutions that SolveBoard must return: .TP .B target=1-13, solutions=1: Returns only one of the cards. Its returned score is the same as target when target or higher tricks can be won. Otherwise, score -1 is returned if target cannot be reached, or score 0 if no tricks can be won. .TP .B target=-1, solutions=1: Returns only one of the optimum cards and its score. .TP .B target=0, solutions=1: Returns only one of the cards legal to play with score set to 0. .TP .B target 1-13, solutions=2: Return all cards meeting target. Their returned scores are the same as target when target or higher tricks can be won. Otherwise, only one card is returned with score -1 if target cannot be reached, or score 0 for all cards legal to play if no tricks can be won. .TP .B target -1, solutions=2: Return all optimum cards with their scores. .TP .B target=0, solutions=2: Return all cards legal to play with scores set to 0. .TP .B target irrelevant, solutions=3: Return all cards that can be legally played with their scores in descending order. .PP Parameter ”\fImode\fP” defines the DLL mode of operation. .TP .B mode=0 Do not search to find the score if the hand to play has only one card, including its equivalents, to play. Score is set to -2 for this card, indicating that there are no alternative cards. If there are multiple choices for cards to play, search is done to find the score. This mode is very fast but you don’t always search to find the score. .TP .B mode=1 Always search to find the score. Even when the hand to play has only one card, with possible equivalents, to play. For both mode=0 and mode=1: If the preceding SolveBoard call had the same trump suit and the same or similar deal, except for deal.first, then the transposition table contents is reused from the preceding SolveBoard call. Setting mode=2 is no longer needed in this case, but can still be done for backwards compatibility. .TP .B mode=2 As for mode=1, but the transposition table contents is reused from the preceding SolveBoard call. It is the responsibility of the programmer using the DLL to ensure that reusing the table is safe in the actual situation. Example: Deal is the same, except for deal.first. Trump suit is the same. 1st call: SolveBoard(deal, -1, 1, 1, &fut, 0), deal.first=1, i.e. East leads. 2nd call: SolveBoard(deal, -1, 1, 2, &fut, 0), deal.first=2, i.e. South leads. 3rd call: SolveBoard(deal, -1, 1, 2, &fut, 0), deal.first=3, i.e. West leads. 4th call: SolveBoard(deal, -1, 1, 2, &fut, 0), deal.first=0, i.e. North leads. .PP \fBstruct futureTricks {\fP /* The DLL provides the score (number of tricks) that can be won by the card to play defined by its suit and rank. Array of all alternative cards. */ \fBint nodes;\fP /* Number of searched nodes */ \fBint cards;\fP /* No of alternative cards */ \fBint suit[13];\fP /* 0=Spades, 1=Hearts, 2=Diamonds, 3=Clubs */ \fBint rank[13];\fP /* 2-14 for 2 through Ace */ \fBint equals[13];\fP /* Bitstring of ranks for equivalent lower rank cards. The decimal value range between 4 (=2) and 8192 (King=rank 13). When there are several ”equals”, the value is the sum of each ”equal”. */ \fBint score[13];\fP /* -1 indicates that target was not reached, otherwise target or max numbe of tricks */ \fB};\fP Parameter ”\fIthreadIndex\fP” defines the identity of the thread used when calling SolveBoard. A configured maximum number of threads can call SolveBoard in parallel, threadIndex must be an integer in the range 0..max number of threads - 1. This maximum number is configured at DLL initial start-up and cannot exceed 16. SolveBoard is thread-safe, so several threads (max 16) can call SolveBoard in parallel. .B SolveBoardPBN In SolveBoardPBN the remaining cards in the deal information are given in PBN text format (e.g. \fBW:T5.K4.652.A98542 K6.QJT976.QT7.Q6 432.A.AKJ93.JT73 AQJ987.8532.84.K\fP) instead of using bits 2-14 in an integer array. Otherwise, \fBSolveboardPBN\fP is identical to \fBSolveBoard\fP. \fBstruct dealPBN {\fP \fBint trump;\fP \fBint first;\fP \fBint currentTrickSuit[3];\fP \fBint currentTrickRank[3];\fP \fBchar remainCards[80];\fP /* First character identifies the hand having the cards given first in the string, then the cards of the other hands are given in a clock-wise order, see example above. Null characters fill out the character array at the end. */ \fB};\fP .B CalcDDtable CalcDDtable calculates the double dummy values of the initial 52 cards for all the 20 trump suit/declarer hand combinations. Before CalcDDtable can be called, a structure of type "\fBddTableResults\fP" must be declared. CalcDDtable returns a status integer, "no fault" means the DLL supplies the double dummy scores in the "\fBddTableResults\fP" type structure. Status codes: 1=No fault, Other status codes are errors, with codes equal to SolveBoard status codes. Structure ”\fBddTableDeal\fP” defines the dealt cards to be analyzed. \fBstruct ddTableDeal { unsigned int cards[4][4];\fP /* 1st index is hand, 2nd index is suit, same coding as for deal.remainCards for SolveBoard. */ \fB};\fP \fBstruct ddTableResults {\fP /* For each combination trump suit / declarer hand, the DLL provides the double dummy score. */ \fBint resTable[5][4];\fP /* 1st index is trump (0=Spades, 1=Hearts, 2=Diamonds, 3=Clubs, 4=No Trump 2nd index is declarer hand, 0=North, 1=East, 2=South, 3=West */ \fB};\fP .B CalcDDtablePBN In \fBCalcDDtablePBN\fP the remaining cards in the deal information are given in PBN text format, see the description above for \fBSolveBoardPBN\fP. Otherwise, \fBCalcDDtablePBN\fP is identical to \fBCalcDDtable\fP. \fBstruct ddTableDealPBN {\fP \fBchar cards[80];\fP \fB};\fP .B CalcAllTables CallAllTables calculates the double dummy values of the trump suit/declarer hand combinations for a nu mber of DD tables in parallel. This increases the speed compared to calculating these values using a Ca lcDDtable call for each DD table. The maximum number of DD tables in a CallAllTables call depends on the number of strains (the number o f 5 trump alternatives, any of the 4 suits and no trump) to be part of the DD calculations. If all 5 st rains are included there are 20 declarer hand / strain combinations. The maximum number of boards that can be calculated in parallel is 200, so the maximum number of DD tables that can be included in a Call AllTable call is 10. At fewer strains the maximum number of DD tables in a call is higher: 4 strains maximum 12 DD tables 3 strains maximum 16 DD tables 2 strains maximum 25 DD tables 1 strain maximum 50 DD tables Before CalcAllTables can be called, a structure of type "ddTablesRes" must be declared. CallAllTables returns a status integer, "no fault" means the DLL supplies the double dummy scores in t he "ddTablesRes" type structure. Its contained structure of type “ddTableResults” is described for the function CalcDDtable. The variable “noOfBoards” shows the number of solved boards (max 200). \fBstruct ddTablesRes {\fP \fBint noOfBoards;\fP \fBstruct ddTableResults results[MAXNOOFBOARDS / 4];\fP \fB};\fP Status codes: 1=No fault, -201=Error, all trump suits and the no trump suit alternative have been marked in the calling parameter trumpFilter to be left out (i.e. they have all been set to TRUE), -202=Error, too many DD tables in the call. Structure “ddTableDeals” contains up to 50 DD table deals, each in a structure “ddTableDeal”, described for the function CalcDDtable. The actual number is set in the “noOfTables” parameter. \fBstruct ddTableDeals {\fP \fBint noOfTables;\fP \fBstruct ddTableDeal deals[MAXNOOFBOARDS / 4];\fP \fB};\fP Parameter “mode” specifies whether or not par score and par contracts will be calculated and if so, which sides that are vulnerable: -1: no par calculation 0: par calculation, vulnerability None 1: par calculation, vulnerability All 2: par calculation, vulnerability NS only 3: par calculation, vulnerability EW only The results of the par calculations are given in the structure “allParResults”, which contains the results for all boards. Each board results are given in structure “parResults”, described for the CalcPar function. \fBstruct allParResults {\fP \fBstruct parResults presults[MAXNOOFBOARDS / 4];\fP \fB};\fP Parameter “trumpFilter” describes which, if any, of the trump suits or the no trump suit alternatives that will be excluded from the calculations. They are defined in the order Spades, Hearts, Diamonds, Clubs and No Trumps. E.g. setting trumpFilter to {FALSE, FALSE, TRUE, TRUE, TRUE} means that values will only be calculated for the trump suits Spades and Hearts. .B CalcAllTablesPBN As for CalcAllTables except that the deals are given in PBN format. The structure “ddTableDealPBN” is described for the CalcDDtablePBN function. \fBstruct ddTableDealsPBN {\fP \fBint noOfTables;\fP \fBstruct ddTableDealPBN deals[MAXNOOFBOARDS / 4];\fP \fB}; .B SolveAllBoards SolveAllBoards solves a number of boards in parallel for increased performance compared to solve them sequentionally using a SolveBoard call for each board. SolveAllBoards is called with a buffer containing board data for a number of boards, maximum 200 boards per call. Each board is defined with the same input data as in SolveBoardPBN. The input data per board can be freely given independent of the settings for the other deals. SolveAllBoards uses multi-thread calls to SolveBoardPBN for solving the buffered boards. struct boardsPBN { int noOfBoards; struct dealPBN deals[MAXNOOFBOARDS]; int target[MAXNOOFBOARDS]; int solutions[MAXNOOFBOARDS]; int mode[MAXNOOFBOARDS]; }; struct solvedBoards { int noOfBoards; struct futureTricks solvedBoard[MAXNOOFBOARDS]; }; In the SolveAllBoards call, the cards are coded in PBN text format using the dealPBN structure. The number of boards to be solved must be defined in the boardsPBN structure, the number must not exceed MAXNOOFBOARDS which is 100. In the returned information in struct solvedBoards, the number of solved boards are given. The futureTricks information is provided for all solved boards with the same returned information per board as with SolveBoard. SolveAllBoards returns 1 if the call succeeds, otherwise an error code identical to the SolveBoard error codes is given when there is a problem in the input information. Notes on DDS use for simulations SolveAllBoards is optimal when the input boards are dissimilar. Adjacent boards in the boards buffer that are similar (same trump, very minor difference between cards distribution between hands) typically means that transposition table information cannot be reused. That is because these boards typically use different threads. In simulations involving different declarer hand alternatives and possibly also different suit trump alternatives, usage of CalcAllTables is a more convenient and probably a faster alternative. E.g. if the task is to make simulations to find which of the major suits is best in a trump contract and which hand is best as declarer, then such simulation is easily set up using CalcAllTables and most likely runs faster than with SolveAllBoards. .B CalcPar CalcPar calculates the par score and par contracts of a given deal. It also includes calculation and presentation of the double dummy values table otherwise calculated by the CalcDDtable function, since this table is a prerequisite for the par calculations. Thus there is no need to make a CalcDDtable call before calling CalcPar. Before CalcPar can be called, a structure of each type " ddTableResults" and “parResults” must be declared. CalcPar returns a status integer, "no fault" means the DLL supplies the double dummy scores in the "ddTableResults" type structure and the par results in the “parResults” structure. Calling CalcPar with the structure of type “ddTableDeal” is done in the same way as for calling CalcDDtable. Status codes: 1=No fault, Other status codes are errors, with codes equal to SolveBoard status codes. Parameter “vulnerable” is set according to: 0 = None 1 = Both sides 2 = North / South side vulnerable 3 = East / West side vulnerable The structure types “ddTableDeal” and “ddTableresults” are described for the function CalcDDtable. The “parResults” structure type includes the par score and the par contracts results returned by the call to CalcPar: struct parResults { char parScore[2][16]; /* index = 0 is from NS view and index =1 is from EW view. */ char parContractsString[2][128]; /* index = 0 is NS view and index = 1 is EW view. By “view” is here meant which side that starts the bidding. */ }; Par score is given as a text string, e.g NS -460. NS lost 460 points. All par contracts for different suits are listed with comma separating the suits. Possible different trick levels of par score contracts are enumerated in the contract description, e.g the possible trick levels 3, 4 and 5 in No trumps, are given as 345N. Example of par contracts in different suits: NS:NS 23S,NS 23H This is from the NS view. North and South as declarer make 2 or 3 Spades and Hearts contracts, 2 Spades and 2 Hearts with an overtrick. If only North could make 3 Hearts, the text string would have looked: NS:NS 23S,N 23H NS before the colon refers to the assumed side that made the initial bid in the process for determining the par score / contracts. Also, DDS calculates the par score / contracts when the assumed side is EW: EW:NS 23S,N 23H Nearly always, the par score / contracts are the same for both starting points. One case where they are not is if both sides can make 1 NT but no other contract. .B CalcParPBN The only difference compared to CalcPar is that the structure type “ddTableDealPBN” is used instead of “ddTableDeal”. For description of “ddTableDealPBN”, see CalcDDtablePBN. .SH Revision History Rev A, 2006-02-25 First issue. Rev B, 2006-03-20 Updated issue. Rev C, 2006-03-28 Updated issue. Addition of the SolveBoard parameter ”mode”. Rev D, 2006-04-05 Updated issue. Usage of target=0 to list all cards that are legal to play. Rev E, 2006-05-29 Updated issue. New error code -10 for number of cards > 52. Rev F, 2006-08-09 Updated issue. New mode parameter value = 2. New error code -11 for calling SolveBoard with mode = 2 and forbidden values of other parameters. Rev F1, 2006-08-14 Clarifications on conditions for returning scores for the different combinations of the values for target and solutions. Rev F2, 2006-08-26 New error code -12 for wrongly set values of deal.currentTrickSuit and deal.currentTrickRank. Rev G, 2007-01-04 New DDS release 1.1, otherwise no change compared to isse F2. Rev H, 2007-04-23 DDS release 1.4, changes for parameter mode=2. Rev I, 2010-04-10 DDS release 1.2, multi-thread support. Rev J, 2010-05-29 DDS release 2.1, OpenMP support, reuse of previous DD transposition table results of similar deals. Rev K, 2010-10-27 Correction of fault in the description: 2nd index in resTable of the structure ddTableResults is declarer hand. Rev L, 2011-10-14 Added SolveBoardPBN and CalcDDtablePBN. Rev M, 2012-07-06 Added SolveAllBoards. Rev N, 2012-07-16 Max number of threads is 8. Rev O, 2012-10-21 Max number of threads is configured at initial start-up, but never exceeds 16. Rev P, 2013-03-16 Added functions CalcPar and CalcParPBN. Rev Q, 2014-01-09 Added functions CalcAllTables/CalcAllTablesPBN. Rev R, 2014-01-13 Updated functions CalcAllTables/CalcAllTablesPBN. Rev S, 2014-01-13 Updated functions CalcAllTables/CalcAllTablesPBN. debian/dds.60000664000000000000000000001233511361024117010031 0ustar .TH DDS 6 .SH NAME dds \- double dummy solver frontend .SH SYNOPSIS .B dds .I file [ .I options ] .SH DESCRIPTION This program is a command line interface for Bo Haglund's Double Dummy Solver (DDS). .PP It has four useful stand-alone options: .IP 1. Option \fB\-playdd\fP, to play any deal double dummy. .IP 2. Option \fB\-giblib\fP. For any deal, to get maximum trick values for all possible contracts and leaders (these are the 20 trick values as for giblib). .IP 3. Option \fB\-tricks\fP. For specified deal, to get maximum trick values for all possible contracts and leaders (these are the 20 trick values as for giblib). .IP 4. Option \fB\-gen\fP. This is to generate deals, without or with up to 20 possible trick values. .SH OPTIONS .BR \fIfile\fP path for 'giblib' input file .TP Optional arguments [\fIoptions\fP] are one or more of: .TP .BR \-v verbose where applicable .TP .BR \-target=\fId\fP \-1-13 (default \-1). Number of tricks to be won by the side to play, \-1 means that the program shall find the maximum number. For equivalent cards only the highest is returned. .TP .BR \-sol=\fId\fP solution 1/2/3 (default 3). How many card solutions SolveBoard returns: target=1-13, solutions=1: Returns only one of the cards. Its returned score is the same as target when target or higher tricks can be won. Otherwise, score \-1 is returned if target cannot be reached, or score 0 if no tricks can be won. target=\-1, solutions=1: Returns only one of the optimum cards and its score. target=0, solutions=1: Returns only one of the cards legal to play with score set to 0. target=1-13, solutions=2: Return all cards meeting target. Their returned scores are the same as target when target or higher tricks can be won. Otherwise, only one card is returned with score \-1 if target cannot be reached, or score 0 for all cards legal to play if no tricks can be won. target=\-1, solutions=2: Return all optimum cards with their scores. target=0, solutions=2: Return all cards legal to play with scores set to 0. target irrelevant, solutions=3: Return all cards that can be legally played with their scores in descending order. .TP .BR \-mode=\fId\fP 0/1 (default 1). DLL mode of operation. This mode does not affect the DLL if there are multiple choices for cards to play. If there is just one card to play, or multiple cards that are all equivalent, this mode determines whether or not the DLL will search to find the score. mode=0: Do not search to find the score if the hand to play has only one card, including its equivalents, to play. Score is set to \-2 for this card, indicating that there are no alternative cards. This mode is very fast. mode=1: Always search to find the score. Even when the hand to play has only one card, with possible equivalents, to play. .\" .\"mode=2: As for mode=1, but the transposition table contents is reused from the .\"preceding SolveBoard call. Requires that target is the same as for the .\"preceding call and is not target=\-1. The parameter solutions must be set to 1, .\"deal must be the same, except that deal.first for the second call is partner to .\"deal.first in the first call. .\"Example: .\"1st call: SolveBoard(deal, 10, 1, 1, &fut1), deal.first=1, i.e. East leads. .\"2nd call: SolveBoard(deal, 10, 1, 2, &fut2), deal.first=3, i.e. West leads. .TP .BR \-trumps=\fIt\fP s/h/d/c/n, this overrides the file (default=n) .TP .BR \-leader=\fIl\fP w/n/e/s, this overrides the file (default=w) but used only when no cards have been played .TP .BR \-deal=\fId\fP 1/2/... deal number in giblib file. Only one of \fB\-deal\fP or \fB\-name\fP should be specified. .TP .BR \-name=\fIstr\fP deal with 'name=str' in giblib file. Only one of \fB\-deal\fP or \fB\-name\fP should be specified. .TP .BR \-playdd play deal choosing between DDS alternatives .TP .BR \-timeall time all deals in file for sol=1/2/3, print stats .TP .BR \-timeg=\fIxcn\fP \fIx\fP - hex digit, total tricks by n-s \fIc\fP - contract s/h/d/c/n \fIn\fP - number of deals time the first n deals in the giblib file, having total tricks x at contract c, for target=\-1 sol=1 mode=1 and for the specified/default leader, each deal is validated. .TP .BR \-giblib=\fId1\fP\-\fId2\fP[\-all] validate all deals from d1 to d2 in giblib file for target=\-1 sol=1 mode=1. 1. if \fB\-all\fP is given, this is done for all of the 20 trick values even if some of them are '\-'. 2. if \fB\-all\fP is not given, this is done only for those trick values which are not '\-'. .TP .BR \-tricks like \fB\-giblib\fP, but for single deal specified by \fB\-name\fP=str \fB\-deal\fP=d or option .TP Generate deals: .TP .BR \-gen=\fIn\fP (required) n=number of deals to generate. output is written to a file (see below) .TP .BR \-genseed=\fIs\fP (default 0) seed for random generator .TP .BR \-gencards=\fIc\fP (default=52) number of cards generated per deal, must be multiple of 4 .TP .BR \-gentricks=\fIt\fP 0,1,...,20 (default 1), number of tricks values to set randomly .TP Generate output is written to a file: gen\-\fIgenseed\fP\-\fIndeal\fP\-\fIgencards\fP\-\fIgentricks\fP.txt .SH NOTES The program was named ddd by its author. As there is already some other ddd package in Debian (the gdb frontend) it was renamed to dds, the name of the library used. .SH "SEE ALSO" dealer(6), deal(6). debian/watch0000664000000000000000000000035612215353716010232 0ustar version=3 opts=dversionmangle=s/\+ddd\d+// \ http://privat.bahnhof.se/wb758135/dds(.)(.)(.)-src.zip #opts=dversionmangle=s/.*ddd(.)(.)(.)/$1.$2.$3/,uversionmangle=s/(.)(.)(.)/$1.$2.$3/ \ # http://privat.bahnhof.se/wb758135/ddd(.*).zip debian/changelog0000664000000000000000000001110512267510353011044 0ustar dds (2.4.2+ddd105-1) unstable; urgency=medium * New dds upstream version. -- Christoph Berg Tue, 21 Jan 2014 16:23:21 +0100 dds (2.3.0+ddd105-2) unstable; urgency=low * Use -std=gnu99 so popen() is available. Thanks to Adam Conrad for the patch! Closes: #727777. -- Christoph Berg Fri, 01 Nov 2013 22:16:56 +0100 dds (2.3.0+ddd105-1) unstable; urgency=low * New dds upstream version, now using Apache License, Version 2.0. * Update watchfile to only look for dds, dehs will only see the ddd version otherwise. * Remove debian/patches/dll.h-fix-version, dds.cpp-autoconfig. * Remove some compiler warnings. -- Christoph Berg Sun, 15 Sep 2013 18:11:00 +0200 dds (2.1.2+ddd105-1) unstable; urgency=low * New dds upstream version. * Update watch file to mangle the ddd version to 1.0.5. * Source format 3.0. * Update to dh_python2, supporting multiple python versions in parallel. Closes: #616785. -- Christoph Berg Sat, 31 Dec 2011 18:02:22 +0200 dds (2.1.1+ddd105-2) unstable; urgency=low * Also run python test when building. -- Christoph Berg Wed, 09 Feb 2011 13:40:17 +0100 dds (2.1.1+ddd105-1) experimental; urgency=low * New dds upstream version. + InitStart now takes 2 arguments for configuring usage of system resources. * Compiled with OpenMP support. * Add InitStart to the manpage. -- Christoph Berg Sat, 02 Oct 2010 22:30:08 +0200 dds (2.0.1+ddd105-1) unstable; urgency=low * New dds upstream version, in some situations dds could wrongly reuse the transposition table contents giving an incorrect result. * Defines DDS_VERSION. -- Christoph Berg Sun, 23 May 2010 11:56:03 +0200 dds (2.0.0+ddd105-1) unstable; urgency=low * New dds upstream version (only bumping version). * Add SolveBoard.3 manpage. -- Christoph Berg Tue, 20 Apr 2010 23:27:57 +0200 dds (1.2.0+ddd105-1) experimental; urgency=low * New dds upstream version. + New API, upload to experimental. * Update author's homepage and email address. * Bump to DH level 7. -- Christoph Berg Tue, 13 Apr 2010 10:27:10 +0200 dds (1.1.9+ddd105-2) unstable; urgency=low * Update watch file with correct dversionmangling. -- Christoph Berg Thu, 30 Oct 2008 23:19:27 +0100 dds (1.1.9+ddd105-1) unstable; urgency=low * New dds upstream version. * Remove obsolete patches dll.h-buildpath and dll.h-longlong. * control: bump standards version, some minor changes suggested by lintian. * rules: run ddd for testing. -- Christoph Berg Sun, 14 Sep 2008 23:35:10 +0200 dds (1.1.8+ddd105-1) unstable; urgency=low * New dds upstream version. * Update upstream URL and correctly mangle version numbers in watch file. -- Christoph Berg Fri, 21 Mar 2008 21:24:14 +0100 dds (1.1.7+ddd105-1) unstable; urgency=low * New dds upstream version. -- Christoph Berg Wed, 10 Oct 2007 22:42:43 +0200 dds (1.1.5+ddd105-2) unstable; urgency=low * Include patch by upstream that removes debugging code. * The C compatibility patch went upstream, thanks Bo. -- Christoph Berg Tue, 19 Jun 2007 14:05:01 +0100 dds (1.1.5+ddd105-1) unstable; urgency=low * New dds upstream version. -- Christoph Berg Mon, 18 Jun 2007 14:39:23 +0200 dds (1.1.4+ddd105-2) unstable; urgency=low * Fetch revision h API docs. * Use C compiler so libdds.a doesn't need C++ linkage. -- Christoph Berg Sat, 16 Jun 2007 16:45:22 +0200 dds (1.1.4+ddd105-1) unstable; urgency=low * New dds upstream version. + mode=2 can now be used with any target/solutions/lead. -- Christoph Berg Sat, 12 May 2007 12:30:20 +0200 dds (1.1.3+ddd105-1) unstable; urgency=low * New dds upstream version. -- Christoph Berg Mon, 12 Mar 2007 16:49:36 +0100 dds (1.1.2+ddd105-1) unstable; urgency=low * New ddd upstream version. * Move python module to subdir. * Note python module license (dual GPL v2+/CC Attribution 2.5, we apply GPL). -- Christoph Berg Fri, 23 Feb 2007 17:13:32 +0100 dds (1.1.2-1) unstable; urgency=low * New upstream version. * Fix ddd.cpp for updated API. * Add missing Sections in control. -- Christoph Berg Mon, 19 Feb 2007 15:34:36 +0100 dds (1.1-1) unstable; urgency=low * Initial release (Closes: #407721). -- Christoph Berg Thu, 25 Jan 2007 15:20:48 +0100 debian/dds.manpages0000664000000000000000000000001511361024117011447 0ustar debian/dds.6