Ir para conteúdo
Julio Marcos

Relato de experiência lendo diversos livros considerados essenciais no Desenvolvimento de Jogos

Recommended Posts

Fiz um relato sobre a minha experiência lendo diversos livros considerados essenciais por muita gente da indústria. 

 

Desenvolver jogos em 2018 é uma tarefa muito mais fácil do que há poucos anos atrás antes do advento de engines como Unity e Construct. Porém para poder ir além do que as engines entregam de maneira mais automática e direta o estudo dos fundamentos é fundamental, em sites é possível se estudar qualquer coisa mas em geral o material é disperso.

A vantagem de se utilizar livros para estudar um assunto é que os livros costumam ser abrangentes, testam o seu conhecimento com exercícios e você passa mais tempo estudando do que procurando material na internet.

Esta é a lista dos livros que considero essenciais para se tornar um desenvolvedor de grande competência e sem medo de experimentar suas próprias ideias.

Além de recomendar os livros que você deve ler também vou dizer minha opinião de quais livros você pode pular sem culpa.

Língua dos livros. Infelizmente os livros que estou recomendando são escritos por autores de outros países, se alguma tradução se tornar disponível atualizarei esta lista o mais rápido possível.

 

 

Matemática

Como muita gente já deve lhe ter dito, jogos envolvem muita matemática, e eu concordo. Porém nem tudo que é dado em sala de aula no ensino médio e superior é de grande importância para o nosso assunto.

3d-math-primer.jpg
 

3D Math Primer for Graphics and Game Development, Segunda Edição

Assim como está escrito no título, este livro serve como uma introdução da matemática em três dimensões utilizada na programação gráfica e programação de jogos em geral. Se esforça, sempre traz os conceitos à luz de algo que interessaria uma pessoa ingressante na área de jogos, passa por muitos assuntos realmente relevantes como vetores, espaços de coordenadas, matrizes e transformações até a assuntos que não se estuda comumente no currículo comum do nível superior como curvas em 3D, coordenadas homogêneas e extensivos testes de interseção geométricas.

O livro peca em suas explicações, entretanto. Algumas partes possuem explicações desnecessárias, e em outras os fundamentos são deixados de lado ou a intuição não é construída.

Foi um livro que exigiu muita dedicação pois por diversas vezes eu tive que buscar material em outros livros ou sites para poder realmente entender do que se tratava. Os exercícios também costumam ser bem bobos.

Mesmo assim, é um livro que vale a pena ler nem que seja somente para saber quais assuntos você deve estudar e como eles são aplicados.

Veredito: 4 (de 0 a 5)
Obrigatório: Sim

practical-linear-algebra-toolbox.jpg
 

Practical Linear Algebra: A Geometry Toolbox, Terceira Edição

Este livro é um excelente livro para ser lido logo após o 3D Math Primer. Todo o formalismo matemático e a falta de exercícios mais pesados que o livro anterior não possui este aqui tem de sobra, mas não se engane achando que a linguagem aqui não é acessível, pois ela é. Todo mundo sabe o que é ler um livro de matemática impossível de entender e com exemplos sem sentido.

Os autores optam por fugir do infame estilo maçante de definição, teorema e corolário, com tantos livros que utilizam esta abordagem é sempre bom encontrar algo um pouco mais formal que consegue fugir deste trio da destruição intuitiva. Praticamente todo o conteúdo aqui é utilizando no desenvolvimento de jogos e em particular na parte gráfica, ou seja, se você tem interesse em criar seus próprios shaders ou se aventurar na criação da parte gráfica de uma engine este livro é leitura obrigatória.

Poderia se aventurar um pouco na parte computacional de maneira mais explícita visto que o livro foi feito tanto para pessoas interessadas em aprender álgebra linear mais prática quanto como um preparatório para um curso de computação gráfica.

Veredito: 4 (de 0 a 5)
Obrigatório: Não, mas bastante recomendado

geometric-algebra-comp-sci.jpg
 

Geometric Algebra for Computer Science

Um assunto bastante novo que serve de alternativa à tradicional álgebra com matrizes. É realmente um livro de vanguarda em comparação aos outros que comumente são estudados, é uma teoria que se desenvolver como uma extensão da álgebra linear clássica e é comumente recebida como bastante prazerosa, consegue-se se abordar a geometria de 3 dimensões, em particular a rotação, sem ter que recorrer aos quase incompreensíveis quaternions. Eu ainda não terminei de ler este livro mas ele promete bastante.

Veredito: ? (de 0 a 5)
Obrigatório: Não

Desenvolvimento de jogos em geral

Provavelmente estes são os livros que mais vão lhe fazer se sentir um desenvolvedor (programador) de jogos de fato.

game-engine-architecture.jpg
 

Game Engine Architecture

Tem sido o livro mais citado aqui no site e em muitos outros lugares. O autor possui extensa experiência real do campo e hoje trabalha como Programador Chefe na Naughty Dog. Apesar do livro ser extenso o nível de detalhe e a clareza com a qual ele passa os conceitos é fenomenal, um livro atual e que provavelmente vai se manter atual por muitos anos. Dificilmente você irá encontrar tantos tópicos do mais alto interesse do programador de engines e com tanta riqueza de detalhes escritos de maneira acessível do que este livro.

Mesmo que o principal foco seja para que está interessado em programar uma engine, o programador de jogos generalista também vai obter incríveis conhecimentos que vão lhe ajudar a obter o máximo de suas engines e também na implementação de subsistemas alternativos (fará isso por diversos motivos: performance, otimização de processo de trabalho, integração com outras ferramentas...) aos originais das engines escolhidas.

Veredito: 5 (de 0 a 5)
Obrigatório: Sim

game-programming-patterns.jpg
 

Game Programming Patterns

Um outro livro também bastante citado, possui versão gratuita online. Também é usado como material fonte para os cursos que são dados no bladecast. Com uma abordagem parecida com o clássico livro de Design Patterns, este livro define e exemplifica diversas técnicas da programação de jogos que são bastante úteis em diversos tipos de jogos. Bastante didático e com vários diagramas, este livro pode ser lido e estudado do começo ao fim em um momento inicial para ser consultado inúmeras vezes em momentos futuros.

Veredito: 5 (de 0 a 5)
Obrigatório: Sim

Veredito: 0 (de 0 a 5)
Obrigatório: Não

 

O resto do artigo você pode conferir aqui: https://bladecast.pro/programacao/livros-essenciais-desenvolvimento-jogos

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar Agora

  • Conteúdo Similar

    • Por henriqueborba
      Olá Devs!
       
      Vim aqui compartilhar com vocês uma idéia que levou algum tempo para se concretizar e agora finalmente está se consolidando, gostaria de ouvir a opinião de vocês sobre o assunto e sobre a biblioteca em si, então vamos lá.
       
      O problema: PHP vs Mercado crescente de Machine de Learning
       
      Quando finalmente tive a oportunidade de me envolver com Big Data uma nova onda estava surgindo com muita intensidade: Inteligência Artificial. Não como aquelas complicadas e loucas que nós programadores sonhávamos em mexer como algo tão obscuro e complexo quanto o Assembly., mas algo prático, frameworks de inteligência artificial! Bibliotecas como Tensorflow, SKLearn e Keras estavam explodindo pela facilidade e pelos resultados alcançados. FINALMENTE! INTELIGÊNCIA ARTIFICIAL PRÁTICA E RÁPIDA DISPONÍVEL PARA QUALQUER UM.....que entendesse de python!
       
      O que me incomodava profundamente, era que o Python não era uma maravilha em velocidade. Ele é interpretado por um interpretador em C assim como o PHP, e pra muitas coisas (depois do PHP 7) chega a ser mais lento. Então porque o PHP tinha que ficar num mundinho separado de API's e o Python seria o mestre das resoluções de problemas complexos? Simplesmente por permitir aritmética de matrizes? Não, isso me incomodava muito. Então decidi olhar o código dessas bibliotecas em Python e analisar de cabeça aberta o que estava acontecendo ali.
       
      O Fator Comum
      Depois de analisar o código, percebi que existia uma coisa muito em comum entre essas bibliotecas em Python, uma coisa obscura até então para mim, chamada Numpy! Decidi então verificar porque esse termo "Numpy" ou "import numpy as np" estava tão presente nessas bibliotecas em Python.
       
      NumPy nada mais é que uma extensão para o Python escrita majoritariamente em C que utiliza um buffer em C e estruturas homogêneas em C para criar um novo tipo de Array para o python especializada em cálculos lineares e além disso permitir operações lineares especializadas (OpenBLAS, LAPACKE....).....pausa para respirar.
       
      A minha conclusão no momento foi: "Eu acho que isso é possível numa extensão em C para o PHP"
       
      O Desafio: C
      Depois de 12 anos desenvolvendo em linguagens como PHP, Java, Python, Ruby e até mesmo Pascal, toda aquela preocupação de alocação e memória vai para o ralo. A gente esquece de muitos fatores que influenciam a computação de algo e nos mergulhamos em abstrações maravilhosas como se fosse um paraíso. Esse sonho foi um pesadelo quando finalmente decidi começar a desenvolver algo como o NumPy mas para o PHP, não existe nada minimamente aplicável em C que não dependa de um malloc ou realloc, meu desafio nesse momento foi reaprender C.
       
      O que mais me surpreeendeu é que basicamente não existe documentação apropriada para extensões em PHP. Simplesmente você não vai encontrar nada atualizado e quando encontra é algo tão sintético que dificilmente vai te ajudar ou extremamente ultrapassado (PHP 5.6 e etc que não são mais compatíveis em C). A minha única idéia no momento foi entrar no GitHub e olhar o código das funções de array do próprio PHP 7 (array_sum, etc), elas estavam todas em um mesmo arquivo array.c e e então comecei a entender como as arrays eram tratadas internamente.
       
      As arrays no PHP são Hash Maps, não vamos entrar em detalhes técnicos mas são ótimas quando você precisa de armazenar vários tipos de dados diferentes em uma mesma estrutura, por exemplo, você pode armazenar um inteiro na posição 0 e uma objeto (classe) na posição 1. Essa liberdade tem um custo alto, porque afinal de contas você nunca se "especializa" em tudo e vou mostrar mais a frente que esse custo é alto!
       
      CArrays e o 7 andares do inferno
      Agora falando com vocês, foram 7 meses de pesquisa e muitos problemas, cheguei a jogar 4 versões da biblioteca no lixo (que chegavam a ter 20 mil linhas programadas do zero) e começar novamente a partir dos erros anteriores. As primeiras versões continham tantos erros de memória e "seg faults" que era impossível produzir algo razoável. No fim tudo compensou e estou postando isso um dia depois dos testes finais para a release da extensão CArray e da biblioteca PHPSci. 
       
      A Resolução
      Consegui finalmente criar um novo tipo de array para o PHP utilizando uma extensão. Eu chamo de CArray e ela utiliza 50% menos memória em média que uma array do PHP e realiza cálculos lineares (ex: produto de matrizes) 800 vezes mais rápido que a mesma implementeção utilizando apenas estruturas PHP, o código da pre-release pode ser encontrado aqui (https://github.com/phpsci/phpsci-ext). 
       
      As CArrays funcionam da seguinte forma, você cria uma a partir de uma array PHP ou utiliza um "initializer" (inicializador) para criar uma matriz, como no exemplo abaixo:
      $a = [[1, 2], [3, 4]]; $b = CArray::fromArray($a); $c = CArray::identity(100); No exemplo, $b se torna uma CArray a partir de $a e $c se torna uma CArray a partir do "inicializador" identity, que nada mais é que uma matriz identidade (com 0 em todos os valores e 1 na diagonal)k, você também pode utilizar diversos inicializadores como "zeros", "ones", "one_like", "zeros_like", "eye" e etc.
       
      Agora vamos dar um print_r na váriavel $b para vermos a matriz:
      print_r($b); O resultado será:
      CArray Object ( [uuid] => 0 [x] => 2 [y] => 2 ) Você deve estar se perguntando, cadê minha array? O print_r do PHP só funciona com objetos nativamente em PHP, um objeto CArray é apenas um ponteiro para uma posição da memória contendo uma matriz em C. Esse ponteiro é o parâmetro "uuid" da classe acima, o 0 significa que nossa array [[1, 2], [3, 4]] está na posição 0 do buffer. O X e Y são apenas as dimensões da sua matriz, que facilitam o acesso do tamanho da sua array sem a necessidade de uma chamada de método ou recálculo do tamanho (que numa matriz seriam no mínimo dois FOR).
       
      Para visualizar os valores da nossa CArray, vamos utilizar o ECHO ao invés do PRINT_R:
      echo $b; [ [1, 2] [3, 4] ] Dessa forma podemos ver que os valores são realmente armazenados, eles apenas não são mostrador pelo print_r porque o PHP não entende que existe um segundo buffer em C contendo esses valores. Você também pode utilizar o método estático toArray para converter sua array CArray para uma array PHP:
      $d = CArray::toArray($b); Pera, e a memória e o lixo desse buffer em C?
      Esse foi um dos problemas! Como fazer o PHP limpar o buffer em C após rodar o Garbage Collection? Imagine se o buffer fosse alocado infinitamente e nunca liberado, a biblioteca se tornaria impraticável, alocando memória até inevitavelmente explodir. Graças ao método __destruct do PHP, as CArrays não utilizadas no buffer em C são automaticamente limpas durante o Garbage Collection do C. Isso resultou em uma alocação de array 50% em média menor que a mesma array em PHP.
       
      E daí? Uma array em C vai me ajudar em que?
      Acontece que a biblioteca em si não apenas aloca valores em uma array em C, ela possui mais de 45 métodos de resolução de funções lineares e matemáticas, otimizadas com algoritmos como OpenBLAS e LAPACKE, o que basicamente é aquilo que bibliotecas de IA precisam! Não existe como ter uma biblioteca de Inteligência Artificial razoável se os seus cálculos em arrays são extremamente lentos. Os métodos são compatíveis com o NumPy exatamente para facilitar a integração e o aprendizado:
       
      $a = CArray::identity(1000); $b = CArray::identity(1000); $c = CArray::matmul($a, $b); O código acima utiliza um dos 40 métodos da biblioteca (matmul) para computar o produto das matrizes $a e $b. O formato das duas matrizes é (1000 linhas, 1000 colunas), isso significa que o produto delas em PHP puro utilizando FOR levaria mais 1 bilhao de iterações. Esse método é um dos que chega a ser 800 vezes mais rápido, ao utilizar apenas arrays em C ele não precisa se quer de se comunicar com o PHP e assim pode utilizar computação paralela e algoritmos especializados.
       
      O método matmul é apenas uma das diversas operações utilizadas em inteligência artificial, o CArray abre caminho para que isso seja aplicado de forma prática.
       
      Resultados com Machine Learning
      Agora estou reescrevendo o código do SKLearn do Python em PHP utilizando a extensão CArrray, vocês podem verificar essa biblioteca aqui: (https://github.com/phpsci/phpsci), o objetivo dela é oferecer aplicações práticas para a CArray, como por exemplo machine learning.
       
      O algoritmo que implementei até agora é um simples Naive Bayes para classificação. Na primeira versão ele já é 13 vezes mais rápido que o Naive Bayes do projeto PHP-ML que não utiliza extensões e utiliza 50% menos memória. A idéia é continuar expandido tanto os métodos da extensão CArray como suas aplicabilidades na biblioteca PHPSci além claro, de melhorar sua performance.
       
      Futuro: GPU
      A boa notícia é que como utilizo o OpenBLAS nas operações em C, os métodos mais importantes podem ser implementados utilizando a biblioteca CuBLAS, basicamente seria a mesma biblioteca CArray porém executando operações em GPU. Dá pra imaginar PHP fazendo cálculo em GPU? Isso vai acontecer jaja, pelo menos se depender da minha determinação na lib.
       
      É isso galera, volto aqui depois do lançamento e com a documentação pronta! Também vou mostrar como utilizar o PHPSci para aprendizado de máquina eficiente, sem ter que esperar horas mas poucos minutos ou segundos para um resultado.
       
      O Presente:
      Segue abaixo uma cópia do registro de métodos da CArray, dessa forma vocês conseguem enteder a abrangência da classe:
      // CARRAY ITERATOR PHP_ME(CArray, offsetUnset, arginfo_array_offsetGet, ZEND_ACC_PUBLIC) PHP_ME(CArray, offsetSet, arginfo_array_offsetSet, ZEND_ACC_PUBLIC) PHP_ME(CArray, offsetGet, arginfo_array_offsetGet, ZEND_ACC_PUBLIC) PHP_ME(CArray, offsetExists, arginfo_array_offsetGet, ZEND_ACC_PUBLIC) // PHP_ME(CArray, __construct, NULL, ZEND_ACC_PUBLIC) // RANGES SECTION PHP_ME(CArray, arange, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, linspace, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, logspace, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // ARITHMETIC PHP_ME(CArray, add, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, subtract, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // LOGARITHMS PHP_ME(CArray, log, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, log10, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, log2, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, log1p, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // TRANSFORMATIONS SECTION PHP_ME(CArray, transpose, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, atleast_1d, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, atleast_2d, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, unique, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, flatten, NULL, ZEND_ACC_PUBLIC) // EIGENVALUES PHP_ME(CArray, eig, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, eigvals, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // NORMS SECTION PHP_ME(CArray, norm, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // OTHERS SECTION PHP_ME(CArray, det, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, cond, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // PRODUCTS SECTION PHP_ME(CArray, matmul, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, inner, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, outer, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, inv, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, svd, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // SET ROUTINES PHP_ME(CArray, in1d, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // EQUATIONS SECTION PHP_ME(CArray, solve, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // MAGIC PROPERTIES PHP_ME(CArray, __get, phpsci_get_args, ZEND_ACC_PUBLIC) // CARRAY MEMORY MANAGEMENT SECTION PHP_ME(CArray, __destruct, NULL, ZEND_ACC_PUBLIC) // TRIGONOMETRIC PHP_ME(CArray, tan, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, cos, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, sin, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, arctan, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, arccos, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, arcsin, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // HYPERBOLIC PHP_ME(CArray, sinh, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, tanh, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, cosh, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // INITIALIZERS SECTION PHP_ME(CArray, identity, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, zeros, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, zeros_like, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, ones, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, ones_like, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, eye, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, full, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, full_like, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // BASIC OPERATIONS PHP_ME(CArray, sum, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, negative, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, multiply, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, divide, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, abs, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, absolute, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, square, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, all, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // SEARCH PHP_ME(CArray, search_keys, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, argmax, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // STATISTICS PHP_ME(CArray, amin, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, amax, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, mean, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, var, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // EXPONENTIAL PHP_ME(CArray, exp, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // CONVERT SECTION PHP_ME(CArray, toArray, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, fromArray, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, toDouble, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, fromDouble, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) // VISUALIZATION PHP_ME(CArray, print_r, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, __toString, NULL, ZEND_ACC_PUBLIC) // RANDOM SECTION PHP_ME(CArray, standard_normal, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, randn, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) PHP_ME(CArray, randint, NULL, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC) { NULL, NULL, NULL }  
      Limitações
      As CArrays possuem até 2 dimensões, ou seja, você pode construir um double, um vetor e uma matriz. Matrizes com N-dimensões serão implementadas na próxima "major version"  
    • Por Motta
      Obra de arte criada a partir de algoritmos vai a leilão na Christie's, em Nova York
    • Por Motta
      O preconceito também se aprende entre algoritmos
    • Por Motta
      http://norman-ai.mit.edu/
    • Por Priscila-pcs
      Galera,
       
      Estou precisando do livro : Usability Inspection Methods, alguém sabe onde posso encontrar, comprar? Jà tentei encontrar em vários lugares e nada.
       
      Obrigada!
×

Informação importante

Ao usar o fórum, você concorda com nossos Termos e condições.