RhodeCode

%%%%% Defining LEMON %%%%%

@misc{lemon,

  key =          {LEMON},

  title =        {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and

                  {O}ptimization in {N}etworks},

  howpublished = {\url{http://lemon.cs.elte.hu/}},

  year =         2009

}

@misc{egres,

  key =          {EGRES},

  title =        {{EGRES} -- {E}gerv{\'a}ry {R}esearch {G}roup on

                  {C}ombinatorial {O}ptimization},

}

@misc{coinor,

  key =          {COIN-OR},

  title =        {{COIN-OR} -- {C}omputational {I}nfrastructure for

                  {O}perations {R}esearch},

}

%%%%% Other libraries %%%%%%

@misc{boost,

  key =          {Boost},

  title =        {{B}oost {C++} {L}ibraries},

}

@book{bglbook,

  author =       {Jeremy G. Siek and Lee-Quan Lee and Andrew

                  Lumsdaine},

  title =        {The Boost Graph Library: User Guide and Reference

                  Manual},

  publisher =    {Addison-Wesley},

  year =         2002

}

@misc{leda,

  key =          {LEDA},

  title =        {{LEDA} -- {L}ibrary of {E}fficient {D}ata {T}ypes and

                  {A}lgorithms},

}

@book{ledabook,

  author =       {Kurt Mehlhorn and Stefan N{\"a}her},

  title =        {{LEDA}: {A} platform for combinatorial and geometric

                  computing},

  isbn =         {0-521-56329-1},

  publisher =    {Cambridge University Press},

  address =      {New York, NY, USA},

  year =         1999

}

%%%%% Tools that LEMON depends on %%%%%

@misc{cmake,

  key =          {CMake},

  title =        {{CMake} -- {C}ross {P}latform {M}ake},

}

@misc{doxygen,

  key =          {Doxygen},

  title =        {{Doxygen} -- {S}ource code documentation generator

                  tool},

}

%%%%% LP/MIP libraries %%%%%

@misc{glpk,

  key =          {GLPK},

  title =        {{GLPK} -- {GNU} {L}inear {P}rogramming {K}it},

}

@misc{clp,

  key =          {Clp},

  title =        {{Clp} -- {Coin-Or} {L}inear {P}rogramming},

}

@misc{cbc,

  key =          {Cbc},

  title =        {{Cbc} -- {Coin-Or} {B}ranch and {C}ut},

}

@misc{cplex,

  key =          {CPLEX},

  title =        {{ILOG} {CPLEX}},

}

@misc{soplex,

  key =          {SoPlex},

  title =        {{SoPlex} -- {T}he {S}equential {O}bject-{O}riented

                  {S}implex},

}

%%%%% General books %%%%%

@book{amo93networkflows,

  author =       {Ravindra K. Ahuja and Thomas L. Magnanti and James

                  B. Orlin},

  title =        {Network Flows: Theory, Algorithms, and Applications},

  publisher =    {Prentice-Hall, Inc.},

  year =         1993,

  month =        feb,

  isbn =         {978-0136175490}

}

@book{schrijver03combinatorial,

  author =       {Alexander Schrijver},

  title =        {Combinatorial Optimization: Polyhedra and Efficiency},

  publisher =    {Springer-Verlag},

  year =         2003,

  isbn =         {978-3540443896}

}

@book{clrs01algorithms,

  author =       {Thomas H. Cormen and Charles E. Leiserson and Ronald

                  L. Rivest and Clifford Stein},

  title =        {Introduction to Algorithms},

  publisher =    {The MIT Press},

  year =         2001,

  edition =      {2nd}

}

@book{stroustrup00cpp,

  author =       {Bjarne Stroustrup},

  title =        {The C++ Programming Language},

  edition =      {3rd},

  publisher =    {Addison-Wesley Professional},

  isbn =         0201700735,

  month =        {February},

  year =         2000

}

%%%%% Maximum flow algorithms %%%%%

@inproceedings{goldberg86newapproach,

  author =       {Andrew V. Goldberg and Robert E. Tarjan},

  title =        {A new approach to the maximum flow problem},

  booktitle =    {STOC '86: Proceedings of the Eighteenth Annual ACM

                  Symposium on Theory of Computing},

  year =         1986,

  publisher =    {ACM Press},

  address =      {New York, NY},

  pages =        {136-146}

}

@article{dinic70algorithm,

  author =       {E. A. Dinic},

  title =        {Algorithm for solution of a problem of maximum flow

                  in a network with power estimation},

  journal =      {Soviet Math. Doklady},

  year =         1970,

  volume =       11,

  pages =        {1277-1280}

}

@article{goldberg08partial,

  author =       {Andrew V. Goldberg},

  title =        {The Partial Augment-Relabel Algorithm for the

                  Maximum Flow Problem},

  journal =      {16th Annual European Symposium on Algorithms},

  year =         2008,

  pages =        {466-477}

}

@article{sleator83dynamic,

  author =       {Daniel D. Sleator and Robert E. Tarjan},

  title =        {A data structure for dynamic trees},

  journal =      {Journal of Computer and System Sciences},

  year =         1983,

  volume =       26,

  number =       3,

  pages =        {362-391}

}

%%%%% Minimum mean cycle algorithms %%%%%

@article{karp78characterization,

  author =       {Richard M. Karp},

  title =        {A characterization of the minimum cycle mean in a

                  digraph},

  journal =      {Discrete Math.},

  year =         1978,

  volume =       23,

  pages =        {309-311}

#!/usr/bin/env /usr/local/Python/bin/python2.1

"""

  BibTeX to Doxygen converter

  Usage: python bib2dox.py bibfile.bib > bibfile.dox

  This code is the modification of the BibTeX to XML converter

  by Vidar Bronken Gundersen et al. See the original copyright notices below. 

  **********************************************************************

  Decoder for bibliographic data, BibTeX

  Usage: python bibtex2xml.py bibfile.bib > bibfile.xml

  v.8

  (c)2002-06-23 Vidar Bronken Gundersen

  http://bibtexml.sf.net/

  Reuse approved as long as this notification is kept.

  Licence: GPL.

  Contributions/thanks to:

  Egon Willighagen, http://sf.net/projects/jreferences/

  Richard Mahoney (for providing a test case)

  Editted by Sara Sprenkle to be more robust and handle more bibtex features.

  (c) 2003-01-15

  1.  Changed bibtex: tags to bibxml: tags.

  2.  Use xmlns:bibxml="http://bibtexml.sf.net/"

  3.  Allow spaces between @type and first {

  4.  "author" fields with multiple authors split by " and "

      are put in separate xml "bibxml:author" tags.

  5.  Option for Titles: words are capitalized

      only if first letter in title or capitalized inside braces

  6.  Removes braces from within field values

  7.  Ignores comments in bibtex file (including @comment{ or % )

  8.  Replaces some special latex tags, e.g., replaces ~ with ' '

  9.  Handles bibtex @string abbreviations

        --> includes bibtex's default abbreviations for months

        --> does concatenation of abbr # " more " and " more " # abbr

  10. Handles @type( ... ) or @type{ ... }

  11. The keywords field is split on , or ; and put into separate xml

      "bibxml:keywords" tags

  12. Ignores @preamble

  Known Limitations

  1.  Does not transform Latex encoding like math mode and special

      latex symbols.

  2.  Does not parse author fields into first and last names.

      E.g., It does not do anything special to an author whose name is

      in the form LAST_NAME, FIRST_NAME

      In "author" tag, will show up as

      <bibxml:author>LAST_NAME, FIRST_NAME</bibxml:author>

  3.  Does not handle "crossref" fields other than to print

      <bibxml:crossref>...</bibxml:crossref>

  4.  Does not inform user of the input's format errors.  You just won't

      be able to transform the file later with XSL

  You will have to manually edit the XML output if you need to handle

  these (and unknown) limitations.

"""

import string, re

# set of valid name characters

valid_name_chars = '[\w\-:]'

#

# define global regular expression variables

#

author_rex = re.compile('\s+and\s+')

rembraces_rex = re.compile('[{}]')

# used by bibtexkeywords(data)

keywords_rex = re.compile('[,;]')

# used by concat_line(line)

concatsplit_rex = re.compile('\s*#\s*')

# split on {, }, or " in verify_out_of_braces

delimiter_rex = re.compile('([{}"])',re.I)

field_rex = re.compile('\s*(\w*)\s*=\s*(.*)')

data_rex = re.compile('\s*(\w*)\s*=\s*([^,]*),?')

url_rex = re.compile('\\\url\{([^}]*)\}')

#

# styles for html formatting

#

divstyle = 'margin-top: -4ex; margin-left: 8em;'

#

# return the string parameter without braces

#

def transformurls(str):

    return url_rex.sub(r'<a href="\1">\1</a>', str)

#

# return the string parameter without braces

#

def removebraces(str):

    return rembraces_rex.sub('', str)

#

# latex-specific replacements

# (do this after braces were removed)

#

def latexreplacements(line):

    line = string.replace(line, '~', ' ')

    line = string.replace(line, '\\\'a', 'á')

    line = string.replace(line, '\\"a', 'ä')

    line = string.replace(line, '\\\'e', 'é')

    line = string.replace(line, '\\"e', 'ë')

    line = string.replace(line, '\\\'i', 'í')

    line = string.replace(line, '\\"i', 'ï')

    line = string.replace(line, '\\\'o', 'ó')

    line = string.replace(line, '\\"o', 'ö')

    line = string.replace(line, '\\\'u', 'ú')

    line = string.replace(line, '\\"u', 'ü')

    line = string.replace(line, '\\H o', 'õ')

    line = string.replace(line, '\\H u', 'ü')   # ũ does not exist

    line = string.replace(line, '\\\'A', 'Á')

    line = string.replace(line, '\\"A', 'Ä')

    line = string.replace(line, '\\\'E', 'É')

    line = string.replace(line, '\\"E', 'Ë')

    line = string.replace(line, '\\\'I', 'Í')

    line = string.replace(line, '\\"I', 'Ï')

    line = string.replace(line, '\\\'O', 'Ó')

    line = string.replace(line, '\\"O', 'Ö')

    line = string.replace(line, '\\\'U', 'Ú')

    line = string.replace(line, '\\"U', 'Ü')

    line = string.replace(line, '\\H O', 'Õ')

    line = string.replace(line, '\\H U', 'Ü')   # Ũ does not exist

    return line

#

# copy characters form a string decoding html expressions (&xyz;)

#

def copychars(str, ifrom, count):

    result = ''

    i = ifrom

    c = 0

    html_spec = False

    while (i < len(str)) and (c < count):

        if str[i] == '&':

            html_spec = True;

            if i+1 < len(str):

                result += str[i+1]

            c += 1

            i += 2

        else:

            if not html_spec:

                if ((str[i] >= 'A') and (str[i] <= 'Z')) or \

                   ((str[i] >= 'a') and (str[i] <= 'z')):

                    result += str[i]

                    c += 1

            elif str[i] == ';':

                html_spec = False;

            i += 1

    return result

# 

# Handle a list of authors (separated by 'and').

# It gives back an array of the follwing values:

    bracefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)')

    bracedata_rex = re.compile('\s*(\w*)\s*=\s*{(.*)},?')

    quotefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)')

    quotedata_rex = re.compile('\s*(\w*)\s*=\s*"(.*)",?')

    for line in filecont_source:

        line = line[:-1]

        # encode character entities

        line = string.replace(line, '&', '&')

        line = string.replace(line, '<', '&lt;')

        line = string.replace(line, '>', '>')

        # start entry: publication type (store for later use)

        if pubtype_rex.match(line):

        # want @<alphanumeric chars><spaces>{<spaces><any chars>,

            entrycont = {}

            entry = []

            entrytype = pubtype_rex.sub('\g<1>',line)

            entrytype = string.lower(entrytype)

            entryid   = pubtype_rex.sub('\g<2>', line)

        # end entry if just a }

        elif endtype_rex.match(line):

            # generate doxygen code for the entry

            # enty type related formattings

            if entrytype in ('book', 'inbook'):

                entrycont['title'] = '<em>' + entrycont['title'] + '</em>'

                if not entrycont.has_key('author'):

                    entrycont['author'] = entrycont['editor']

                    entrycont['author']['text'] += ', editors'

            elif entrytype == 'article':

                entrycont['journal'] = '<em>' + entrycont['journal'] + '</em>'

            elif entrytype in ('inproceedings', 'incollection', 'conference'):

                entrycont['booktitle'] = '<em>' + entrycont['booktitle'] + '</em>'

            elif entrytype == 'techreport':

                if not entrycont.has_key('type'):

                    entrycont['type'] = 'Technical report'

            elif entrytype == 'mastersthesis':

                entrycont['type'] = 'Master\'s thesis'

            elif entrytype == 'phdthesis':

                entrycont['type'] = 'PhD thesis'

            for eline in entrycont:

                if eline != '':

                    eline = latexreplacements(eline)

            if entrycont.has_key('pages') and (entrycont['pages'] != ''):

                entrycont['pages'] = string.replace(entrycont['pages'], '--', '-')

            if entrycont.has_key('author') and (entrycont['author'] != ''):

                entry.append(entrycont['author']['text'] + '.')

            if entrycont.has_key('title') and (entrycont['title'] != ''):

                entry.append(entrycont['title'] + '.')

            if entrycont.has_key('journal') and (entrycont['journal'] != ''):

                entry.append(entrycont['journal'] + ',')

            if entrycont.has_key('booktitle') and (entrycont['booktitle'] != ''):

                entry.append('In ' + entrycont['booktitle'] + ',')

            if entrycont.has_key('type') and (entrycont['type'] != ''):

                eline = entrycont['type']

                if entrycont.has_key('number') and (entrycont['number'] != ''):

                    eline += ' ' + entrycont['number']

                eline += ','

                entry.append(eline)

            if entrycont.has_key('institution') and (entrycont['institution'] != ''):

                entry.append(entrycont['institution'] + ',')

            if entrycont.has_key('publisher') and (entrycont['publisher'] != ''):

                entry.append(entrycont['publisher'] + ',')

            if entrycont.has_key('school') and (entrycont['school'] != ''):

                entry.append(entrycont['school'] + ',')

            if entrycont.has_key('address') and (entrycont['address'] != ''):

                entry.append(entrycont['address'] + ',')

            if entrycont.has_key('edition') and (entrycont['edition'] != ''):

                entry.append(entrycont['edition'] + ' edition,')

            if entrycont.has_key('howpublished') and (entrycont['howpublished'] != ''):

                entry.append(entrycont['howpublished'] + ',')

            if entrycont.has_key('volume') and (entrycont['volume'] != ''):

                eline = entrycont['volume'];

                if entrycont.has_key('number') and (entrycont['number'] != ''):

                    eline += '(' + entrycont['number'] + ')'

                if entrycont.has_key('pages') and (entrycont['pages'] != ''):

                    eline += ':' + entrycont['pages']

                eline += ','

                entry.append(eline)

            else:

                if entrycont.has_key('pages') and (entrycont['pages'] != ''):

                    entry.append('pages ' + entrycont['pages'] + ',')

            if entrycont.has_key('year') and (entrycont['year'] != ''):

                if entrycont.has_key('month') and (entrycont['month'] != ''):

                    entry.append(entrycont['month'] + ' ' + entrycont['year'] + '.')

                else:

                    entry.append(entrycont['year'] + '.')

            if entrycont.has_key('note') and (entrycont['note'] != ''):

                entry.append(entrycont['note'] + '.')

            # generate keys for sorting and for the output

            sortkey = ''

            bibkey = ''

            if entrycont.has_key('author'):

                for author in entrycont['author']['list']:

                    sortkey += copychars(author, author.rfind(' ')+1, len(author))

                bibkey = entrycont['author']['abbrev']

            else:

                bibkey = 'x'

            if entrycont.has_key('year'):

                sortkey += entrycont['year']

                bibkey += entrycont['year'][-2:]

            if entrycont.has_key('title'):

                sortkey += entrycont['title']

            if entrycont.has_key('key'):

                sortkey = entrycont['key'] + sortkey

                bibkey = entrycont['key']

            entry.insert(0, sortkey)

            entry.insert(1, bibkey)

            entry.insert(2, entryid)

            # add the entry to the file contents

            filecont.append(entry)

        else:

            # field, publication info

            field = ''

            data = ''

            # field = {data} entries

            if bracedata_rex.match(line):

                field = bracefield_rex.sub('\g<1>', line)

                field = string.lower(field)

                data =  bracedata_rex.sub('\g<2>', line)

            # field = "data" entries

            elif quotedata_rex.match(line):

                field = quotefield_rex.sub('\g<1>', line)

                field = string.lower(field)

                data =  quotedata_rex.sub('\g<2>', line)

            # field = data entries

            elif data_rex.match(line):

                field = field_rex.sub('\g<1>', line)

                field = string.lower(field)

                data =  data_rex.sub('\g<2>', line)

            if field in ('author', 'editor'):

                entrycont[field] = bibtexauthor(data)

                line = ''

            elif field == 'title':

                line = bibtextitle(data, entrytype)

            elif field != '':

                line = removebraces(transformurls(data.strip()))

            if line != '':

                line = latexreplacements(line)

                entrycont[field] = line

    # sort entries

    filecont.sort(entry_cmp)

    # count the bibtex keys

    keytable = {}

    counttable = {}

    for entry in filecont:

        bibkey = entry[1]

        if not keytable.has_key(bibkey):

            keytable[bibkey] = 1

        else:

            keytable[bibkey] += 1

    for bibkey in keytable.keys():

        counttable[bibkey] = 0

    # generate output

    for entry in filecont:

        # generate output key form the bibtex key

        bibkey = entry[1]

        entryid = entry[2]

        if keytable[bibkey] == 1:

            outkey = bibkey

        else:

            outkey = bibkey + chr(97 + counttable[bibkey])

        counttable[bibkey] += 1

        # append the entry code to the output

        file.append('\\section ' + entryid + ' [' + outkey + ']')

        file.append('<div style="' + divstyle + '">')

        for line in entry[3:]:

            file.append(line)

        file.append('</div>')

        file.append('')

    return file

#

# return 1 iff abbr is in line but not inside braces or quotes

# assumes that abbr appears only once on the line (out of braces and quotes)

#

def verify_out_of_braces(line, abbr):

    phrase_split = delimiter_rex.split(line)

    abbr_rex = re.compile( '\\b' + abbr + '\\b', re.I)

    open_brace = 0

    open_quote = 0

    for phrase in phrase_split:

        if phrase == "{":

            open_brace = open_brace + 1

        elif phrase == "}":

            open_brace = open_brace - 1

        elif phrase == '"':

            if open_quote == 1:

                open_quote = 0

            else:

                open_quote = 1

        elif abbr_rex.search(phrase):

            if open_brace == 0 and open_quote == 0:

                return 1

    return 0

#

# a line in the form phrase1 # phrase2 # ... # phrasen

# is returned as phrase1 phrase2 ... phrasen

# with the correct punctuation

# Bug: Doesn't always work with multiple abbreviations plugged in

#

def concat_line(line):

    # only look at part after equals

    field = field_rex.sub('\g<1>',line)

    rest = field_rex.sub('\g<2>',line)

    concat_line = field + ' ='

    pound_split = concatsplit_rex.split(rest)