De Wikipedia, la enciclopedia libre
Saltar a navegación Saltar a búsqueda

Julia
Lenguaje de programación Julia Logo.svg
ParadigmaMulti-paradigma : envío múltiple (paradigma primario), procedimental , funcional , meta , multietapa [1]
Diseñada porJeff Bezanson , Alan Edelman , Stefan Karpinski , Viral B. Shah
DesarrolladorJeff Bezanson , Stefan Karpinski , Viral B. Shah y otros colaboradores [2] [3]
Apareció por primera vez2012 ; Hace 9 años [4] ( 2012 )
Lanzamiento estable
1.6.0 [5] Edita esto en Wikidata / 24 de marzo de 2021 ; Hace 38 días y 1.7.0-DEV con actualizaciones diarias ( 24 de marzo de 2021 )
Disciplina de mecanografíaDinámico , [6] fuerte , [7] nominativo , paramétrico , opcional
Lenguaje de implementaciónJulia, C , C ++ , esquema , LLVM [8]
PlataformaNivel 1: x86-64 , IA-32 , ARM de 64 bits , GPU CUDA / Nvidia
Nivel 2: Windows de 32 bits (64 bits es el nivel 1)
Nivel 3: ARM de 32 bits , PowerPC , GPU AMD.
También tiene soporte para navegador web (para JavaScript y WebAssembly ) [9] y funciona en Android . Para obtener más detalles, consulte "plataformas compatibles" .
SOLinux , macOS , Windows y FreeBSD
LicenciaMIT (núcleo), [2] GPL v2 ; [8] [10] una opción de archivo MAKE omite las bibliotecas GPL [11]
Extensiones de nombre de archivo.jl
Sitio webJuliaLang.org
Influenciado por
  • C [4]
  • Dylan [12]
  • Lisp [4]
  • Lua [13]
  • Mathematica [4] (estrictamente su Wolfram Language [4] [14] )
  • MATLAB [4]
  • Perl [13]
  • Python [13]
  • R [4]
  • Rubí [13]
  • Esquema [15]

Julia es un lenguaje de programación dinámico de alto nivel y alto rendimiento . Si bien es un lenguaje de uso general y se puede usar para escribir cualquier aplicación, muchas de sus características son adecuadas para el análisis numérico y la ciencia computacional . [16] [17] [18] [19]

Los aspectos distintivos del diseño de Julia incluyen un sistema de tipos con polimorfismo paramétrico en un lenguaje de programación dinámico ; con el envío múltiple como su paradigma de programación central . Julia apoya concurrente , (componibles) paralelo y Distributed Computing (con o sin el uso de MPI [20] y o el / incorporado correspondiente [ aclaración necesaria ] [21] a " OpenMP al estilo de" hilos [22] ), y llamada directa de C y Fortranbibliotecas sin código de pegamento . Julia usa un compilador justo a tiempo (JIT) al que se hace referencia como " justo a tiempo " (JAOT) en la comunidad de Julia, ya que Julia compila todo el código (por defecto) en código de máquina antes de ejecutarlo. [23] [24]

Julia recolecta basura , [25] utiliza una evaluación ávida e incluye bibliotecas eficientes para cálculos de punto flotante , álgebra lineal , generación de números aleatorios y comparación de expresiones regulares . Hay muchas bibliotecas disponibles, incluidas algunas (por ejemplo, para transformaciones rápidas de Fourier ) que anteriormente se incluían con Julia y ahora están separadas. [26]

Varias herramientas de desarrollo admiten la codificación en Julia, como los entornos de desarrollo integrados (por ejemplo, Visual Studio Code de Microsoft , con extensiones disponibles que agregan compatibilidad con Julia a los IDE, por ejemplo, proporcionando soporte para depuración y linting [27] ); con herramientas integradas, por ejemplo, un perfilador (y soporte gráfico de llama disponible [28] [29] para el integrado), depurador, [30] y el paquete Rebugger.jl "admite depuración de ejecución repetida " [a] y más . [32]

Historia [ editar ]

El trabajo en Julia se inició en 2009, por Jeff Bezanson, Stefan Karpinski , Viral B. Shah y Alan Edelman , quienes se propusieron crear un lenguaje libre que fuera rápido y de alto nivel. El 14 de febrero de 2012, el equipo lanzó un sitio web con una publicación de blog que explica la misión del idioma. [33] En una entrevista con InfoWorld en abril de 2012, Karpinski dijo sobre el nombre "Julia": "En realidad, no hay una buena razón. Parecía un nombre bonito". [34] Bezanson dijo que eligió el nombre por recomendación de un amigo, [35] luego escribió más tarde que quizás Julia significa "El ceceo poco común de Jeff es automático". [36]

Desde el lanzamiento de 2012, la comunidad de Julia ha crecido y "Julia ha sido descargada por usuarios de más de 10,000 empresas", [37] con más de 25,000,000 descargas en febrero de 2021 , un 87% más en un año (otras estadísticas relacionadas con Julia hasta en un 113%), [38] y se utiliza en más de 1.500 universidades, [39] [40] [41] La conferencia académica JuliaCon para usuarios y desarrolladores de Julia se ha celebrado anualmente desde 2014 y los últimos años 2020 JuliaCon dando la bienvenida a más de 28,900 espectadores únicos. [42]

La versión 0.3 se lanzó en agosto de 2014, la versión 0.4 en octubre de 2015, la versión 0.5 en octubre de 2016, [43] y la versión 0.6 en junio de 2017. [44] Tanto Julia 0.7 (una versión útil para probar paquetes y para saber cómo actualizar ellos para 1.0 [45] ) y la versión 1.0 se lanzaron el 8 de agosto de 2018. El trabajo en Julia 0.7 fue una "gran empresa" (por ejemplo, debido a un "optimizador completamente nuevo"), y se realizaron algunos cambios en la semántica, por ejemplo, la iteración se simplificó la interfaz; [46] y la sintaxis cambió un poco (con la sintaxis ahora estable, y lo mismo para 1.xy 0.7).

El candidato de lanzamiento para Julia 1.0 (Julia 1.0.0-rc1) se lanzó el 7 de agosto de 2018, y la versión final un día después (y por ahora, Julia 1.0.x son las versiones más antiguas que aún se admiten, con soporte a largo plazo ( LTS); durante al menos un año). Julia 1.1 se lanzó en enero de 2019 con, por ejemplo, una nueva función de idioma de "pila de excepciones". Se esperan versiones de corrección de errores aproximadamente mensualmente, para 1.4.xy 1.0.xy Julia 1.0.1 hasta 1.0.5 han seguido ese programa. Julia 1.2 se lanzó en agosto de 2019 y tiene, por ejemplo, algo de soporte integrado para navegadores web (para probar si se ejecuta en JavaScript VM), [47]y Julia 1.5 en agosto de 2020 (y con ella las versiones de Julia 1.4.x, 1.3.x, 1.2.xy Julia 1.1.x ya no se mantienen). Julia 1.3 agregó, por ejemplo, un paralelismo de subprocesos múltiples componible y un sistema de artefactos binarios para los paquetes de Julia. [48]

Julia 1.4 permitió una mejor sintaxis para la indexación de matrices para manejar, por ejemplo , matrices basadas en 0 , con A[begin+1]para el segundo elemento de la matriz A. [49] También se cambió el modelo de memoria. [50] Versión menor 1.4.2 solucionada, por ejemplo, un problema de Zlib , duplicando la velocidad de descompresión. [51]

Julia 1.5 agrega soporte de depuración de grabación y reproducción , [52] para la herramienta rr de Mozilla . Es una gran versión, con un comportamiento modificado en el REPL (alcance flexible), el mismo que se usa en Jupyter , pero totalmente compatible con el código que no es REPL. La mayor parte de la API de subprocesos se marcó como estable, y con esta versión "los objetos inmutables arbitrarios, independientemente de si tienen campos que hacen referencia a objetos mutables o no, ahora se pueden asignar en pila", [53] reduciendo las asignaciones de montón, p.viewsya no están asignando. Todas las versiones han trabajado en el rendimiento, pero especialmente el trabajo en Julia 1.5 se centró en el rendimiento del llamado "tiempo hasta el primer gráfico", en general, la velocidad de compilación en sí (en contraposición al rendimiento del código generado), y agrega herramientas. para que los desarrolladores mejoren la carga de paquetes. [54] Julia 1.6 también mejora aún más dicho rendimiento.

Los paquetes que funcionan en Julia 1.0.x deberían funcionar en 1.1.xo más reciente, habilitado por la garantía de sintaxis compatible con versiones posteriores . Una excepción notable fueron las bibliotecas de interfaz de idiomas extranjeros como JavaCall.jl (para lenguajes JVM como Java o Scala ) y Rcall.jl ( lenguaje R ) debido a algunos cambios relacionados con subprocesos (en un momento en que todas las funciones de subprocesos en Julia estaban marcado experimental). [55] El problema fue especialmente complicado para la JVM de Java, ya que tiene algunas expectativas especiales sobre cómo se usa el espacio de direcciones de la pila . Se JULIA_ALWAYS_COPY_STACKSpublicó una solución alternativa para Julia 1.3.0, mientras que una solución completa para Java está pendiente y no tiene una fecha de vencimiento establecida. [56]Además, las versiones de JVM desde Java 11 no presentan este problema. [57] Julia 1.6 tenía una fecha de vencimiento que se pospuso hasta finales de 2020, [58] y Julia 1.7 está en desarrollo.

Julia 1.6 fue la versión más grande desde 1.0, más rápida en muchos frentes, por ejemplo, introdujo la precompilación paralela y la carga más rápida de paquetes, en algunos casos "50 veces más rápido en los tiempos de carga para grandes árboles de artefactos binarios", [59] y es probable que se convierta en el próxima versión de soporte a largo plazo (LTS) de Julia. El hito de 2.0 actualmente no tiene una fecha de vencimiento establecida. [60]

Julia 1.6.1 ha sido lanzada, y Julia 1.7 y 1.8 son los próximos hitos, con el primero previsto para el 30 de abril de 2021 [61] y a partir de Julia 1.7, el desarrollo de Julia ha vuelto a las versiones basadas en el tiempo . [62]

Usos notables [ editar ]

Julia ha atraído a algunos usuarios de alto perfil, desde el administrador de inversiones BlackRock , que lo usa para análisis de series de tiempo , hasta la aseguradora británica Aviva , que lo usa para cálculos de riesgo . En 2015, el Banco de la Reserva Federal de Nueva York usó a Julia para hacer modelos de la economía de los Estados Unidos, y señaló que el lenguaje hizo la estimación del modelo "aproximadamente 10 veces más rápido" que su implementación anterior de MATLAB . Los cofundadores de Julia establecieron Julia Computing en 2015 para brindar servicios de asistencia, capacitación y consultoría pagados a los clientes, aunque Julia sigue siendo de uso gratuito. En la conferencia JuliaCon [63] de 2017 , Jeffrey Regier, Keno Fischery otros anunciaron [64] que el proyecto Celeste [65] utilizó a Julia para lograr "un rendimiento máximo de 1,54  petaFLOPS utilizando 1,3 millones de hilos" [66] en 9300 nodos Knights Landing (KNL) de la supercomputadora Cori II (Cray XC40) (entonces Sexto ordenador más rápido del mundo). [67] Julia se une así a C, C ++ y Fortran como lenguajes de alto nivel en los que se han logrado cálculos petaFLOPS.

Tres de los cocreadores de Julia son los ganadores del Premio James H. Wilkinson de Software Numérico 2019 (otorgado cada cuatro años) "por la creación de Julia, un entorno innovador para la creación de herramientas de alto rendimiento que permitan el análisis y solución de problemas de ciencias computacionales ". [68] Además, Alan Edelman, profesor de matemáticas aplicadas en el MIT, ha sido seleccionado para recibir el premio Sidney Fernbach de la IEEE Computer Society de 2019 "por sus destacados avances en computación de alto rendimiento, álgebra lineal y ciencia computacional y por sus contribuciones a la Julia lenguaje de programación." [69]

Julia Computing y NVIDIA anuncian "la disponibilidad del lenguaje de programación Julia como un contenedor empaquetado previamente en el registro de contenedores NVIDIA GPU Cloud (NGC)" [70] con NVIDIA indicando "Implemente Julia fácilmente en x86 y arm [..] Julia ofrece un paquete para un ecosistema HPC integral que cubre el aprendizaje automático, la ciencia de datos, varios dominios científicos y visualización ". [71]

Además, "Julia fue seleccionada por Climate Modeling Alliance como el único lenguaje de implementación para su modelo climático global de próxima generación. Este proyecto multimillonario tiene como objetivo construir un modelo climático a escala terrestre que brinde información sobre los efectos y desafíos del cambio climático. " [70]

Julia es utilizada por la NASA [72] [73] y el INPE brasileño para la planificación de misiones espaciales y la simulación de satélites . [74] Otro esfuerzo está trabajando en un proyecto integrado para controlar un satélite en el espacio usando Julia para el control de actitud . [ cita requerida ]

Patrocinadores [ editar ]

El lenguaje de Julia se convirtió en un proyecto patrocinado por NumFOCUS Fiscalmente en 2014 en un esfuerzo por garantizar la sostenibilidad del proyecto a largo plazo. [75] El Dr. Jeremy Kepner del MIT Lincoln Laboratory fue el patrocinador fundador del proyecto Julia en sus inicios. Además, los fondos de la Fundación Gordon y Betty Moore , la Fundación Alfred P. Sloan , Intel y agencias como NSF , DARPA , NIH , NASA y FAA han sido esenciales para el desarrollo de Julia. [76] Mozilla, el fabricante del navegador web Firefox, con sus becas de investigación para el primer semestre de 2019, patrocinó a "un miembro del equipo oficial de Julia" para el proyecto "Bringing Julia to the Browser", [77] es decir, para Firefox y otros navegadores web. [78] [79] [80] [81]

Julia Computing [ editar ]

Julia Computing, Inc. fue fundada en 2015 por Viral B. Shah, Deepak Vinchhi, Alan Edelman, Jeff Bezanson, Stefan Karpinski y Keno Fischer . [82]

En junio de 2017, Julia Computing recaudó $ 4.6  millones en fondos semilla de General Catalyst y Founder Collective , [83] y en el mismo mes recibió $ 910,000 de la Fundación Alfred P. Sloan para apoyar el desarrollo de código abierto de Julia, incluidos $ 160,000 para promover diversidad en la comunidad de Julia " [84] y en diciembre de 2019 la empresa obtuvo una  financiación de 1,1 millones de dólares del gobierno de EE. UU. para" desarrollar una herramienta de aprendizaje automático de componentes neuronales para reducir el consumo total de energía de los sistemas de calefacción, ventilación y aire acondicionado (HVAC) en edificios ". [85]

Funciones de idioma [ editar ]

Julia es un lenguaje de programación de propósito general , [86] aunque originalmente también fue diseñado para computación numérica / técnica. También es útil para la programación de sistemas de bajo nivel , [87] como lenguaje de especificación , [88] y para la programación web tanto en el lado del servidor [89] [90] como del cliente [91] [9] .

Según el sitio web oficial, las principales características del idioma son:

  • Despacho múltiple : brinda la capacidad de definir el comportamiento de la función en muchas combinaciones de tipos de argumentos
  • Sistema de tipos dinámicos : tipos para documentación, optimización y despacho.
  • Rendimiento cercano al de lenguajes de tipado estático como C
  • Un administrador de paquetes integrado
  • Macros similares a Lisp y otras instalaciones de metaprogramación
  • Llame a las funciones de C directamente: sin envoltorios ni API especiales
  • Capacidad para interactuar con otros lenguajes, por ejemplo, Python con PyCall, [b] R con RCall y Java / Scala con JavaCall
  • Potentes habilidades similares a un caparazón para administrar otros procesos
  • Diseñado para computación distribuida y paralela
  • Coroutines : roscado verde ligero
  • Los tipos definidos por el usuario son tan rápidos y compactos como los integrados
  • Generación automática de código especializado y eficiente para diferentes tipos de argumentos
  • Conversiones y promociones elegantes y extensibles para numéricos y otros tipos
  • Soporte eficiente para Unicode , incluido, entre otros, UTF-8

El envío múltiple (también denominado métodos múltiples en Lisp) es una generalización del envío único  , el mecanismo polimórfico utilizado en los lenguajes comunes de programación orientada a objetos (OOP), que utiliza la herencia . En Julia, todos los tipos concretos son subtipos de tipos abstractos, subtipos directa o indirectamente del tipo Any , que es la parte superior de la jerarquía de tipos. Los tipos concretos no pueden subtipificarse en sí mismos como en otros idiomas; en su lugar, se usa composición (ver también herencia vs subtipificación ).

Julia se inspira significativamente en varios dialectos de Lisp, incluidos Scheme y Common Lisp , y comparte muchas características con Dylan , también un lenguaje dinámico orientado a múltiples despachos (que presenta una sintaxis infija de forma libre similar a ALGOL en lugar de Lisp) como sintaxis de prefijo, mientras que en Julia "todo" [95] es una expresión ), y con Fortress , otro lenguaje de programación numérico (que cuenta con envío múltiple y un sofisticado sistema de tipos paramétricos). Si bien Common Lisp Object System (CLOS) agrega múltiples despachos a Common Lisp, no todas las funciones son funciones genéricas.

En Julia, Dylan y Fortress, la extensibilidad es la predeterminada y las funciones integradas del sistema son todas genéricas y extensibles. En Dylan, el envío múltiple es tan fundamental como en Julia: todas las funciones definidas por el usuario e incluso las operaciones integradas básicas como +son genéricas. El sistema de tipos de Dylan, sin embargo, no es totalmente compatible con los tipos paramétricos, que son más típicos del linaje de lenguajes ML . Por defecto, CLOS no permite el envío de tipos paramétricos de Common Lisp; dicha semántica de despacho extendida solo se puede agregar como una extensión a través del Protocolo de metaobjetos CLOS. Por su diseño convergente, Fortress también presenta múltiples despachos en tipos paramétricos; Sin embargo, a diferencia de Julia, Fortress se escribe estáticamente en lugar de dinámicamente, con fases de compilación y ejecución separadas. Las características del idioma se resumen en la siguiente tabla:

IdiomaTipo de sistemaFunciones genéricasTipos paramétricos
JuliaDinámicaDefectosí
Lisp comúnDinámicaOptar enSí (pero no envío)
DylanDinámicaDefectoParcial (sin envío)
FortalezaEstáticoDefectosí

De forma predeterminada, el tiempo de ejecución de Julia debe estar preinstalado a medida que se ejecuta el código fuente proporcionado por el usuario. Alternativamente, un ejecutable independiente que no necesita código fuente de Julia se puede construir con PackageCompiler.jl . [96]

Las macros sintácticas de Julia (utilizadas para la metaprogramación ), como las macros Lisp, son más poderosas que las macros de sustitución de texto utilizadas en el preprocesador de algunos otros lenguajes como C, porque funcionan al nivel de árboles de sintaxis abstracta (AST). El sistema de macros de Julia es higiénico , pero también admite la captura deliberada cuando se desea (como para las macros anafóricas ) utilizando la escconstrucción.

Interacción [ editar ]

La distribución oficial de Julia incluye un bucle interactivo de lectura-evaluación-impresión de línea de comandos (REPL), [97] con un historial de búsqueda, finalización de tabulación y modos de ayuda y shell dedicados , [98] que se pueden usar para experimentar y probar codificar rápidamente. [99] El siguiente fragmento representa un ejemplo de sesión de muestra donde las cadenas se concatenan automáticamente por println: [100]

julia>  p ( x )  =  2 x ^ 2  +  1 ;  f ( x ,  y )  =  1  +  2 p ( x ) y julia>  println ( "¡Hola, mundo!" ,  "Estoy en la nube" ,  f ( 0 ,  4 ),  "¡ya que Julia admite sintaxis reconocible!" ) Hola ¡mundo! ¡Estoy en la nube 9 ya que Julia admite una sintaxis reconocible!

El REPL brinda al usuario acceso al shell del sistema y al modo de ayuda, presionando ;o ?después del indicador (que precede a cada comando), respectivamente. También mantiene el historial de comandos, incluso entre sesiones. [101] Código que puede probarse dentro de la sección interactiva de Julia o guardarse en un archivo con una .jlextensión y ejecutarse desde la línea de comandos escribiendo: [95]

$ julia <nombre de archivo>

Julia es compatible con Jupyter , un entorno de "cuadernos" interactivos en línea, [102] y Pluto.jl , un " cuaderno reactivo " (donde los cuadernos se guardan como archivos de Julia puros), un posible reemplazo del tipo anterior. [103]

Usar con otros idiomas [ editar ]

En la práctica, Julia es interoperable con muchos idiomas (por ejemplo, la mayoría de los 10-20 idiomas principales de uso popular). La ccallpalabra clave de Julia se usa para llamar a funciones de biblioteca compartida C-exported o Fortran individualmente, y paquetes para permitir llamar a otros lenguajes, por ejemplo, Python, R, MATLAB, Java o Scala. [104] Y paquetes para otros lenguajes, por ejemplo, Python (o R o Ruby), es decir, pyjulia, para llamar a Julia.

Julia tiene soporte para el último Unicode 13.0, [105] con UTF-8 usado para cadenas (por defecto) y para el código fuente de Julia (solo permite UTF-8 legal en la última versión), lo que significa que también permite como opción símbolos matemáticos comunes para muchos operadores, como ∈ para el inoperador.

Julia tiene paquetes que admiten lenguajes de marcado como HTML (y también para HTTP ), XML , JSON y BSON , y para bases de datos y uso web en general.

Sistema de paquetes [ editar ]

Julia tiene un administrador de paquetes integrado e incluye un sistema de registro predeterminado. [106] Los paquetes se distribuyen con mayor frecuencia como código fuente alojado en GitHub , aunque también se pueden utilizar alternativas. Los paquetes también se pueden instalar como binarios, utilizando artefactos. [107] El administrador de paquetes de Julia se utiliza para consultar y compilar paquetes, así como para administrar entornos. Se admiten registros de paquetes federados, lo que permite agregar localmente registros distintos del oficial. [108]

Usos [ editar ]

Julia se ha utilizado para realizar computación a petasescala con la biblioteca Celeste para estudios del cielo . [109] [110] Julia es utilizada por las plataformas analíticas de BlackRock Engineering [111] .

Implementación [ editar ]

El núcleo de Julia está implementado en Julia y C , junto con C ++ para la dependencia LLVM . El análisis sintáctico y la reducción de código se implementan en FemtoLisp, un dialecto de Scheme . [112] El proyecto de infraestructura del compilador LLVM se utiliza como back-end para la generación de código de máquina optimizado de 64 o 32 bits , según la plataforma en la que se ejecute Julia. Con algunas excepciones (p. Ej., PCRE ), la biblioteca estándarse implementa en Julia. El aspecto más notable de la implementación de Julia es su velocidad, que a menudo está dentro de un factor de dos en relación con el código C totalmente optimizado (y, por lo tanto, a menudo un orden de magnitud más rápido que Python o R ). [113] [114] [115] El desarrollo de Julia comenzó en 2009 y una versión de código abierto se publicó en febrero de 2012. [4] [116]

Plataformas actuales y futuras [ editar ]

Si bien Julia tiene compatibilidad con macOS de nivel 1, es decir, para Mac basadas en Intel, la compatibilidad con las nuevas Mac basadas en Apple M1 no se especifica explícitamente (y tampoco para Windows en ARM ). [117] Sin embargo, se afirma que Julia trabaja; [118] "ok" (en rendimiento reducido) con Rosetta 2 (que necesita emular a Julia). El trabajo en el soporte nativo de M1 de velocidad completa (es decir, sin emulación) se realiza principalmente, y muchos programas pueden funcionar si se usa una compilación de Julia, ya que todas las pruebas de Julia menos una pasan (excepto "Demasiados archivos abiertos").

Dado que Julia usa JIT, Julia genera código de máquina nativo directamente, antes de que se ejecute una función por primera vez (es decir, un enfoque diferente a la compilación del código de bytes , que usted distribuye de forma predeterminada, para ejecutarse en una máquina virtual (VM), como por ejemplo, Java / JVM ; luego se traduce del código de bytes mientras se ejecuta, como lo hizo Dalvik en versiones anteriores de Android).

Julia tiene cuatro niveles de apoyo. [119] Se admiten todos los procesadores IA-32 que implementan completamente la subarquitectura i686 y se admiten x86-64 de 64 bits (también conocido como amd64 ), con menos de una década de antigüedad. Los procesadores ARMv8 ( AArch64 ) son totalmente compatibles en el primer nivel, y ARMv7 y ARMv6 (AArch32) son compatibles con algunas advertencias (nivel inferior) para Julia 1.0.xy también tenían ejecutables oficiales para versiones posteriores, mientras que la compatibilidad con ARM de 32 bits fue posterior degradado al nivel 3 (sin embargo, hay binarios no oficiales disponibles para Julia 1.5.1 [120] ). [121] CUDA (es decir, GPU Nvidia; implementación de PTX) tiene soporte de nivel 1, con la ayuda de un paquete externo. También hay paquetes adicionales que admiten otros aceleradores, como las TPU de Google , [122] y las GPU de AMD también son compatibles, por ejemplo, con OpenCL ; y soporte experimental para la pila AMD ROCm . [123] La página de descargas de Julia proporciona ejecutables (y fuente) para todas las plataformas oficialmente soportadas.

En algunas plataformas, es posible que Julia deba compilarse a partir del código fuente (por ejemplo, la Raspberry Pi original ), con opciones de compilación específicas, lo cual se ha hecho y hay disponibles binarios preconstruidos no oficiales (e instrucciones de compilación). [124] [125] Julia se ha construido sobre varias plataformas ARM. PowerPC (64 bits) tiene soporte de nivel 3, lo que significa que "puede compilarse o no". Julia ahora es compatible con Raspbian [126] mientras que el soporte es mejor para los nuevos Pis, por ejemplo, aquellos con ARMv7 o más nuevos; el soporte de Julia es promovido por la Fundación Raspberry Pi . [127]

También hay soporte para navegadores web / JavaScript a través de JSExpr.jl; [91] y el lenguaje alternativo de los navegadores web, WebAssembly , tiene un soporte mínimo [9] para varios proyectos externos futuros de Julia. Julia puede compilar en ARM; por lo tanto, en teoría, las aplicaciones de Android se pueden crear con el NDK , pero por ahora Julia se ha hecho para que se ejecute en Android solo de forma indirecta, es decir , con un chroot de Ubuntu en Android. [128]

Ver también [ editar ]

  • Comparación de software de análisis numérico
  • Comparación de paquetes estadísticos
  • Programación diferenciable

Notas [ editar ]

  1. ^ [Con Rebugger.jl] puedes:
    • pruebe diferentes modificaciones al código o argumentos tantas veces como desee; nunca se ve obligado a salir del "modo de depuración" y guardar su archivo
    • ejecutar el mismo bloque de código elegido repetidamente (quizás probando diferentes formas de corregir un error) sin necesidad de repetir el trabajo de "configuración" que podría haber sido necesario para llegar a algún método profundamente anidado en la pila de llamadas original. [31]
  2. ^ Para llamar al Python 3 más nuevo (el valor predeterminado anterior para llamar a Python 2, todavía es compatible) [92] [93] y llamar en la otra dirección, de Python a Julia, también es compatible con pyjulia . [94]

Referencias [ editar ]

  1. ^ "Suavizar datos con funciones @generadas de Julia" . 5 de noviembre de 2015 . Consultado el 9 de diciembre de 2015 . Las funciones generadas por Julia están estrechamente relacionadas con el paradigma de programación multietapa (MSP) popularizado por Taha y Sheard, que generaliza las etapas de tiempo de compilación / tiempo de ejecución de la ejecución del programa al permitir múltiples etapas de ejecución retrasada del código.
  2. ^ a b "LICENCIA.md" . GitHub .
  3. ^ "Colaboradores de JuliaLang / julia" . GitHub .
  4. ^ a b c d e f g h "Por qué creamos a Julia" . Sitio web de Julia . Febrero de 2012 . Consultado el 7 de febrero de 2013 .
  5. ^ "Descargar Julia (inglés)" . Consultado el 25 de marzo de 2021 .
  6. ^ Engheim, Erik (17 de noviembre de 2017). "Los idiomas escritos dinámicamente no son lo que piensas" . Medio . Consultado el 27 de enero de 2021 .
  7. ^ "¿Julia está fuertemente marcada (escrita)?" . JuliaLang . El 7 de agosto de 2018 . Consultado el 27 de enero de 2021 .
  8. ^ a b "Julia" . Julia . Proyecto NumFocus . Consultado el 9 de diciembre de 2016 . La biblioteca Base de Julia, escrita en gran parte en la propia Julia, también integra las mejores bibliotecas C y Fortran de código abierto maduras y mejores para ...
  9. ↑ a b c Fischer, Keno (22 de julio de 2019). "Ejecutando julia en wasm" . Consultado el 25 de julio de 2019 .
  10. ^ "¿Julia no GPL?" . Groups.google.com . Consultado el 31 de mayo de 2017 .
  11. ^ "Introduzca el indicador USE_GPL_LIBS Makefile para construir Julia sin bibliotecas GPL" . Tenga en cuenta que esta confirmación no elimina las utilidades GPL como git y busybox que se incluyen en los instaladores binarios de Julia en Mac y Windows. Permite construir desde el código fuente sin dependencias de la biblioteca GPL.
  12. ^ Stokel-Walker, Chris. "Julia: El lenguaje Ricitos de Oro" . Incremento . Raya . Consultado el 23 de agosto de 2020 .
  13. ^ a b c d "Inicio · La lengua de Julia" . docs.julialang.org . Consultado el 15 de agosto de 2018 .
  14. ^ "Red de lenguajes de programación" . GitHub . Consultado el 6 de diciembre de 2016 .
  15. ^ "JuliaCon 2016" . JuliaCon . Consultado el 6 de diciembre de 2016 . Ha codiseñado el lenguaje de programación Scheme, que ha influido mucho en el diseño de Julia.
  16. ^ Bryant, Avi (15 de octubre de 2012). "Matlab, R y Julia: lenguajes para el análisis de datos" . O'Reilly Strata. Archivado desde el original el 26 de abril de 2014.
  17. ^ Singh, Vicky (23 de agosto de 2015). "Lenguaje de programación Julia - una verdadera alternativa a Python" . Technotification.
  18. ^ Krill, Paul (18 de abril de 2012). "El nuevo lenguaje de Julia busca ser la C de los científicos" . InfoWorld .
  19. ^ Finley, Klint (3 de febrero de 2014). "A la intemperie: el hombre crea un lenguaje de programación para gobernarlos a todos" . Cableado .
  20. ^ "GitHub - JuliaParallel / MPI.jl: envoltorios MPI para Julia" . Julia paralela . Consultado el 22 de septiembre de 2019 .
  21. ^ "Preguntas sobre cómo empezar con la computación paralela" . JuliaLang . 16 de junio de 2019 . Consultado el 8 de octubre de 2019 .
  22. ^ "Julia y concurrencia" . JuliaLang . 24 de junio de 2019 . Consultado el 22 de septiembre de 2019 .
  23. ^ Fischer, Keno; Nash, Jameson. "Hacer crecer un compilador: llegar al aprendizaje automático desde un compilador de propósito general" . Blog de Julia Computing . Consultado el 11 de abril de 2019 .
  24. ^ "Creación de una imagen del sistema" . Documentación de PackageCompiler .
  25. ^ "Suspensión de la recolección de basura por rendimiento ... ¿buena idea o mala idea?" . Groups.google.com . Consultado el 31 de mayo de 2017 .
  26. ^ ahora disponibleen las versiones actuales (esa dependencia es una de las muchas que se movió de la biblioteca estándar a un paquete porque tiene licencia GPL y, por lo tanto, no está incluida en Julia 1.0 de forma predeterminada). "Elimine los enlaces FFTW desde Base por ararslan · Pull Request # 21956 · JuliaLang / julia " . GitHub . Consultado el 1 de marzo de 2018 .using FFTW
  27. ^ "ANN: complemento linter-julia para Atom / Juno" . JuliaLang . 15 de febrero de 2017 . Consultado el 10 de abril de 2019 .
  28. ^ Holy, Tim (13 de septiembre de 2019). "GitHub - timholy / ProfileView.jl: visualización de datos de perfiles de Julia" . Consultado el 22 de septiembre de 2019 .
  29. ^ Gregg, Brendan (20 de septiembre de 2019). "GitHub - brendangregg / FlameGraph: visualizador de seguimiento de pila" . Consultado el 22 de septiembre de 2019 .
  30. ^ "Un intérprete y depurador de Julia" . julialang.org . Consultado el 10 de abril de 2019 .
  31. ^ "[ANN] Rebugger: depuración interactiva para Julia 0.7 / 1.0" . JuliaLang . 21 de agosto de 2018 . Consultado el 10 de abril de 2019 .
  32. ^ "Inicio · Rebugger.jl" . timholy.github.io . Consultado el 10 de abril de 2019 .
  33. ↑ Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman. "Por qué creamos a Julia" . JuliaLang.org . Consultado el 5 de junio de 2017 .Mantenimiento de CS1: utiliza el parámetro de autores ( enlace )
  34. ^ Karpinski, Stefan (18 de abril de 2012). "El nuevo lenguaje de Julia busca ser la C de los científicos" . InfoWorld .
  35. ^ Torre, Charles. "Stefan Karpinski y Jeff Bezanson sobre Julia" . Canal 9 . MSDN . Consultado el 4 de diciembre de 2018 .
  36. ^ Bezanson, Jeff. "CAS Benchmarks" . discurso.julialang.org . Julia . Consultado el 2 de abril de 2021 .
  37. ^ "Boletín de agosto de 2020" . juliacomputing.com . 14 de agosto de 2020 . Consultado el 7 de septiembre de 2020 .
  38. ^ "Boletín de enero de 2021 - Julia Computing" . juliacomputing.com . Consultado el 13 de enero de 2021 .
  39. ^ "Computación de Julia" . juliacomputing.com . Consultado el 12 de agosto de 2020 .
  40. ^ "Boletín de noviembre de 2019" . juliacomputing.com . 7 de noviembre de 2019 . Consultado el 29 de noviembre de 2019 .
  41. ^ "Boletín de Julia Computing, métricas de crecimiento" . juliacomputing.com . Consultado el 11 de febrero de 2019 .
  42. ^ "Resumen de JuliaCon 2020" . julialang.org . 11 de agosto de 2020 . Consultado el 20 de diciembre de 2020 .
  43. ^ "El Blog de Julia" .
  44. ^ "Anuncio de lanzamiento de Julia 0.6" .
  45. ^ "¿Qué es Julia 0.7? ¿Cómo se relaciona con 1.0?" . JuliaLang . Consultado el 17 de octubre de 2018 .
  46. ^ Davies, Eric. "Escribiendo iteradores en Julia 0.7" . julialang.org . Consultado el 5 de agosto de 2018 .
  47. ^ "Sys.isjsvm ([os])" . El lenguaje de Julia. 20 de agosto de 2019 . Consultado el 20 de agosto de 2019 . Predicado para probar si Julia se está ejecutando en una máquina virtual de JavaScript (JSVM), incluida, por ejemplo, una incorporación de JavaScript de WebAssembly en un navegador web.
  48. ^ Bezanson, Jeff; Karpinski, Stefan; Shah, viral; Edelman, Alan. "La lengua de Julia" . julialang.org . Consultado el 13 de diciembre de 2019 .
  49. ^ "admite un [comienzo] para un [primer índice (a)] por stevengj · Pull Request # 33946 · JuliaLang / julia" . GitHub . Consultado el 7 de abril de 2020 .
  50. ^ quinnj. "Para estructuras con todos los campos isbits o isbitsunion, permita que se almacenen en línea en matrices · Pull Request # 32448 · JuliaLang / julia" . GitHub . Consultado el 7 de abril de 2020 . Sigo teniendo problemas que esto causa internamente porque fue un cambio importante que cambia las suposiciones hechas por algunos usuarios y la inferencia / codegen.
  51. ^ "Lanzamiento de Bump Zlib BB a 'v1.2.11 + 10' que habilita la optimización '-O3' por giordano · Pull Request # 35979 · JuliaLang / julia" . GitHub . Consultado el 25 de mayo de 2020 .
  52. ^ Fischer, Keno (2 de mayo de 2020). "Próximamente en Julia 1.5: informe de errores de viaje en el tiempo (Linux)" . julialang.org . Consultado el 5 de mayo de 2020 . La sobrecarga para el registro de procesos de un solo subproceso es generalmente inferior a 2x, con mayor frecuencia entre 2% y 50% (menor para cálculos puramente numéricos, mayor para cargas de trabajo que interactúan con el sistema operativo). La grabación de múltiples subprocesos o procesos que comparten memoria (a diferencia de usar el paso de mensajes basado en el kernel) es más difícil. [..] Como era de esperar, la prueba de subprocesos es la peor infractora con un 600% de sobrecarga.
  53. ^ Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman et al. "La lengua de Julia" . julialang.org . Consultado el 14 de agosto de 2020 . Existen algunos límites basados ​​en el tamaño a los que se pueden asignar las estructuras en pila, pero es poco probable que se excedan en la práctica.CS1 maint: uses authors parameter (link)
  54. ^ Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman et al. "La lengua de Julia" . julialang.org . Consultado el 16 de septiembre de 2020 .CS1 maint: uses authors parameter (link)
  55. ^ "Solución de problemas de comprobación de pila C en 1.1 por simonbyrne · Solicitud de extracción # 293 · JuliaInterop / RCall.jl" . GitHub . Consultado el 10 de agosto de 2019 .
  56. ^ "JVM no se puede cargar en 1.1 (JavaCall.jl) · Edición # 31104 · JuliaLang / julia" . GitHub . Consultado el 18 de agosto de 2019 . JeffBezanson modificó los hitos: 1.3, 1.4
  57. ^ "StackOverflowError en 'JavaCall.init' para Julia 1.1.0 · Número 96 · JuliaInterop / JavaCall.jl" . GitHub . Consultado el 21 de octubre de 2019 .
  58. ^ "JuliaLang / julia" . GitHub . Consultado el 7 de enero de 2021 .
  59. ^ Jeff Bezanson, Stefan Karpinski, Viral Shah, Alan Edelman et al. "Aspectos destacados de Julia 1.6" . julialang.org . Consultado el 26 de marzo de 2021 .CS1 maint: uses authors parameter (link)
  60. ^ "Hitos - JuliaLang / julia" . El lenguaje de Julia . Consultado el 13 de diciembre de 2019 .
  61. ^ "JuliaLang / julia" . GitHub . Consultado el 26 de abril de 2021 .
  62. ^ "Actualización a OpenBLAS 0.3.13 por omus · Pull Request # 39216 · JuliaLang / julia" . GitHub . Consultado el 26 de abril de 2021 . Dado que 1.7 no está demasiado lejos (lanzamientos programados en el futuro)
  63. ^ "JuliaCon 2017" . juliacon.org . Consultado el 4 de junio de 2017 .
  64. ^ Fisher, Keno. "El Proyecto Celeste" . juliacon.org . Consultado el 24 de junio de 2017 .
  65. ^ Regier, Jeffrey; Pamnany, Kiran; Giordano, Ryan; Thomas, Rollin; Schlegel, David; McAulife, Jon; Prabat (2016). "Aprendizaje de un catálogo astronómico del universo visible a través de inferencia bayesiana escalable". arXiv : 1611.03404 [ cs.DC ].
  66. ^ Claster, Andrew (12 de septiembre de 2017). "Julia se une al club Petaflop" . Julia Computing (Comunicado de prensa). Celeste está escrito íntegramente en Julia, y el equipo de Celeste cargó un total de 178 terabytes de datos de imágenes para producir el catálogo más preciso de 188 millones de objetos astronómicos en solo 14,6 minutos [..] una mejora de rendimiento de 1000x en ejecución de un solo subproceso .
  67. ^ Shah, Viral B. (15 de noviembre de 2017). "Viral B. Shah en Twitter" . Consultado el 15 de septiembre de 2019 . @KenoFischer está hablando sobre Celeste en el teatro @Intel en @Supercomputing. 0,65 millones de núcleos, 56 TB de datos, Cori: la sexta supercomputadora más grande del mundo.
  68. ^ "Los co-creadores de la lengua de Julia ganan el premio James H. Wilkinson de software numérico" . Noticias del MIT . Consultado el 22 de enero de 2019 .
  69. ^ "Alan Edelman del MIT reconocido con el prestigioso premio Sidney Fernbach de la IEEE Computer Society de 2019 | IEEE Computer Society" (Comunicado de prensa). 1 de octubre de 2019 . Consultado el 9 de octubre de 2019 .
  70. ^ a b "Julia Computing y NVIDIA llevan a Julia GPU Computing a armar" . juliacomputing.com . 3 de diciembre de 2019 . Consultado el 3 de diciembre de 2019 .
  71. ^ Patel, Chintan (19 de noviembre de 2019). "NVIDIA amplía el soporte para Arm con HPC, AI, contenedores de visualización en NGC | Blog de NVIDIA" . El blog oficial de NVIDIA . Consultado el 3 de diciembre de 2019 .
  72. ^ Circuitscape / Circuitscape.jl , Circuitscape, 25 de febrero de 2020 , consultado el 26 de mayo de 2020
  73. ^ "Conservación a través de la codificación: 5 preguntas con Shah viral | Dirección de misión científica" . science.nasa.gov . Consultado el 26 de mayo de 2020 .
  74. ^ JuliaSpace / SatelliteToolbox.jl , JuliaSpace, 20 de mayo de 2020 , consultado el 26 de mayo de 2020
  75. ^ "Julia: Proyecto patrocinado por NumFOCUS desde 2014" . numfocus.org . Consultado el 29 de septiembre de 2020 .
  76. ^ "La lengua de Julia" . julialang.org . Consultado el 22 de septiembre de 2019 .
  77. ^ Cimpanu, Catalin. "Mozilla está financiando una forma de apoyar a Julia en Firefox" . ZDNet . Consultado el 22 de septiembre de 2019 .
  78. ^ "Julia en yoduro" . alpha.iodide.io . Consultado el 22 de septiembre de 2019 .
  79. ^ "Complementos de idioma - Documentación de yoduro" . iodide-project.github.io . Consultado el 22 de septiembre de 2019 .
  80. ^ "Mozilla Research Grants 2019H1" . Mozilla . Consultado el 22 de septiembre de 2019 . ejecutar intérpretes de idiomas en WebAssembly. Para aumentar aún más el acceso a las principales herramientas de ciencia de datos, estamos buscando a alguien que transfiera R o Julia a WebAssembly e intente proporcionar un complemento de lenguaje de nivel 3 para Iodide: conversión automática de tipos básicos de datos entre R / Julia y Javascript, y la capacidad de compartir instancias de clases entre R / Julia y Javascript.
  81. ^ "Computación científica alfabetizada y comunicación para la web: yoduro-proyecto / yoduro" . yoduro. 20 de septiembre de 2019 . Consultado el 22 de septiembre de 2019 . Imaginamos un flujo de trabajo futuro que le permita hacer su intercambio de datos en Python, ajustar un modelo rápido en R o JAGS, resolver algunas ecuaciones diferenciales en Julia y luego mostrar sus resultados con una visualización interactiva en vivo de d3 + JavaScript ... y todo que dentro de un archivo único, portátil, que se puede compartir y que se puede piratear.
  82. ^ "Acerca de nosotros - Julia Computing" . juliacomputing.com . Consultado el 12 de septiembre de 2017 .
  83. ^ "Julia Computing recauda 4,6 millones de dólares en financiación inicial" . Archivado desde el original el 10 de mayo de 2019.
  84. ^ "Julia Computing otorgó una subvención de $ 910,000 por la Fundación Alfred P. Sloan, incluidos $ 160,000 para la diversidad STEM" . juliacomputing.com . 26 de junio de 2017 . Consultado el 28 de julio de 2020 .
  85. ^ "DIFERENCIAR: inteligencia de diseño que fomenta una formidable reducción de energía (y) que permite nuevas mejoras tecnológicas avanzadas totalmente impactantes" (PDF) .
  86. ^ "The Julia Language" (sitio web oficial). Propósito general [..] Julia le permite escribir interfaces de usuario, compilar estáticamente su código o incluso implementarlo en un servidor web.
  87. ^ Green, Todd (10 de agosto de 2018). "Programación de sistemas de bajo nivel en Julia de alto nivel" . Archivado desde el original el 5 de noviembre de 2018 . Consultado el 5 de noviembre de 2018 .
  88. ^ Moss, Robert (26 de junio de 2015). "Uso de Julia como lenguaje de especificación para el sistema de prevención de colisiones aerotransportadas de próxima generación" (PDF) . Archivado desde el original el 1 de julio de 2015 . Consultado el 29 de junio de 2015 . Sistema de prevención de colisiones aerotransportadas
  89. ^ Anaya, Richard (28 de abril de 2019). "Cómo crear un servidor HTTP multiproceso en Julia" . Medio . Consultado el 25 de julio de 2019 . En resumen, aunque Julia carece de una solución de servidor de subprocesos múltiples actualmente lista para usar, podemos aprovechar fácilmente sus características de distribución de procesos y una tecnología de equilibrio de carga muy popular para obtener el uso completo de la CPU para el manejo de HTTP.
  90. ^ Anthoff, David (1 de junio de 2019). "Instalación de Node.js para julia" . Consultado el 25 de julio de 2019 .
  91. ^ a b "Traducir Julia a JavaScript" . JuliaGizmos. El 7 de julio de 2019 . Consultado el 25 de julio de 2019 .
  92. ^ "PyCall.jl" . stevengj . github.com.
  93. ^ "Usando PyCall en julia en Ubuntu con python3" . julia-users en Grupos de Google . para importar módulos (por ejemplo, python3-numpy)
  94. ^ "interfaz de python para julia" .
  95. ^ a b "Aprenda a Julia en minutos Y" . Learnxinyminutes.com . Consultado el 31 de mayo de 2017 .
  96. ^ "GitHub - JuliaLang / PackageCompiler.jl: compile su paquete Julia" . El lenguaje de Julia. 14 de febrero de 2019 . Consultado el 15 de febrero de 2019 .
  97. ^ "El REPL de Julia · El lenguaje de Julia" . docs.julialang.org . Consultado el 22 de septiembre de 2019 .
  98. ^ "Presentación de Julia / The REPL - Wikilibros, libros abiertos para un mundo abierto" . en.wikibooks.org . Consultado el 22 de septiembre de 2019 . puede instalar el paquete de Julia OhMyREPL.jl ( github .com / KristofferC / OhMyREPL .jl ) que le permite personalizar la apariencia y el comportamiento de REPL
  99. ^ "Introducción · El idioma de Julia" . docs.julialang.org . Consultado el 15 de agosto de 2018 .
  100. ^ Consulte también: docs .julialang .org / en / v1 / manual / strings / para la interpolación de cadenas y elstring(greet, ", ", whom, ".\n")ejemplo para conocer las formas preferidas de concatenar cadenas. Julia tiene las funciones println e print, pero también una macro @printf (es decir, no en forma de función) para eliminar la sobrecarga de formateo en tiempo de ejecución (a diferencia de la misma función en C).
  101. ^ "Documentación de Julia" . JuliaLang.org . Consultado el 18 de noviembre de 2014 .
  102. ^ "Proyecto Jupyter" .
  103. ^ Boudreau, Emmett (16 de octubre de 2020). "¿Podría Plutón ser un verdadero reemplazo de Jupyter?" . Medio . Consultado el 8 de diciembre de 2020 .
  104. ^ "Julia y Spark, mejor juntos" . juliacomputing.com . 2 de junio de 2020 . Consultado el 14 de julio de 2020 .
  105. ^ "Soporte de Unicode 13 por stevengj · Pull Request # 179 · JuliaStrings / utf8proc" . GitHub . Consultado el 29 de marzo de 2020 .
  106. ^ "JuliaRegistries / General" . Consultado el 30 de abril de 2020 .
  107. ^ "Pkg.jl - Artefactos" . Consultado el 4 de junio de 2020 .
  108. ^ "Pkg.jl - Registros" . Consultado el 30 de abril de 2020 .
  109. ^ Farber, Rob (28 de noviembre de 2017). "Julia Language ofrece rendimiento de HPC de Petascale" . La próxima plataforma . Consultado el 22 de abril de 2020 .
  110. ^ Kincade, Kathy (11 de noviembre de 2016). "Las mejoras de Celeste crean nuevas oportunidades en Sky Surveys" . Laboratorio de Berkeley . Consultado el 22 de abril de 2020 .
  111. ^ Francis, Michael (9 de mayo de 2017). "OS @ BLK: Julia NamedTuples" . Ingeniería de BlackRock . Consultado el 22 de abril de 2020 .
  112. ^ Bezanson, Jeff (6 de junio de 2019). "JeffBezanson / femtolisp" . GitHub . Consultado el 16 de junio de 2019 .
  113. ^ "Julia: un lenguaje dinámico rápido para la informática técnica" (PDF) . 2012.
  114. ^ "Cómo hacer que Python funcione tan rápido como Julia" . 2015.
  115. ^ "Comparación básica de Python, Julia, R, Matlab e IDL" . 2015.
  116. ^ Gibbs, Mark (9 de enero de 2013). "Pure y Julia son lenguajes geniales que vale la pena revisar" . Network World (columna) . Consultado el 7 de febrero de 2013 .
  117. ^ "Problema de seguimiento de Darwin / ARM64 · Número # 36617 · JuliaLang / julia" . GitHub . Consultado el 8 de diciembre de 2020 .
  118. ↑ Carlton, Sam (8 de diciembre de 2020), ThatGuySam / doesitarm , consultado el 8 de diciembre de 2020
  119. ^ "Descargas de Julia" . julialang.org . Consultado el 17 de mayo de 2019 .
  120. ^ "Lleve el código de Julia al hardware integrado (ARM)" . JuliaLang . 23 de enero de 2019 . Consultado el 30 de marzo de 2021 .
  121. ^ "julia / arm.md" . El lenguaje de Julia. 29 de noviembre de 2019 . Consultado el 29 de noviembre de 2019 . Hay disponible una lista de problemas conocidos de ARM.
  122. ^ "Julia en TPU" . JuliaTPU. 26 de noviembre de 2019 . Consultado el 29 de noviembre de 2019 .
  123. ^ "AMD ROCm · JuliaGPU" . juliagpu.org . Consultado el 20 de abril de 2020 .
  124. ^ 262588213843476. "Build Julia para RaspberryPi Zero" . Gist . Consultado el 14 de agosto de 2020 .CS1 maint: numeric names: authors list (link)
  125. ^ "JuliaBerry: Julia en la Raspberry Pi" . juliaberry.github.io . Consultado el 14 de agosto de 2020 .
  126. ^ "Julia disponible en Raspbian en Raspberry Pi" . Julia trabaja en todas las variantes de Pi, recomendamos usar Pi 3.
  127. ^ "Lenguaje de Julia para Raspberry Pi" . Fundación Raspberry Pi .
  128. ^ "¿Utilizando Julia en Android?" . JuliaLang . 27 de septiembre de 2019 . Consultado el 2 de octubre de 2019 .

Lectura adicional [ editar ]

  • Nagar, Sandeep (2017). Comenzando la programación de Julia: para ingenieros y científicos . Saltador. ISBN 9781484231715.
  • Bezanson, J; Edelman, A; Karpinski, S; Shah, V. B (2017). "Julia: un nuevo enfoque de la computación numérica". Revisión SIAM . 59 (1): 65–98. arXiv : 1411.1607 . CiteSeerX  10.1.1.760.8894 . doi : 10.1137 / 141000671 . S2CID  13026838 .
  • Joshi, Anshul (2016). Julia para la ciencia de datos: explore el mundo de la ciencia de datos desde cero con Julia a su lado . Packt. ISBN 9781783553860.

Enlaces externos [ editar ]

  • Página web oficial
  • julia en GitHub