[Ebooks PDF] download Programming Algorithms in Lisp Writing Efficient Programs with Examples in ANSI Common Lisp 1st ed. Edition Vsevolod Domkin full chapters
[Ebooks PDF] download Programming Algorithms in Lisp Writing Efficient Programs with Examples in ANSI Common Lisp 1st ed. Edition Vsevolod Domkin full chapters
com
https://ebookname.com/product/programming-algorithms-in-
lisp-writing-efficient-programs-with-examples-in-ansi-
common-lisp-1st-ed-edition-vsevolod-domkin/
OR CLICK BUTTON
DOWNLOAD EBOOK
https://ebookname.com/product/practical-common-lisp-1st-corrected-
edition-peter-seibel/
ebookname.com
https://ebookname.com/product/lisp-in-small-pieces-1-paperback-ed-
edition-christian-queinnec/
ebookname.com
https://ebookname.com/product/entrepreneurship-a-small-business-
approach-1st-edition-charles-bamford/
ebookname.com
Theatre Work Reimagining the Labor of Theatrical
Production 1st Edition Brídín Clements Cotton
https://ebookname.com/product/theatre-work-reimagining-the-labor-of-
theatrical-production-1st-edition-bridin-clements-cotton/
ebookname.com
https://ebookname.com/product/literature-and-the-long-modernity-1st-
edition-mihaela-irimia/
ebookname.com
https://ebookname.com/product/b2b-selling-for-dummies-hoover-s-
special-edition-tom-hopkins/
ebookname.com
https://ebookname.com/product/close-relations-an-introduction-to-the-
sociology-of-families-mcdaniel/
ebookname.com
A Geography of the European Union 2nd Edition Francis Cole
https://ebookname.com/product/a-geography-of-the-european-union-2nd-
edition-francis-cole/
ebookname.com
Programming
Algorithms
in Lisp
Writing Efficient Programs with
Examples in ANSI Common Lisp
—
Vsevolod Domkin
Programming Algorithms
in Lisp
Writing Efficient Programs
with Examples in ANSI Common Lisp
Vsevolod Domkin
Programming Algorithms in Lisp: Writing Efficient Programs with Examples in ANSI
Common Lisp
Vsevolod Domkin
Kyiv, Ukraine
Chapter 1: Introduction�������������������������������������������������������������������������������������������� 1
Why Algorithms Matter����������������������������������������������������������������������������������������������������������������� 1
A Few Words About Lisp���������������������������������������������������������������������������������������������������������������� 3
iii
Table of Contents
Chapter 5: Arrays���������������������������������������������������������������������������������������������������� 41
Arrays as Sequences������������������������������������������������������������������������������������������������������������������ 43
Dynamic Vectors������������������������������������������������������������������������������������������������������������������������� 45
Why Are Arrays Indexed from 0��������������������������������������������������������������������������������������������������� 49
Multidimensional Arrays������������������������������������������������������������������������������������������������������������� 50
Binary Search������������������������������������������������������������������������������������������������������������������������������ 52
Binary Search in Action: A Fast Specialized In-Memory DB�������������������������������������������������� 58
Sorting���������������������������������������������������������������������������������������������������������������������������������������� 61
O(n^2) Sorting����������������������������������������������������������������������������������������������������������������������� 62
Quicksort������������������������������������������������������������������������������������������������������������������������������� 65
Production Sort���������������������������������������������������������������������������������������������������������������������� 68
Performance Benchmark������������������������������������������������������������������������������������������������������� 70
Takeaways���������������������������������������������������������������������������������������������������������������������������������� 72
iv
Table of Contents
vi
Table of Contents
vii
Table of Contents
Afterword�������������������������������������������������������������������������������������������������������������� 367
Index��������������������������������������������������������������������������������������������������������������������� 369
viii
About the Author
Vsevolod Domkin from Kyiv, Ukraine, is a Lisp programmer and enthusiast, a natural
language processing researcher, an occasional writer/blogger, and a teacher.
ix
About the Technical Reviewer
Michał “phoe” Herda is a programmer with contributions
to multiple parts of the Common Lisp (CL) ecosystem: CL
implementations, existing and widely used CL utilities,
documentation, and some of the new library ideas that he
slowly pushes forward and works on.
xi
Acknowledgments
I’m very thankful to those who helped me in the work on Programming Algorithms in
Lisp by providing support, advice, corrections, and suggestions. First of all, many thanks
to my wife, Ksenya, who encouraged me to work on it despite the time that was, in part,
taken from my family duties. Michał “phoe” Herda contributed a very thorough and
detail-oriented review that helped correct a couple of significant misunderstandings on
my part and pushed me to add more code and explanations where they were lacking.
He has also championed the idea of a separate repository with all the book’s code
accompanied by a test suite and helped me in this undertaking.
I am very grateful to Dr. Robert Strandh who humbly volunteered his help as an
editor of the initial chapters of the book to make it sound more native (as my English
is far from perfect since I’m not a native speaker) and point out the mistakes that I
made. He and his wife, Kathleen, have contributed lots of improvements to more than
half of the chapters, and I tried to follow their advice in the subsequent ones. Thanks
to Rainer Joswig for commenting on the Lisp choices. I’m also grateful to my father,
Dr. Volodymyr Demkine, for reviewing and proofing the book. Thanks to @dzenicv on
reddit who posted links to almost all of the chapters there, which triggered some helpful
discussions. Thanks to @tom_mellior on Hacker News for pointing a serious deficiency
in the explanation of Union-Find. Thanks to all those people who shared the links to the
chapters and contributed their comments and attention.
xiii
CHAPTER 1
Introduction
This book started after teaching an intensive course on algorithms to working
programmers in Kyiv, in spring 2016. It took more than 3 years to complete, and,
meanwhile, I also did three iterations of the course. Its aim is to systematically explain
how to write efficient programs and, also, the approaches and tools for determining why
the program isn’t efficient enough. In the process, it will teach you some Lisp and show
in action the technics of algorithmic development. And, even if you won’t program in
Lisp afterward, you’ll still be able to utilize the same approaches and tools or be inclined
to ask why they aren’t available in your language of choice from its authors. :)
1
© Vsevolod Domkin 2021
V. Domkin, Programming Algorithms in Lisp, https://doi.org/10.1007/978-1-4842-6428-7_1
Chapter 1 Introduction
In the book, I’ll address, primarily, the second issue but will also try to touch on the
first whenever possible.
Besides, learning the art of solving difficult algorithmic problems trains the brain and
makes it more apt to solving various other problems, in the course of your day-to-day
work.
Finally, you will be speaking the same lingua franca as other advanced
programmers—the tongue that transcends the mundane differences of particular
programming languages. And you’ll gain a more detached view of those differences,
freeing your mind from the dictate of a particular set of choices exhibiting in any one of
them.
One of the reasons for this gap of understanding of the value of algorithms, probably,
originates from how they are usually presented in the computer science curriculum.
First, it is often done in a rather theoretical or “mathematical” way with rigorous proofs
and lack of connection to the real world. Second, the audience is usually freshmen or
sophomores who don’t have a lot of practical programming experience and thus can’t
appreciate and relate how this knowledge may be applied to their own programming
challenges (because they didn’t have those yet)—rather, most of them are still at the level
of struggling to learn well their first programming language and, in their understanding
of computing, are very much tied to its choices and idiosyncrasies.
In this book, the emphasis is made on the demonstration of the use of the described
data structures and algorithms in various areas of computer programming. Moreover,
I anticipate that the self-selected audience will comprise programmers with some
experience in the field. This makes a significant difference in the set of topics that are
relevant and how they can be conveyed. Another thing that helps a lot is when the
programmer has a good command of more than one programming language, especially
if the languages are from different paradigms: static and dynamic, object-oriented and
functional. These factors allow bridging the gap between “theoretical” algorithms and
practical coding, making the topic accessible, interesting, and inspiring.
2
Chapter 1 Introduction
This is one answer to a possible question: Why write another book on algorithms?
Indeed, there are several good textbooks and online courses on the topic, of which I’d
recommend the most Steven Skiena’s The Algorithm Design Manual. Yet, as I said, this
book is not at all academic in presentation of the material, which is a norm for other
textbooks. Except for simple arithmetic, it contains almost no “math” or proofs. And,
although proper attention is devoted to algorithmic complexity, it doesn’t deal with
theories of complexity or computation and similar scientific topics. Besides, all the
algorithms and data structures come with some example practical use cases. Last, but
not least, there’s no book on algorithms in Lisp, and, in my opinion, it’s a great topic
to introduce the language. The next chapter will provide a crash course to grasp the
basic ideas, and then we’ll discuss various Lisp programming approaches alongside the
algorithms they will be used to implement.
This is an introductory book, not a bible of algorithms. It will draw a comprehensive
picture and cover all topics necessary for further advancement of your algorithm
knowledge. However, it won’t go too deep into the advanced topics, such as persistent
or probabilistic data structures and advanced tree, graph, and optimization algorithms,
as well as algorithms for particular fields, such as machine learning, cryptography, or
computational geometry. All of those fields require (and usually have) separate books of
their own.
3
Chapter 1 Introduction
Why Lisp is great for algorithmic programs? One reason is that the language was
created with such use case in mind. It has support for all the proper basic data structures,
such as arrays, hash-tables, linked lists, strings, and tuples. It also has a numeric tower,
which means no overflow errors and, so, a much saner math. Next, it’s created for the
interactive development style, so the experimentation cycle is very short, there’s no
compile-wait-run-revise red tape, and there are no unnecessary constraints, like the
need for additional annotations (a.k.a. types), prohibition of variable mutation, or other
stuff like that. You just write a function in the REPL (Read-Eval-Print Loop), run it, and
see the results. In my experience, Lisp programs look almost like pseudocode. Compared
to other languages, they may be slightly more verbose at times but are much more clear,
simple, and directly compatible with the algorithm’s logical representation.
But why not choose a popular programming language? The short answer is that it
wouldn’t have been optimal. There are four potential mainstream languages that could
be considered for this book: C++, Java, Python, and JavaScript (JS). (Surely, there’s
already enough material on algorithms that use them.) The first two are statically typed,
which is, in itself, a big obstacle to using them as teaching languages. Java is also too
verbose, while C++ too low level. These qualities don’t prevent them from being used
in the majority of production algorithm code, in the wild, and you’ll, probably, end
up dealing with such code sooner than later if not already. Besides, their standard
libraries provide great examples of practical algorithm implementation. But I believe
that gaining good conceptual understanding will allow to easily adapt to one of these
languages if necessary, while learning them in parallel with diving into algorithms
creates unnecessary complexity. Python and JS are, in many ways, the opposite choices:
they are dynamic and provide some level of an interactive experience (albeit inferior
compared to Lisp), but those languages are in many ways anti-algorithmic. Trying to be
simple and accessible, they hide too much from the programmer and don’t give enough
control of the concrete data. Teaching algorithms, using their standard libraries, seems
like cheating to me as their basic data structures often are not what they claim to be. Lisp
is in the middle: it is both highly interactive and gives enough control of the environment
while not being too verbose and demanding. And the price to pay—the unfamiliar
syntax—is really small, in my humble opinion.
4
Chapter 1 Introduction
Mostly, this book will be dedicated to showing Lisp code and explaining it. Yet, all
such code snippets will fall into two quite different categories:
5
CHAPTER 2
Algorithmic Complexity
Complexity is a point that will be mentioned literally on every page of this book; the
discussion of any algorithm or data structure can’t avoid this topic. After correctness,
it is the second most important quality of every algorithm. Moreover, often correctness
alone doesn’t matter if complexity is neglected, while the opposite is possible: to
compromise correctness somewhat in order to get significantly better complexity. By
and large, algorithm theory differs from other subjects of CS in that it concerns not about
presenting a working (correct) way to solve some problem but about finding an efficient
way to do it, where efficiency is understood as the minimal (or admissible) number of
operations performed and occupied memory space.
In principle, the complexity of an algorithm is the dependence of the number of
operations that will be performed on the size of the input. It is crucial to the computer
system’s scalability: it may be easy to solve the programming problem for a particular set
of inputs, but how will the solution behave if the input is doubled or increased tenfold or
millionfold? This is not a theoretical question, and an analysis of any general-purpose
algorithm should have a clear answer to it.
Complexity is a substantial research topic: a whole separate branch of CS—
complexity theory—exists to study it. Yet, throughout the book, we’ll try to utilize the
end results of such research without delving deep into rigorous proofs or complex
math, especially since, in most of the cases, measuring complexity is a matter of simple
counting. Let’s look at the following illustrative example:
What’s its complexity? To answer, we can just count the number of operations
performed: at each iteration of the inner loop, there are two comparisons involving
one array access, and, sometimes, if the planets align, we perform another access for
assignment. The inner loop is executed (array-dimension mat 1) times (let’s call it m
where m=3) and the outer one (array-dimension mat 0) (n=2, in the example). If we
sum this all up, we’ll get n * m * 4 as an upper limit, for the worst case when each
sequent array element is larger than the previous. As a rule of thumb, each loop adds
multiplication to the formula, and each sequential block adds a plus sign.
In this calculation, there are two variables (array dimensions n and m) and one
constant (the number of operations performed for each array element). There exists
a special notation—Big-O—used to simplify the representation of end results of such
complexity arithmetic. In it, all constants are reduced to 1, and thus m * 1 becomes just
m, and also since we don’t care about individual array dimension differences, we can
just put n * n instead of n * m. With such simplification, we can write down the final
complexity result for this function: O(nˆ2). In other words, our algorithm has quadratic
complexity (which happens to be a variant of a broader class called “polynomial
complexity”) in array dimensions. It means that by increasing the dimensions of our
matrix ten times, we’ll increase the number of operations of the algorithm 100 times.
In this case, however, it may be more natural to be concerned with the dependence of
the number of operations on the number of elements of the matrix, not its dimensions.
We can observe that nˆ2 is the actual number of elements, so it can also be written as
just n—if by n we mean the number of elements and then the complexity is linear in the
number of elements (O(n)). As you see, it is crucial to understand what n we are talking
about!
There are just a few more things to know about Big-O complexity before we can start
using it to analyze our algorithms:
8
Chapter 2 Algorithmic Complexity
9
CHAPTER 3
This chapter is intended primarily for the first group. After reading it, the rest of the
Lisp code from the book should become understandable to you. Besides, you’ll know the
basics to run Lisp and experiment with it if you will so desire.
As for the lispers, you might be interested to glance over this part just to understand
my approach to utilizing the language throughout the book.
11
© Vsevolod Domkin 2021
V. Domkin, Programming Algorithms in Lisp, https://doi.org/10.1007/978-1-4842-6428-7_3
Chapter 3 A Crash Course in Lisp
It is much easier to explain Lisp if we begin from a blank slate. In essence, all there is
to it is just an evaluation rule: Lisp programs consist of forms that are evaluated by the
compiler. There are 3 + 2 ways how that can happen:
12
Chapter 3 A Crash Course in Lisp
A Code Example
To sum up, let’s consider an example of the evaluation of a Lisp form. The following one
implements the famous binary search algorithm (that we’ll discuss in more detail in one
of the following chapters):
13
Chapter 3 A Crash Course in Lisp
It is a compound form. In it, the so-called top-level form is when, which is a macro for
a one-clause conditional expression: an if with only the true branch. First, it evaluates
the expression (> (length vec) 0), which is an ordinary function for a logical operator
> applied to two args: the result of obtaining the length of the contents of the variable
vec and a constant 0. If the evaluation returns true, that is, the length of vec is greater
than 0, the rest of the form is evaluated in the same manner. The result of the evaluation,
if nothing exceptional happens, is either false (which is called nil, in Lisp) or three
values returned from the last form (values ...). In the following, we’ll talk about other
operators shown here.
But first I need to say a few words about RUTILS. It is a third-party library developed
by me that provides a number of extensions to the standard Lisp syntax and its basic
operators. The reason for its existence is that the Lisp standard is not going to change
ever, and, as everything in this world, it has its flaws. Besides, our understanding of what
constitutes elegant and efficient code evolves over time. The great advantage of the Lisp
standard, however, which counteracts the issue of its immutability, is that its authors had
put into it multiple ways to modify and evolve the language at almost all levels starting
from even the basic syntax. And this addresses our ultimate need, after all: we’re not
so interested in changing the standard as in changing the language. So RUTILS is one of
the ways of evolving Lisp; and its purpose is to make programming in it more accessible
without compromising the core principles of the language. So I will utilize a number
of RUTILS features throughout this book, explaining them as needed. Surely, using a
particular third-party extension is a question of preference and taste, and it might not
be approved by some of the Lisp old-times, but no worries: in your code, you’ll be able
to easily swap them for your favorite alternatives. Yet, completely rejecting this option is
puristic and impractical.
The REPL
Lisp programs are supposed to be run not only in a one-off fashion of simple scripts but also
as live systems that operate over long periods of time experiencing change not only of their
data but also code. This general way of interaction with a program is called Read-Eval-Print
Loop (REPL), which literally means that the Lisp compiler reads a form, evaluates it with the
aforementioned rule, prints the results back to the user, and loops over.
14
Chapter 3 A Crash Course in Lisp
REPL is the default way to interact with a Lisp program, and it is very similar to
the Unix shell. When you run your Lisp (e.g., by entering sbcl at the shell), you’ll drop
into the REPL. We’ll precede all REPL-based code interactions in the book with a REPL
prompt (CL-USER> or similar). Here’s an example one:
A curious reader may be asking why "Hello world" is printed twice. It’s a proof
that everything is an expression in Lisp. :) The print “statement,” unlike in most other
languages, not only prints its argument to the console (or other output streams) but also
returns it as is. This comes very handy when debugging, as you can wrap almost any
form in a print not changing the flow of the program.
Obviously, if the interaction is not necessary, just the read-eval part may remain. But,
what’s more important, Lisp provides a way to customize every stage of the process:
• The print stage is conceptually the simplest one, and there’s also
a standard way to customize object printing via the Common Lisp
Object System’s (CLOS) print-object function.
Basic Expressions
The structural programming paradigm states that all programs can be expressed in terms
of three basic constructs: sequential execution, branching, and looping. Let’s see how
these operators are expressed in Lisp.
15
Random documents with unrelated
content Scribd suggests to you:
the English shot made larger holes than the Spanish, and a few more men
would have turned the scale and given the victory to the Dainty.
When the action was renewed the vice-admiral came upon their quarter,
and a shot from one of the Dainty's stern-pieces carried away his mainmast
close to the deck. Hawkins lay below, and knew nothing of what had
occurred; then was the time to press the Spaniard home, but the Dainty was
steered away, and the Spaniards had time to repair their damage.
They soon overtook the Dainty, and the fight went on through the
second night, and they ceased firing again before the dawn; but there had
been no interval for rest or refreshment, except to snatch a little bread and
wine as they could. Indeed, some of the English crew had drunk heavily
before the fight began; some ignorant seamen even mixed powder with their
wine, thinking it would give them strength and courage. The result of their
drinking was, of course, order, and foolish hardihood without reason, or
vainglorious exposure to danger. And though Hawkins had prepared light
armour for all, not a man would use it; yet it would have saved many from
such wounds as splintered wood creates if they would have imitated their
foe and worn armour.
By the afternoon of the third day the enemy had the weather-gage of
them, and their guns were telling with terrible effect.
The Dainty had now fourteen gaping wounds under water, eight foot of
water in her hold, her sails torn to tatters, her masts bowing and bent, and
her pumps useless—hardly a man was now unwounded.
"Sir, the Spaniards still offer good war, life and liberty and an
embarkation to England. If we wait any longer, sir, the ship will sink; unless
a miracle be wrought in our behalf by God's almighty power, we may
expect no deliverance or life."
Hawkins was too ill to resist further; he murmured sadly:
So they bade the rest cease firing, and a Spanish prisoner was sent from
the hold to tell Beltran de Castro that if he would give his word of honour
the ship should be surrendered.
"So is ours. Amain your sails, then; strike sail, can't you?"
Meanwhile the vice-admiral, not seeing the flag of truce, had come
upon the Dainty's quarter, and firing two of his chase-pieces, wounded the
captain sorely in the thigh and maimed one of the master's mates.
Then the Spanish admiral came alongside, and the prisoner jumped into
the warship, and was received with all courtesy.
Don Beltran affirmed that he received the commander and his people à
buena guerra, to the laws of fair war and quarter. He swore by his habit of
Alcantara, and the green cross of the order which he wore upon his breast,
that he would give them their lives with good treatment, and send them as
speedily as he could to their own country.
Don Beltran also sent one of his captains to help to bring the English
commander aboard the "admiral," which he did with great humanity and
courtesy.
There were only forty Englishmen left, all wounded; but all recovered,
in spite of the fact that no instruments, doctors, or salves were to be had. We
remember that in the other case where an English ship had to surrender to
the Spaniards, the Revenge disdained to swim in dishonour, and sank
sullenly in a terrible storm.
The Dainty lived to fight for Spain under the name of La Visitation,
being so named because she was captured on the day of that festival.
She was finally navigated to the port of Panama, and anchored there
some two leagues from the town, about three weeks after the fight.
When the good folk on shore saw the prize and heard the glad news,
they lit bonfires on the hills and candles in every window; the churches and
halls were illuminated, as on a holy day. As the city faced the sea, it
appeared to those in the ships as though the whole place was in flames.
Don Beltran reassured Hawkins that his officers and men should be well
treated, and gave him his word that if the King left him to his disposal, his
ransom should be only a couple of greyhounds for himself and a couple for
his brother. It sounded almost too good to be true.
Then the Englishman had the mortification of seeing his dear Dainty
being rebaptized with all solemnity in the harbour, where she was shored
up. Perhaps a sardonic smile curled his lip when, in the very midst of the
ceremony, the props on one side gave way with a loud crash, and the
reluctant ship heeled over, "entreating many of them that were in her very
badly."
Here ends Sir Richard's account of his unfortunate voyage in his
"Observations"; he had intended to write a second part, but deferred it too
long.
Don Beltran was not allowed by his King to observe the terms he had
offered; the crew were sent to serve in the galleys at Cartagena, Hawkins
and twenty others Don Beltran took with him to Lima.
Our hero had shown courage and generosity and kindness to natives and
prisoners, but as a complete seaman his own words show him to have been
deficient. He trusted his subordinates too much, and he kept rather loose
discipline; but he was a man of the highest honour, and won the respect of
the best Spaniards.
At Lima the Inquisition claimed the prisoners, but the Viceroy refused
to give them up until he had heard from King Philip.
In 1602 he was released and sent home, as by this time Count Miranda,
President of the Council, had come to the conclusion that formal pledges
given by the King's officers must be kept, or else no other English would
surrender.
In July 1603 Hawkins was knighted, became M.P. for Plymouth and
Vice-Admiral of Devon, and had to scour the sea for pirates.
But for all that, he was not the least among England's heroes; he was a
worthy son of Sir John, and a man whom Devon may claim as one of her
noblest and most generous sons.
Updated editions will replace the previous one—the old editions will
be renamed.
1.D. The copyright laws of the place where you are located also
govern what you can do with this work. Copyright laws in most
countries are in a constant state of change. If you are outside the
United States, check the laws of your country in addition to the
terms of this agreement before downloading, copying, displaying,
performing, distributing or creating derivative works based on this
work or any other Project Gutenberg™ work. The Foundation makes
no representations concerning the copyright status of any work in
any country other than the United States.
1.E.6. You may convert to and distribute this work in any binary,
compressed, marked up, nonproprietary or proprietary form,
including any word processing or hypertext form. However, if you
provide access to or distribute copies of a Project Gutenberg™ work
in a format other than “Plain Vanilla ASCII” or other format used in
the official version posted on the official Project Gutenberg™ website
(www.gutenberg.org), you must, at no additional cost, fee or
expense to the user, provide a copy, a means of exporting a copy, or
a means of obtaining a copy upon request, of the work in its original
“Plain Vanilla ASCII” or other form. Any alternate format must
include the full Project Gutenberg™ License as specified in
paragraph 1.E.1.
• You pay a royalty fee of 20% of the gross profits you derive
from the use of Project Gutenberg™ works calculated using the
method you already use to calculate your applicable taxes. The
fee is owed to the owner of the Project Gutenberg™ trademark,
but he has agreed to donate royalties under this paragraph to
the Project Gutenberg Literary Archive Foundation. Royalty
payments must be paid within 60 days following each date on
which you prepare (or are legally required to prepare) your
periodic tax returns. Royalty payments should be clearly marked
as such and sent to the Project Gutenberg Literary Archive
Foundation at the address specified in Section 4, “Information
about donations to the Project Gutenberg Literary Archive
Foundation.”
• You comply with all other terms of this agreement for free
distribution of Project Gutenberg™ works.
1.F.
1.F.4. Except for the limited right of replacement or refund set forth
in paragraph 1.F.3, this work is provided to you ‘AS-IS’, WITH NO
OTHER WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR ANY PURPOSE.
Please check the Project Gutenberg web pages for current donation
methods and addresses. Donations are accepted in a number of
other ways including checks, online payments and credit card
donations. To donate, please visit: www.gutenberg.org/donate.
Most people start at our website which has the main PG search
facility: www.gutenberg.org.