jump to navigation

Lendo Euclides por Beppo Levi 2013/09/03

Posted by gsavix in ciência colaborativa, civilização, colaboração na aquisição conhecimento, Conhecimento, conhecimento física, Conhecimento para receber ou transferir tecnologia, construtores de documentação, gerador documentos, máxima matemática, Memorando, metodologia para receber ou transferir conhecimento, morfologia, notícias interesse público, publicação jornal internet, semântica, sintaxe, sistema hipotético dedutivo, sociologia do conhecimento.
add a comment

A matemática e a geometria sob um olhar renovador.

Editora Civilização Brasileira – Rio de Janeiro – 2008
(um selo da editora record ltda)

Tradução do espanhol (Leyendo a Euclides)

Ao publicar sua monumental obra Elementos, Euclides de Alexandria (360 a.C. a 295 a.C.), criador da geometria euclidiana, tornou-se o mais importante matemático da Antiguidade greco-romana e talvez de todos os tempos.

A obra abrange toda a aritmética, a álgebra e a geometria conhecidas até então no mundo grego, sistematiza o conhecimento geométrico dos antigos e intercala os teoremas já conhecidos com a demonstração de muitos outros, que completam lacunas e dão coerência e encadeamento lógico ao sistema que ele criou.

Em Elementos, Euclides introduziu o formato (ou método) axiomático, que é, em grande medida, o paradigma do modo de operar da razão matemática. Seus axiomas cristalizaram uma estética quase imperativa para essa razão: a estética do equilíbrio delicado entre simplicidade e alcance, entre o mínimo de pressupostos e o máximo de consequências deriváveis. A genialidade do modelo euclidiano reside em que a partir de noções elementares como ponto, reta, círculo e juntamente com apenas cinco axiomas, é possível desenvolver análises que abrangem toda a geometria clássica.

Beppo Levi escreveu “Lendo Euclides” em 1947, e já nesta época era reconhecido na comunidade científica como alguém que formulou as bases do ensino claro e do respeito pela investigação científica, na qual deve prevalecer o rigor lógico. Seu objetivo era atrair a atenção dos leitores não matemáticos para o estudo dos conceitos fundamentais da geometria e da filosofia por meio da reflexão e da análise cuidadosa de Elementos. Neste livro não é o matemático profissional quem escreve, mas o estudioso que transmite sua paixão pela matemática, pela história e pela filosofia. Ao fazer essa leitura e vem a tona a reflexão de um diálogo que atravessa mais de vinte e dois séculos e permite aprender Euclides com olhos modernos. Os leitores terão a oportunidade de reaprender a geometria pelas mãos de um célebre matemático.

Beppo Levi nasceu em Turim, na Itália, em 1875. Doutorou-se em 1896, com apenas 21 anos e a partir de 1906 foi professor nas universidades de Cagliari, Parma e Bolonha. em 1938, devido à perseguição anti-semita do regime fascista de Mussolini, teve de emigrar com sua família. estabeleceu-se na cidade de Rosario, na Argentina, onde viveu até sua morte em 1961. Lá fundou o Departamento de Matemática da Universidad Nacional del Litoral – que hoje leva seu nome – e influenciou na formação de grandes cientistas argentinos.

Euclides dois mil anos depois

Entre diversas coisas, conjecturou e demonstrou que existem infinitos números primos (indivisíveis). Ganhou a vida dando aulas de matemática a curiosos, desejosos de aprender para saber, não para fazer. Conta a tradição que quando um aluno novato lhe perguntou que proveito material poderia obter com o estudo da matemática, Euclides teria chamado seu escravo e lhe teria dito: “Dê uma moeda de ouro a esse infeliz, já que ele pensa que deve ganhar para aprender”.

É muito possível que Euclides tenha estado conectado com o Museu de Alexandria, visto que nesse instituto estatal de investigações científicas e humanísticas se havia congregado a flor e a nata da intelectualidade da época. Os pesquisadores do Museu recebiam salários do tesouro real para produzir conhecimentos que raras vezes tinham aplicação prática. Só formavam e proviam cérebros curiosos e engenhosos, a começar pelos próprios. Quantos estadistas do nosso século entendem que o conhecimento básico é o mais útil, por ser utilizável em múltiplos campos?

A principal obra de Euclides, intitulada Elementos, é o livro antigo mais estudado da História. Reúne e sistematiza os conhecimentos geométricos de seu Tempo. Por isso já se disse que Euclides não foi original: apenas compilou invenções alheias. Os que repetem essa tese desconhecem que Euclides construiu a primeira teoria propriamente dita registrada pela História, o sistema Hipotético-Dedutivo. Antes dele, a matemática era um amontoado de resultados soltos; a partir dele, foi se convertendo em um conjunto de sistemas relacionados entre si.

Euclides introduziu explicitamente o formato (também chamado método) axiomático, que consiste em começar listando os conceitos básicos e os postulados – ou seja, ideias não deriváveis de outras ideias no mesmo sistema – e derivar (definir ou deduzir) os demais a partir deles.

A axiomática serve de parâmetro para a organização racional e econômica de qualquer corpo de conhecimentos, sejam matemáticos, físicos, econômicos, filosóficos ou outros. Spinoza, por exemplo, a utilizou em sua grande obra “Ética”. Hoje, os filósofos a empregam para esclarecer, sistematizar e provar ideias em qualquer ramo da filosofia.

David Hilbert, no final do século XIX, exaltou e advertiu para as virtudes da axiomática. Utilizou-a em matemática e em física, e a tornou seu cânone (Hilbert, 1918). Entre estas virtudes figuram as seguintes:

– economia
– aceleração da dedução
– facilitação do exame de coerência lógica
– esclarecimento de suposições
– individualização dos conceitos básicos ou primitivos (definidores) e busca de fundamentos cada vez mais profundos.

Essas virtudes tornam quase plausível a anedota segundo a qual Blaise Pascal, aos 14 anos, teria reconstruído por sua própria conta a maior parte da geometria euclidiana a partir de seus postulados.

No entanto, o método axiomático pode enganar, ao sugerir que basta um sistema de axiomas para deduzir todos os teoremas em um campo definido. De fato, salvo nos casos das consequências imediatas (corolários), é preciso agregar suposições, tais como construções, exemplos ou lemas (proposições tomadas de campos fronteiriços). Por exemplo para provar que a soma dos ângulos internos de um triângulo é igual a dois ângulos retos, convém começar traçando uma reta paralela a um dos lados. Outros teoremas euclidianos requerem outras construções (ad hoc) mais ou menos engenhosas. Talvez por esse motivo Einstein, já famoso e sempre muito ocupado, tenha se dado ao trabalho de escrever uma carta ao psicólogo Wertheimer expondo duas provas diferentes do teorema geométrico do antigo Menelau. [minha anotação: também Einstein trabalhando por muitos anos no escritório de patentes na Suiça, deve ter visto, lido, analisado centenas de tratados, teoremas, ideias, roteiros, etc].

Isso, junto com sua sistemática e seu rigor lógico, faz com que o estudo da geometria euclidiana seja possivelmente mais formativo do que o da geometria analítica ou o do cálculo infinitesimal. Essas teorias possuem algoritmos (regras) que podem se aplicar uniformemente e, em muitos casos, mecanicamente. Esse, além da inércia secular, é um dos motivos que os Elementos se tornou um dos livros mais difundidos em todo mundo durante dois milênios. Seu estudo exige tanto engenho e empenho quanto rigor. Forma tanto matemáticos quanto advogados.

A lógica da geometria de Euclides, em particular sua sistemática e coerência, continua suscitando admiração. Não causa surpresa que um matemático moderno como Beppo Levi lhe tenha dedicado um estudo profundo ainda que sem a carga erudita habitual. Nem é de se estranhar, também, que este livro do matemático ítalo-argentino desperte a curiosidade de leitores contemporâneos.

Beppo Levi (1875-1961) foi um matemático tão versátil como distinto. Mesmo tendo trabalhado principalmente com geometria algébrica, fez importantes incursões em outros campos, tais como a análise matemática, a teoria dos números, a teoria dos conjuntos, a lógica e a dialética da matemática. Semelhante universalidade é inconcebível hoje em dia, em parte porque se sabe muitíssimo mais, em parte porque se superestimam a especialização, sem reparar que as fronteiras entre as disciplinas são, em grande medida, artificiais.

Afirma-se que, entre 1897 e 1909, Levi participou ativamente em todos os novos desenvolvimentos da matemática da época (Schappacher e Schoof, 1996). Seu nome aparece associado, direta ou indiretamente, aos nomes de quase todos os grandes matemáticos de seu tempo, entre outros, Hilbert, Lebesgue e Poincaré. Além disso suas contribuições pertencem à pré-história de vários ramos da matemática que emergiram depois de Levi.

Entre outras coisas, Levi talvez tenha sido o primeiro a formular explicitamente e a criticar o axioma da escolha, usualmente atribuído a Zermelo (Moore, 1982). Descobriu que estava sendo utilizado tacitamente em muitas demonstrações matemáticas (tal axioma continua sendo motivo de estudos). Mas Levi é bem mais conhecido pelo lema que leva seu nome, e que se refere a integrais de sucessões monótonas de funções. Também é conhecido por seu estudo, mais importante, de singularidades de superfícies algébricas.

Ironicamente, esse grande homem tem sido considerado o matemático mais baixinho do século. Era corcunda, tinha uma voz estridente e era casado com uma mulher linda, com quem teve três filhos, entre eles Laura, a física da família. Embora Levi não tenha passado no exame de pureza racial, viveu muito mais anos, comportou-se muitíssimo melhor, concebeu e criou mais filhos e mais ideias que seu perseguidor.

A legislação anti-semita promulgada pelo governo fascista italiano em 1938 privou Levi de sua cátedra em Bolonha e o obrigou a emigrar junto com a família. Aos 64 anos de idade, recomeçou a vida: veio parar no ramo de Rosario da Universidade Nacional do Litoral. Isso se deveu à gestão de seu ilustrado reitor, o engenheiro Cortés Plá, e do matemático Julio Rey pastor, grande incentivador da ciência na Argentina e na Espanha.

Em sua nova Pátria, Levi fez um pouco de tudo. Deu cursos para estrangeiros; em 1940, fundou e dirigiu o Instituto de Matemática e sua revista , Mathematicae Notae; estimulou os poucos jovens que se interessavam pela Matemática pura; participou de reuniões de físicos; continuou cultivando as humanidades e inclusive encontrou tempo para responder algumas questões matemáticas formuladas por alunos e colaboradores.

Aprenderão com este livro a ver Euclides e inclusive seu mestre Platão, através dos olhos modernos.

Mario Bunge
Foundations and Philosophy of Science Unit
MCGill University, Montreal

Referências bibliográficas:

– Hilbert, D. “Axiomatisches Denken”, in Gesammelte Abhandlungen, vol. 3. Berlim: Julius Springer, 1918.

– Moore, G. E. Zermelo’s Axioms of Choice. Nova York: Springer-Verlag, 1982.

– Schappacher, N. e Schoof, R. “Beppo Levi and the arithmetic of elliptic curves”, in The Mathematical Intelligencer 18: 57-69, 1996.

adaptado por Gilberto dos Santos Alves
com base em livros e artigos da Biblioteca de São Paulo – agosto de 2013.

Tributo para a Linguística e Chomsky 2013/04/28

Posted by gsavix in Computadores, Conhecimento, Conhecimento para receber ou transferir tecnologia, construtores de classe do documentos web, construtores de documentação, língua portuguesa, Memorando, metodologia para receber ou transferir conhecimento, publicador documentação, Sistemas Computacionais, Sistemas de Gestão da Produção, sociologia do conhecimento, Soft.
add a comment

Como traduzir em palavras para alguém que me pergunta:

O que a Linguística tem a ver com ciência da Computação?

Realmente não é intuitivo explicar que na Universidade de São Paulo existe a Faculdade de Filosofia Letras e Ciências Humanas que possui um Departamento de Linguística que foi criado nos anos 198X.

Mas acontece que este departamento entre outros conhecimentos fundamentais para qualquer pessoa que pretenda entender ou pouco mais sobre ciência, pesquisa e ensino, também cuida da Fonologia, da Morfologia Semântica e Sintática, da Semiologia e diversas outras disciplinas que são vitais para auxiliar na compreensão do pensamento, da transmissão e recepção de mensagens, a desconstrução de modelos lógicos semânticos ou sintáticos; resumindo algo a ver com lógica sem a qual não é possivel compreender, aprender nem transmitir conhecimento.

Desde a graduação em linguística quando passei a saber da existência de Noam Chomski, Ferdinand de Saussire, Roland Barthes   entre outros, o ponto de vista sobre linguagens de computação que até então eu usava para construir aplicações e sistemas, como Cobol, RPG, Fortran, Assembler, Algol, REXX passaram a compor uma outra dimensão.

Como entender a lógica aplicada na linguagem humana, seja ela escrita, falada, representada em uma peça teatral, uma novela apresentada em capítulos, um folhetim ou um filme que tem a magia de transformar uma sala de cinema em outro lugar?

Como decifrar o conhecimento existente nessa lógica de apresentar algo?

Como a propaganda consegue usar e abusar desse conhecimento passando ao largo da lei, da ética ou de qualquer barreira cultural?

Logo nas primeiras aulas para minha frustração um eminente professor do departamento desmontou minhas pretensões de fazer qualquer paralelo entre a linguística que em sua visão deveria ser usada apenas para compreender a linguagem humana e não serviria para captar ou compreender ou modelar a linguagem usada nos computadores.

Demorei mais de cinco anos até encontrar documentação de ponta sobre o conceito das linguagens simbólicas como a linguagem assembler usada para abstrair qualquer coisa, macros que permitiam apenas com algumas instruções e parâmetros produzir “objetos” que poderiam ser qualquer coisa ou classe. Ainda no final dos anos 80 tomei contato com a linguagem C++ orientada a objeto que nos permitia modelar classes, hereditariedade, polimorfismo, métodos, acoplamentos entre outras propriedades ou atributos.

Isso me permitiu compreender toda a gramática sintática e semântica que os engenheiros projetistas de linguagens e não sómente codificadores de sistema precisaram construir para permitir que através da linguagem C++ fosse possivel escrever uma solução para uma aplicação de computador e que esta poderia com muito menor esforço do que o requerido pelos programas em linguagem assembler.

Assim conheci a linguagem SmallTalk que já existia desde o pós segunda-guerra mas que para nós que escreviámos aplicações comerciais, financeiras ou muito triviais parecia não utilizável.

Quando passei a me interessar mais pela estrutura de uma aplicação para entender os pontos que não apresentam uma boa performance e são considerados como “gargalos” pois impedem maximizar recursos de computação, transmissão ou recepção (hoje usando a internet), processos sincronos, assíncronos, recuperação semântica ou fonética percebi que as disciplinas que lidam com a lógica, matemática, modelos gramaticais e semânticos passam a ter uma importância que pode definir se uma aplicação será um sucesso comercial e econômico gerando ganhos para as empresas que a utilizam.

Logo pude encontrar os conectores de aplicações ou API que permitem a conexão de diferentes aplicações e funcionalidades permitindo o aproveitamento de aplicações estáveis mas que não possuiam a capacidade de interagir com as novas gerações de aplicativos.

Faz algum tempo já encontrei alguns artigos que permitem ilustrar minhas desconfianças sobre usar intensamente a linguística para criar, modelar, documentar procedimentos executados por humanos ou não chamados workflow. Um certo tipo de sequênciamento de procedimentos permitindo mapear, custear, modificar recursos alocados a cada etapa do procedimento.

Muitas novas linguagens como por exemplo HTML, XML, JSON, JAVA, , WSDL, PL/SQL para os bancos de dados, Perl, PHP, Python, BPEL, BPMN, WS-BPEL (usada para especificar serviços na web), Máxima e WxMáxima escritos em Lisp que permitem a modelagem matemática muito rápida e principalmente sendo software livre GPL

Apresentarei dentro de semanas uma tradução que demonstra esses conceitos iniciais, a partir de uma tradução de um artigo de Aaron Maxwell do sítio eletrônico url: http://redsymbol.net/articles/svg-markup-chomsky/ que tão bem ilustra isso.

Enquanto isso apresento o artigo original em inglês:

SVG, Markup Languages and the Chomsky Hierarchy

A fascinating correspondence between markup languages and the theory of computation

Note: This is an incomplete draft.

Software development sometimes seems divorced from the theory of computer science. Certainly being good with math does not automatically make one a great coder, and vice versa; some different skills and personality traits are required.

Deep down, however, there are certainly places where the two worlds intersect. Some friends and myself came across one recently, at the intersection of two roads: gritty, practical XML markup languages, and the Chomsky Language hierarchy.

SVG is such a markup language. It’s an XML specification of 2D vector graphic images, which can be rendered directly or converted to other image file formats.

simple.svg svg source

<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" 
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100" height="60"
     xmlns="http://www.w3.org/2000/svg">
  <rect fill="green" x="15" y="15" width="70" height="30"/>
  <rect fill="red" x="20" y="20" width="60" height="20"/>
</svg>

SVG provides a rich set of primitives and high level features for describing two-dimensional graphics, including operations for styling, object grouping and transformations, and for incorporating text and bitmap images. In addition, it is an open web standard. It’s an interesting file format for what it does.

Let’s switch topics a moment to the language hierarchy. In the mid-20th century, Noam Chomsky famously outlined a ranking of formal languages based on their expressive power. Here, “formal” means “defineable using the tools of computer science and mathematics.” In the end, every general-purpose and specialized programming language is formal in this sense, even if the details of creating the formal description can get messy.

Chomsky’s original hierarchy had at least four distinctions, and several more refined distinctions usefully exist. Here, we are concerned with two of those categories: regular languages and context-free languages.

A language, in this context, is just a set of strings. That’s all. It can be an infinite set, and in fact, all useful programming languages I know of are infinite. Imagine all possible valid Java programs. That is a set of strings, and hence a language. Now imagine all possible regular expressions. That, too, is a set of strings, and a language. (The word “language” is overloaded a bit, which could confuse us if we allow it. We’ll try to dodge that.)

A language can be categorized depending on its expressive power. Two such categories are called “regular” and “context-free”. The definitions are quite precise: a language is regular if there exists some finite state machine that accepts all strings in the language and rejects all strings outside of it. And a language is context-free if there exists some context-free grammar that accepts all strings in that language, and rejects those outside of it.

You may be familiar with both finite state machines (FSMs) and context free grammars (CFGs). They are simply mathematical constructs that can be used to define sets of strings. In case you don’t recall or never learned, an important fact is that not all languages can be described by a FSM. In other words, some languages are regular, and some are not. Similarly, some languages are context-free (can be described by a CFG), and are not. However, all regular languages are also context-free languages, but not vice versa.

In other words, the set of context-free languages is a strict superset of the set of all regular languages. For this reason, we say that context-free languages have more expressive power than regular languages.

Now, how does this relate to markup languages? Well, XML, and some XML markup languages like SVG and XHTML, are all context free. You cannot create a finite state machine that will correctly discriminate all possible XML (or SVG or XHTML) documents.

However, every context-free language has subsets that are regular. Sometimes this is useful. Let’s start with a contrived example: minimal HTML documents that just contain lists. Consider exhibit A:

<html>
  <body>
    <ul>
      <li>Hello</li>
      <li>Handsome</li>
      <li>Programmer</li>
    </ul>
    <ul>
      <li>Another</li>
      <li>List</li>
    </ul>
  </body>
</html>

This specimin – a multi-line string – is from a language that is a limited subset of XHTML. Namely, those whose body contains only unordered lists, and whose list items contain simple text. It is a regular language; you can craft a FSM that accepts only this language. Now, you may or may not be conversant in building state machines. Regardless, we can just use regular expressions instead: as theorems in any thorough automata textbook will show, if and only if a language is regular, there exists some regular expression that accepts it (and rejects strings not in the language). So one regular expression for Exhibit A is:

"<html><body>" ("<ul>" ("<li>" text "</li>")* "</ul>")* "</body></html>"

This regular expression will only accept these simple-list HTML documents. Well, fine. But what if you need to work with documents like this:

<html>
  <body>
    <ul>
      <li>Programmers</li>
      <li>are</li>
      <li>
        <ul>
         <li>Handsome</li>
         <li>Charming</li>
         <li>Happy</li>
        </ul>
      </li>
    </ul>
    <ul>
      <li>Random</li>
      <li>Words</li>
    </ul>
  </body>
</html>

Here, there is a nested list, which is definitely not accepted by the regular expression above. Can you write a regular expression that will? Yes, but it would be a little messy, and that’s if you limit it to a single level of nesting. Nest deeper, and the regex explodes quickly. It turns out that no regular expression will match list nested to arbitrary depth.

However, a context free grammar that does so is pretty simple:

  HTML -> "<html><body>" UL* "</body></html>"
  UL -> "<ul>" LI* "</ul>"
  LI -> "<li>" ITEM "</li>"
  ITEM -> [char]* | UL

It is probably uncommon that you will encounter the need for infinitely nested HTML lists. This is an intentionally simple example, to make the concept easier to see. Now let’s look at something more complex and practical.

Here is a histogram, whose source is an SVG document:

http://static.redsymbol.net/articles/svg-markup-chomsky/img/Black_cherry_tree_histogram.svg svg source

(credit)

If you look at the source, you will see that it mainly consists of simple elements, defining lines, text and rectangles. Now, imagine all possible SVG documents that render histograms. Assume they are basic histograms, of the same form of the example here, devoid of unnecessary decorations like fractal outlines or anything weird like that.

That set of all SVG documents that render histograms is a set of strings – a language. Quiz time: is this language regular?

Yes, it turns out. Structurally, it is simply “START BAR* END”, where START is a header for the SVG document, each BAR is an SVG snippet that renders one of the bars, and END is a closing tag. (Actually, I’m lazily omitting elements to display the axes, tick marks, labels, etc. No matter; the end result is the same.) mkhist.py is a short python program that generates such histograms:

#!/usr/bin/env python
'''
_start_ _bar_* _end_

'''

_start = '''<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100%" height="100%" version="1.1"
     xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink">
  <desc>Histogram</desc>

  <!-- Begin data plots -->
'''

_end = '</svg>\n'

def _bar(n, v):
    s = '  <!-- Histogram bar #%d (value: %d) -->\n' % (n, v)
    x = 10 + 20 * n
    h = v * 10
    s += '  <rect fill="red" x="%d" y="5" ' \
         'width="10" height="%d"/>\n' % (x, h)
    return s

data = [1, 5, 7, 3, 12, 4]

svg = _start
for n, v in enumerate(data):
    svg += _bar(n, v)
svg += _end

print svg

The data being plotted is hardcoded near the end. Using those values, mkhist.py will generate a histogram like this:

http://static.redsymbol.net/articles/svg-markup-chomsky/img/histogram.svg svg source

<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100%" height="100%" version="1.1"
     xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink">
  <desc>Histogram</desc>

  <!-- Begin data plots -->
  <!-- Histogram bar #0 (value: 1) -->
  <rect fill="red" x="10" y="5" width="10" height="10"/>
  <!-- Histogram bar #1 (value: 5) -->
  <rect fill="red" x="30" y="5" width="10" height="50"/>
  <!-- Histogram bar #2 (value: 7) -->
  <rect fill="red" x="50" y="5" width="10" height="70"/>
  <!-- Histogram bar #3 (value: 3) -->
  <rect fill="red" x="70" y="5" width="10" height="30"/>
  <!-- Histogram bar #4 (value: 12) -->
  <rect fill="red" x="90" y="5" width="10" height="120"/>
  <!-- Histogram bar #5 (value: 4) -->
  <rect fill="red" x="110" y="5" width="10" height="40"/>
</svg>

With some small modifications, one can add the useful decorations (axes, labels, etc.) It’s a little remarkable, when you think about it, that the universe of all possible histogram plots can be described by a reasonably simple state machine.

Now, can you think of examples of other “image languages” – sets of SVG documents – that are not regular?

One example: sets of images with some kind of bilateral symmetry — reminiscent of the classic context-free language example LCFG = {anbn | n > 0}. Perhaps more commonly, any image representing data with some kind of nested tree structure will not be regular either. Think organizational charts, electronic circuit diagrams, and graphical representations of parse trees.

(By the way, don’t fall into the trap of defining an overly permissive regular language, and believing that adequately describes your context free language. When crafting a construct to define a language, whether that construct be an FSM, regular expression, or CFG, the strings that the construct rejects are just as important as those it accepts. Let’s define a language named Lall by a regex C*, where C is any unicode character. Any context-free language will be a subset of L; that doesn’t mean L is in any way useful to you.)

Let’s examine one of these image classes that must be described by a context free language. Imagine a simple integer arithmetic language, using prefix notation. Its operators – consisting of *,+ and - – always take exactly two arguments, which can be either an integer, or another expression (surrounded by parentheses). So you will have expressions like (+ 2 3)(* 7 (+ 2 4)), and (+ (* (+ 2 3) 4) (- 7 2)) as members of this language.

Consider a specific expression: (* (+ 2 3) (- 7 (* 8 9))). Here is the syntax parse tree for it:

parsetree.svg svg source

In fact, this figure is an SVG image generated by an analogue of the histogram-writing script above. We’ll see that script in a moment; before we get to it, though, we need to do a little theoretical analysis. Think about the parse tree image, and the SVG language elements that must be present to render it.

This might seem difficult if this article is your first exposure to SVG, but it’s not actually not so hard: the only elements in the image are text elements – renderings of an operator or integer – and lines indicating parent-child relationships. SVG has primitives for both of these; the rest is boilerplate and detail you can ignore for now. So basically, the SVG file will contain a sequence of text definitions and line definitions (just assume all the coordinates are magically calculated for you), arranged in some particular order and subject to some constraint in its organization.

Can you imagine a regular expression that will describe all SVG documents representing expression parse trees? I doubt it, because there is not one. You can verify using the pumping theorem or any similar technique that it is not regular, for the same reason that set of valid expressions is not a regular language either. A context-free grammar representing this class of SVG documents is

svg -> <start> <node> <end>
<node> -> (<opline> <node> <node>) | <TERM>
<TERM> -> ("0".."9")*
<opline> -> <OP> <line_to_leftchild> <line_to_rightchild>
<OP> -> "*" | "+" | "-"

mkparsetree.py will generate such SVG documents, given a preprocessed syntax parse tree (defined in the “data” variable towards the end of the script):

#!/usr/bin/env python
'''
svg -> _start_ _node_ _end_
_node_ -> _node_ _OP_ _node_ | _TERM_
_TERM_ -> 0..9
_OP_ -> * | +

'''

_start = '''<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg width="100%" height="100%" version="1.1"
     xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink">
  <desc>Arithmetic Parse Tree</desc>

  <!-- Begin  parse tree data -->
'''

_end = '</svg>'

def _t(x, y, s):
    return '<text font-size="30" x="%s" y="%s">%s</text>\n' % (x, y, s)

def _node(args, x, y, depth):
    op, n1, n2 = args[0], args[1], args[2]
    x_n1 = int(x-100/depth)
    x_n2 = int(x+100/depth)
    y_child = y + 80
    if type(n1) is list:
        n1_s = _node(n1, x_n1, y_child, depth+1)
    else:
        n1_s = _t(x_n1, y_child, n1)
    if type(n2) is list:
        n2_s = _node(n2, x_n2, y_child, depth+1)
    else:
        n2_s = _t(x_n2, y_child, n2)
    s = _t(x, y, op)
    s += n1_s
    s += n2_s
    line_fmt = '<path d="M %d %d L %d %d" stroke="black" ' \
        + 'stroke-width="1"/>\n'
    s += line_fmt % (x+5, y + 15, x_n1+8, y_child - 25)
    s += line_fmt % (x+5, y + 15, x_n2+8, y_child - 25)
    return s

DATA = ['*', ['+', '2', '3'], ['-', '7', ['*', '8', '9']]]

print _start + _node(DATA, 200, 30, 1) + _end

Much of mkhist.py and mkparsetree.py are similar. The interesting difference is in comparing the _bar and _node functions. The _bar function in the histogram generator simply calculates the SVG snippet that will render an appropriate rectangle. The parse tree generator’s_node function, in contrast, may recursively call itself any number of times. In fact, any pair of generators, one for regular-language images and one for context-free-language images, will show some form of this difference.

Does this relate to practical software engineering? You bet. These two models delineate two different broad classes of problems, and provide insight in the kind of algorithms that can effectively address them. Let’s say you need to develop a component that generates images according to some requirements; having read this far, it’s clear that the range of possible images will dictate the nature of the rendering code. Of course, the basic idea is not limited to the domain of two-dimensional graphics; it is more fundamental, and applies to many software engineering problems.

boletim nuto santana – machado de assis 2011/04/11

Posted by gsavix in biblioteca pública wireless, civilização, classes de documentação web html, colaboração na aquisição conhecimento, como gerar documentos a partir dos programas fonte, como publicar na internet gratuitamente, Conhecimento para receber ou transferir tecnologia, construtores de classe do documentos web, construtores de documentação, gerador documentos, língua portuguesa, machado de assis, notícias interesse público, publicação jornal internet, publicador documentação.
add a comment

A finalidade deste artigo é apresentar quais são os livros que estão na biblioteca pública nuto santana, que fica aqui em são paulo – brasil – e possui muitos dos livros desse importante autor brasileiro.

Se você deseja fazer seu trabalho escolar ou pesquisa e usar alguns dos livros saiba que é só fazer sua carteirinha gratuitamente na biblioteca e retirar o livro para sua pesquisa ou trabaho sem nenhum custo. de graça. gratuito.

veja a lista das obras que estão do sistema da biblioteca e só aqui você tem a lista que pode ser encontrada facilmente pelos buscadores google, yahoo, bing, ask etc.

 

baixe o arquivo contendo o pdf para melhorar sua pesquisa:

 

MachadodeAssisNutoSanabril2011

 

você também pode acessar esta versão para seu dispositivo móvel independente de versão de sistema operacional.

Protótipo Boletim Novos Títulos 2011/02/23

Posted by gsavix in biblioteca pública wireless, classes de documentação web html, colaboração na aquisição conhecimento, como gerar documentos a partir dos programas fonte, como publicar na internet gratuitamente, Conhecimento para receber ou transferir tecnologia, construtores de classe do documentos web, construtores de documentação, gerador documentos, língua portuguesa, Memorando, metodologia para receber ou transferir conhecimento, publicação jornal internet, publicador documentação, www.auvix.com.br.
1 comment so far

Boletim Biblioteca Pública Nuto Santana – São Paulo – SP — Boletim Nuto Santana fev/2011 – Sphinx




publicar periódico ou jornal na web com htmldoc 2011/02/02

Posted by gsavix in classes de documentação web html, como publicar na internet gratuitamente, Conhecimento, Conhecimento para receber ou transferir tecnologia, construtores de classe do documentos web, construtores de documentação, Doc, gerador documentos, Memorando, metodologia para receber ou transferir conhecimento, publicação jornal internet, publicador documentação, Soft.
add a comment

Overview

Assim como outros programas  HTMLDOC  foi desenvolvido como resposta a uma necessidade de algumas organizações gerar documentação de alta qualidade, tanto impressas como na web.

Com a escrita do programa HTMLDOC para gerar documentação, naturalmente o HTML tornou-se a fonte de tudo, pois com a escolha de um editor o que você ve é o que você obtem “WYSIWYG” e em último caso você também pode usar um editor de texto para criar sua documentação.  Nós geramos HTML como saída em nossa documentação, que pode ser vista em um web server. Também pode ser gerada a saída em arquivo formato PDF ou PostScript para atender a qualquer requerimento de visualização ou impressão.

O resultado do nosso esforço é que HTMLDOC está disponível em Linux®/UNIX®, GNU/Linux, MacOS® X, and Microsoft® Windows®. Este manual foi produzido utilizando HTMLDOC, e esta tradução foi feita a partir do site http://www.htmldoc.org. Enquanto HTMLDOC pode converter páginas web em arquivos PostScript ou PDF, seu forte é gerar publicações indexadas.

HTMLDOC usa elementos de cabeçalho HTML para delinear capítulos e cabeçalhos nas publicações. O elemento  H1 é usado para capítulos:

    <HTML>
    <HEAD>
	<TITLE>O pequeno computador que pode</TITLE>
    </HEAD>
    <BODY>
    <H1>Capítulo 1 - O Pequeno Computador Nasceu</H1>
    ...
    <H1>Capítulo 2 - A Primeira Tarefa do Pequeno Computador</H1>
    ...
    </BODY>
    </HTML>

Subcabeçalhos são marcados usando-se elementos H2 até H6.

Nota:Quanto usando modo ” book”, HTMLDOC inicia a criação com o primeiro elemento H1. Qualquer texto, imagem, tabela ou outros elementos visíveis, que precedam o primeiro H1 são silenciosamente ignorados. Por causa disso, certifique-se que o seu arquivo HTML contenha um elemento H1.


Suporte a Temas em HTML (CSS) 2011/02/01

Posted by gsavix in biblioteca pública wireless, classes de documentação web html, colaboração na aquisição conhecimento, como gerar documentos a partir dos programas fonte, como publicar na internet gratuitamente, Conhecimento, Conhecimento para receber ou transferir tecnologia, construtores de documentação, Doc, língua portuguesa, Memorando, metodologia para receber ou transferir conhecimento, notícias interesse público, publicação jornal internet, publicador documentação, Sistemas Computacionais, sociologia do conhecimento, Soft.
add a comment

Suporte a Temas em HTML

Novo na versão 0.6.

Sphinx suporta a mudança na aparência dos HTML gerados, através da funcionalidade chamada tema. Tema é uma coleção de modelos de folhas de estilo (CSS) além de outros tipos de arquivos estáticos. Adicionalmente, pode haver a configuração de arquivos que podem ter seu tema herdado de outro tema, permitindo utilizar várias opções de aparência e comportamento.

Temas podem ser desvinculados de projetos, podendo ser utilizados de maneira diferente em cada um deles, sem sofrer mudanças.

Usando um tema

Usar um tema existente é fácil. Se o tema já veio com o Sphinx, você só precisa configurar html_theme para o valor desejado.Com valor de html_theme_options você escolhe opções de aparência e comportamento. Por exemplo, você pode ter o seguinte em seu arquivo conf.py:

html_theme = "default"
html_theme_options = {
    "rightsidebar": "true",
    "relbarbgcolor": "black"
}

Isto irá dar a você o tema padrão, mas com uma barra lateral à direita e uma barra de relação ( a barra de navegação das ligações no topo e no rodapé) na cor preta.

Se o tema não veio com o Sphinx, ele pode ser em duas formas: um diretório contendo o arquivo theme.conf e outros arquivos necessários, ou um arquivo zip com os mesmos conteúdos. Qualquer um deles pode ser colocado onde o Sphinx pode encontrá-los; para isso pode ser usado o valor de configuração html_theme_path. Ele dá uma lista de diretórios, relativos ao diretório contendo o arquivo conf.py, os quais podem conter temas ou arquivos zip. Por exemplo, se você tem um tema em um arquivo blue.zip, você pode colocá-lo no arquivo conf.py e usar esta configuração:

html_theme = "blue"
html_theme_path = ["."]

Temas Internos

Visão Temas
default 

default

sphinxdoc 

sphinxdoc

scrolls 

scrolls

agogo 

agogo

traditional 

traditional

nature 

nature

haiku 

haiku

O Sphinx vem com uma seleção de temas que você pode usar.

Estes temas são:

  • basic – Essa é a formatação sem estilo usada como base para outros temas, e utilizável como base para outros temas configuráveis também. O HTML contém todos os elementos importantes como barras laterais e barras de relação. Tem uma opção (a qual é herdada por outros temas):
    • nosidebar (verdadeiro ou falso): Não inclui a barra lateral. Padrão é falso.
  • default – Este é o tema padrão,o qual parece com Documentação Python em <http://docs.python.org/>`_. Pode ser personalizado através destas opções:
    • rightsidebar (verdadeiro ou falso): Barra lateral do lado direito. Padrão é Falso.
    • stickysidebar (verdadeiro ou falso): Barra lateral ser fixa, ela não rola para fora da visão para conteúdos longos. Isto pode não funcionar bem para todos os navegadores. Padrão é falso.
    • collapsiblesidebar (true or false): Add an experimental JavaScript snippet that makes the sidebar collapsible via a button on its side. Doesn’t work together with “rightsidebar” or “stickysidebar”. Defaults to false.
    • externalrefs (true or false): Display external links differently from internal links. Defaults to false.

    There are also various color and font options that can change the color scheme without having to write a custom stylesheet:

    • footerbgcolor (CSS color): Background color for the footer line.
    • footertextcolor (CSS color): Text color for the footer line.
    • sidebarbgcolor (CSS color): Background color for the sidebar.
    • sidebarbtncolor (CSS color): Background color for the sidebar collapse button (used when collapsiblesidebar is true).
    • sidebartextcolor (CSS color): Text color for the sidebar.
    • sidebarlinkcolor (CSS color): Link color for the sidebar.
    • relbarbgcolor (CSS color): Background color for the relation bar.
    • relbartextcolor (CSS color): Text color for the relation bar.
    • relbarlinkcolor (CSS color): Link color for the relation bar.
    • bgcolor (CSS color): Body background color.
    • textcolor (CSS color): Body text color.
    • linkcolor (CSS color): Body link color.
    • visitedlinkcolor (CSS color): Body color for visited links.
    • headbgcolor (CSS color): Background color for headings.
    • headtextcolor (CSS color): Text color for headings.
    • headlinkcolor (CSS color): Link color for headings.
    • codebgcolor (CSS color): Background color for code blocks.
    • codetextcolor (CSS color): Default text color for code blocks, if not set differently by the highlighting style.
    • bodyfont (CSS font-family): Font for normal text.
    • headfont (CSS font-family): Font for headings.
  • sphinxdoc – The theme used for this documentation. It features a sidebar on the right side. There are currently no options beyond nosidebar.
  • scrolls – A more lightweight theme, based on the Jinja documentation. The following color options are available:
    • headerbordercolor
    • subheadlinecolor
    • linkcolor
    • visitedlinkcolor
    • admonitioncolor
  • agogo – A theme created by Andi Albrecht. The following options are supported:
    • bodyfont (CSS font family): Font for normal text.
    • headerfont (CSS font family): Font for headings.
    • pagewidth (CSS length): Width of the page content, default 70em.
    • documentwidth (CSS length): Width of the document (without sidebar), default 50em.
    • sidebarwidth (CSS length): Width of the sidebar, default 20em.
    • bgcolor (CSS color): Background color.
    • headerbg (CSS value for “background”): background for the header area, default a grayish gradient.
    • footerbg (CSS value for “background”): background for the footer area, default a light gray gradient.
    • linkcolor (CSS color): Body link color.
    • headercolor1, headercolor2 (CSS color): colors for <h1> and <h2> headings.
    • headerlinkcolor (CSS color): Color for the backreference link in headings.
    • textalign (CSS text-align value): Text alignment for the body, default is justify.
  • nature – A greenish theme. There are currently no options beyond nosidebar.
  • haiku – A theme without sidebar inspired by the Haiku OS user guide. The following options are supported:
    • full_logo (true or false, default false): If this is true, the header will only show the html_logo. Use this for large logos. If this is false, the logo (if present) will be shown floating right, and the documentation title will be put in the header.
    • textcolor, headingcolor, linkcolor, visitedlinkcolor, hoverlinkcolor (CSS colors): Colors for various body elements.
  • traditional – A theme resembling the old Python documentation. There are currently no options beyond nosidebar.
  • epub – A theme for the epub builder. There are currently no options. This theme tries to save visual space which is a sparse resource on ebook readers.

Criando temas

Como foi dito, temas podem ser diretórios ou arquivos zip (cujo nome é o nome tema), contendo o seguinte:

  • Um arquivo theme.conf veja abaixo,
  • Modelos HTML, se necessário.
  • Um diretório static/ contento qualquer arquivos estáticos, que serão copiados para o diretório estático de saída (diretório de build). Podem ser imagens, folhas de estilo, scripts, etc.

O arquivo theme.conf tem formato de INI [1] (legível inclusive pelo módulo Python ConfigParser) e tem a seguinte estrutura:

[theme]
inherit = base theme
stylesheet = main CSS name
pygments_style = stylename

[options]
variable = default value
  • inherit fornece o nome do tema básico “base theme”, ou none. O tema básico irá ser usado para localizar modelos inexistentes ( muitos temas não conseguem suprir outros modelos se eles usam basic como tema básico), estas opções serão herdadas e todos seus arquivos estáticos também.
  • stylesheet fornece o nome do arquivo CSS que será referenciado no header do HTML gerado. Se você preceisa mais de um CSS, inclua o segundo a partir do primeiro usando CSS’ @import, ou utilize um modelo de HTML que adiciona a ligação <link rel="stylesheet"> e as tags necessárias. Configurando o valor html_style irá sobrepor esta configuração.
  • pygments_style fornece o nome do estilo de “Pygments” que deverá ser usado para enfatizar as cores. Configurando o valor pygments_style irá sobrepor esta configuração.
  • A seção options contém pares de nome de variáveis e valores. Estas opções podem ser sobrepostas pelo usuário através de html_theme_options e são acessíveis a partir de todos os modelos como theme_<name>.

Modelos

O guia para modelos css guide to templating ajuda se você deseja escrever seu próprio modelo. O que é importante ter em mente é a ordem na qual o Sphinx procura por modelos (templates):

  • Primeiro, nos diretórios modelos do usuário templates_path.
  • Depois, no tema selecionado.
  • Após, em seus temas internos, Sphinx tema básico, etc.

Quando estender um modelo de tema, com o mesmo nome, use o nome do tema como um nome de diretório explícito: {% extends "basic/layout.html" %}. A partir de um modelo de usuário templates_path, você pode usar o “ponto de exclamação” como na sintaxe descrita no documento de modelo.

Modelos Estáticos

Temas foram criados para facilitar, o usuário em configurar aparência da documentação sem precisar escrever uma folha de estilos. É necessário um tema modelo bem como arquivos HTML. Entretanto o Sphinx suporta o que é chamado de “modelos estáticos” como segue:

Se o nome do arquivo está em um diretório de temas static/ ou em um caminho estático (terminado por _t), irá ser processado pelo motor de modelos. O _t irá ser deixado no final do nome do arquivo. Por ex: o tema padrão default é um arquivo static/default.css_t o qual usa um modelo para colocar cores em uma folha de estilo (css). Quando a documentação for construída com o tema padrão, o diretório de saída irá conter um arquivo _static/default.css onde os alvos (tags) já foram tratadas.

[1] Ele não é um arquivo Python executável, em oposição ao arquivo conf.py, pois pode expor a risco de segurança desnecessário já que é compartilhado.

Contrutores disponíveis¶ 2011/02/01

Posted by gsavix in biblioteca pública wireless, classes de documentação web html, colaboração na aquisição conhecimento, como gerar documentos a partir dos programas fonte, como publicar na internet gratuitamente, Conhecimento, Conhecimento para receber ou transferir tecnologia, construtores de classe do documentos web, construtores de documentação, Doc, gerador documentos, Memorando, metodologia para receber ou transferir conhecimento, publicação jornal internet, publicador documentação, Sistemas Computacionais, sociologia do conhecimento.
add a comment

Contrutores disponíveis

Estas são as classes de construtores internas do Sphinx. Mais construtores (Builders) podem ser adicionadas através extensões.

O nome do construtor precisa ser dado para a opção -b da linha de comando do sphinx-build para o construtor selecionado.

class sphinx.builders.html.StandaloneHTMLBuilder
Este é o construtor padrão de HTML. Sua saida é um diretório ou pasta com arquivos HTML, completados com folhas de estilos (CSS) e opcionalmente fontes de arquivos (reST). Existem poucos valores para escolher as opções desejadas neste construtor, veja o capítulo Opções para Saída HTML para detalhes.

Seu nome é html.

class sphinx.builders.html.DirectoryHTMLBuilder
Esta é uma subclasse do construtor HTML. Sua saida é um diretório contendo arquivos HTML, onde cada arquivo é chamado index.html e colocado em um subdiretório ou subpasta com nome igual ao do nome da página. Por exemplo: O documento markup/rest.rst não irá resultar em um arquivo markup/rest.html, mas markup/rest/index.html. Quando gerando ligações entre as páginas, o index.html é omitido, então aquela URL parecerá com markup/rest/.

Seu nome é dirhtml.

Novo na versão 0.6.

class sphinx.builders.html.SingleFileHTMLBuilder
Esse é um construtor HTML que combina todo o projeto em um único arquivo. (Obviamente isso só funciona para pequenos projetos.) O arquivo é nomeado como documento mestre. Não é gerado índice.

Seu nome é singlehtml.

Novo na versão 1.0.

class sphinx.builders.htmlhelp.HTMLHelpBuilder
Esse construtor produz a mesma saída que o construtor HTML, mas também cria arquivos de suporte Help HTML, que permitem que o Microsoft HTML Help Workshop, compile-os em um arquivo (CHM).

Seu nome é htmlhelp.

class sphinx.builders.qthelp.QtHelpBuilder
Esse construtor produz a mesma saída que o construtor HTML, mas também cria uma coleção de arquivos de suporte Qt help que permitem ao gerador de coleção Qt compilá-los.

Seu nome é qthelp.

class sphinx.builders.devhelp.DevhelpBuilder
Esse construtor produz a mesma saída padrão HTML, mas também cria GNOME Devhelp suporte arquivo que permite ao leitor GNOME Devhelp enxergá-los.

Seu nome é devhelp.

class sphinx.builders.epub.EpubBuilder
Esse construtor produz a mesma saída que o construtor HTML, mas também cria um arquivo epub para leitores de ebook. Veja Epub info para detalhes sobre ele. Para o formato das definições de epub olhe em http://www.idpf.org/specs.htm ou http://en.wikipedia.org/wiki/EPUB.

Alguns leitoros ebook não exibem os alvos das ligações de referência, entretanto este construtor adiciona os alvos, após as ligações quando necessário. A exibição de URLs pode ser personalizada através de regras CSS para a classe link-target.

Seu nome é epub.

class sphinx.builders.latex.LaTeXBuilder
Esse construtor produz um conjunto de arquivos LaTeX em um diretório de saída. Você deve especificar quais documentos serão incluídos nos arquivos LaTeX através do valor latex_documents. Existem alguns valores que podem ser personalizados para esse construtor, veja o capítulo Options for LaTeX output para mais detalhes.

Nota

A produção de arquivo LaTeX utiliza vários pacotes LaTeX que podem não estarem presentes em uma distribuição “mínima”. Para TeXLive, os seguintes pacotes precisam estar instalados:

  • latex-recommended
  • latex-extra
  • fonts-recommended

Seu nome é latex.

Note que um construtor direto PDF usando ReportLab está disponível em rst2pdf versão 0.12 ou maior. Pode ser necessário adicionar 'rst2pdf.pdfbuilder' para seu extensions para habilitá-lo, seu nome é pdf. Veja o manual rst2pdf manual para detalhes.

class sphinx.builders.text.TextBuilder
Esse construtor produz um arquivo de texto para cada arquivo reST – isto é o mesmo que a fonte reST, porém com várias marcações eliminadas para melhor legibilidade.

Seu nome é text.

Novo na versão 0.4.

class sphinx.builders.manpage.ManualPageBuilder
Esse construtor produz páginas de manual no formato groff. Você precisa especificar quais documentos serão incluídos nas páginas do manual através do valor de configuração man_pages.

Seu nome é man.

Nota

Esse construtor requer o gerador de páginas man docutils, e está disponível na versão 0.6 do docutils.

Novo na versão 1.0.

class sphinx.builders.html.SerializingHTMLBuilder
Esse construtor usa um módulo que implementa a API de serialização Python (pickle, simplejson, phpserialize e outras) para dar saída a documanetação gerada. O construtor pickle é uma subclasse dele.

Uma subclasse concreta desse construtor de serialização é a PHP serialization cujo formato é esse:

import phpserialize

class PHPSerializedBuilder(SerializingHTMLBuilder):
    name = 'phpserialized'
    implementation = phpserialize
    out_suffix = '.file.phpdump'
    globalcontext_filename = 'globalcontext.phpdump'
    searchindex_filename = 'searchindex.phpdump'
implementation
Um módulo que implementa funções dump(), load(), dumps() e loads() que tem os mesmos nomes conforme o módulo pickle. Módulos conhecidos na implementação desse interface são`simplejson` (ou json em Python 2.6), phpserialize, plistlib e outros.

out_suffix
O sufixo para arquivos normais.

globalcontext_filename
O nome de arquivo que contém “contexto global”. Esse é um dict (dicionário) contendo valores das configurações gerais, como por exemplo o nome do projeto.

searchindex_filename
O nome do arquivo para pesquisa do índice, que será gerado pelo Sphinx.

Veja Detalhes sobre Construtores de Serialização para detalhes sobre o formato da saída.

Novo na versão 0.5.

class sphinx.builders.html.PickleHTMLBuilder
Esse construtor produz um diretório ou pasta contendo arquivos pickle contendo fragmentos de HTML e informação sobre (TOC tabela de conteúdo), para uso com uma aplicação web ou ferramento para pós-processamento, a qual não usa os modelos de HTML padrão. Veja Detalhes sobre Construtores de Serialização para detalhes sobre o formato da saída.

Seu nome é pickle. (O nome antigo web também funciona.)

O sufixo de arquivo é .fpickle. O contexto global é chamado globalcontext.pickle, e o índice de pesquisa searchindex.pickle.

class sphinx.builders.html.JSONHTMLBuilder
Esse construtor produz um diretório com arquivos JSON, contendo fragmentos HTML e informações TOC, para uso em aplicação web (ou configurado para ferramentas de pósprocessamento) que não utiliza templates padrões HTML.

Veja Detalhes sobre Construtores de Serialização para detalhes sobre o formato da saída.

Seu nome é json.

O sufixo do arquivo é .fjson. O contexto global é chamado globalcontext.json, o índice searchindex.json.

Novo na versão 0.5.

class sphinx.builders.changes.ChangesBuilder
Esse construtor produz HTML com visão de todas as diretivas novidades da versão, versionadded e com as tornadas obsoletas deprecated na versão corrente version. Isto é utilizado para atualizar um arquivo registro de modificações “ChangeLog”, por exemplo.

Seu nome é: changes.

class sphinx.builders.linkcheck.CheckExternalLinksBuilder
Esse construtor procura em todos os documentos para ligações externas e tenta abrir, utilizando o módulo urllib2, e grava informações sobre quais estão quebradas para a saída padrão e para um arquivo chamado output.txt no diretório de saída.

Seu nome é linkcheck.

Extensões nativas (Built-in) do Sphinx que oferencem mais construtores são:

Detalhes sobre Construtores de Serialização

Todos os construtores de serialização gravam um arquivo para cada arquivo fonte e alguns arquivos especiais. Eles também copiam os arquivos fonte reST para o diretório ou pasta _sources sob o diretório ou pasta de saída.

A PickleHTMLBuilder é uma subclasse que implementa o interface de serialização.

Os arquivos do arquivo fonte têm a extensão out_suffix e são organizados em diretórios ou pastas assim como os arquivos fontes estão. Eles são revertidos para um dicionário (estrutura como um dicionário) com estas chaves:

body
O HTML “body” (isto é, o HTML deduzido do arquivo fonte), é renderizado pelo tradutor HTML.
title
O título do documento, como HTML (pode conter markup).
toc
A tabela de conteúdos do arquivo, é renderizada como um HTML <ul>.
display_toc
Um booleano que é True se o toc contém mais de uma entrada.
current_page_name
O nome do documento do arquivo corrente.
parents, prev and next
Informação sobre capítulos relacionados à árvore TOC. Cada relação é um dicionário com as chaves link (HREF para a relação) e title (título do documento relacionado, como HTML). parents é a lista das relações, enquanto prev e next são relações simples.
sourcename
O nome do arquivo fonte sob _sources.

Os arquivos especiais estão localizados no diretório ou pasta de saída. São:

SerializingHTMLBuilder.globalcontext_filename
Um dicionário pickled com as chaves:

project, copyright, release, version
Os mesmos valores informados no arquivo de configuração.
style
html_style.
last_updated
Data da última geração.
builder
Nome do construtor utilizado, no caso de pickles será sempre 'pickle'.
titles
Um dicionário de todos os documentos títulos como strings HTML.
SerializingHTMLBuilder.searchindex_filename
Um índice que pode ser usado para pesquisar na documentação. É uma lista pickled com as seguintes entradas:

  • Uma lista indexada de nomes de documentos.
  • Uma lista de títulos de documentos, como strings HTML, na mesma ordem da primeira lista.
  • Um dicionário mapeando palavras raízes (processadas por um stemmer em inglês) para uma lista de inteiros, os quais são índices para a primeira.
environment.pickle
O ambiente do construtor. Sempre é um arquivo pickle, independente do construtor e uma cópia do ambiente no qual o construtor foi iniciado.

Por fazer

Documentar os membros comuns.

Diferentemente de outros arquivos pickle, esse arquivo requer que o pacote sphinx esteja disponível para desfazer o pickle.