Introducción a Rust

Introducción

• Rust es un lenguaje de programación moderno centrado en la seguridad, la velocidad y la concurrencia.
• Tiene una sintaxis parecida a C++, pero garantiza la seguridad de la memoria sin recolector de basura.
• Es útil para proyectos nuevos donde el rendimiento es crítico, el reemplazo de código C/C++, y la ejecución de WebAssembly.

Empezando con Rust

Instalación

• Se usa curl para la instalación.
• En Linux o macOS, se ejecuta:

curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

• En macOS, se instalan las herramientas de línea de comandos Xcode con:

xcode-select --install

• En Linux (Ubuntu), instala GCC o Clang mediante:

sudo apt update
sudo apt install gcc

¡Hola Mundo!

• Crea el archivo main.rs con el siguiente código:

fn main() {
    println!("¡Hola, mundo!");
}

• Compila y ejecuta con:

rustc main.rs./main

Hello, Cargo!

• Cargo es el sistema de compilación y el administrador de paquetes de Rust.
• Para crear un proyecto llamado "Hello, Cargo!":

cargo new hello_cargo
cd hello_cargo

• El archivo src/main.rs debe contener:

fn main() {
    println!("¡Hola, mundo!");
}

• Compila y ejecuta con:

cargo build
cargo run

Conceptos básicos

Variables

• Las variables son inmutables por defecto.
• Se usa mut para declarar variables mutables:

let x = 5; // inmutable
let mut y = 10; // mutable
y = 20;

Tipos de datos

• Rust es de tipado estático, pero puede inferir tipos.
• Algunos tipos básicos son:
  • Integers: i32, u32, i64, u64, etc.
  • Floating point: f32, f64
  • Boolean: bool
  • Character: char
  • String: String, &str
• Ejemplo:

let a: i32 = 10;
let b: f64 = 3.14;
let c: bool = true;
let d: char = 'A';
let e: String = String::from("Hola");
let f: &str = "Mundo";

Funciones

• Se definen con fn.
• Requieren anotación de tipos de parámetros y retorno.

fn add(x: i32, y: i32) -> i32 {
    x + y
}

Comentarios

• Los comentarios de una línea empiezan con //.
• Los comentarios de varias líneas empiezan con ``.

Propiedad

• Rust gestiona la memoria sin un recolector de basura mediante un sistema de propiedad.

Reglas de Propiedad

• Cada valor tiene un propietario.
• Solo puede haber un propietario a la vez.
• Cuando el propietario sale del ámbito, el valor se elimina.

Préstamo y porciones

• Préstamo: Referencia a una variable sin transferir la propiedad.
• Porciones: Referencia a una parte de una estructura de datos.
• Se ejemplifica con:

fn main() {
    let s1 = String::from("hola");
    let len = calculate_length(&s1); // Préstamo
    println!("La longitud de '{}' es {}.", s1, len);

    let s = String::from("hola mundo");
    let hello = &s[0..5]; // Porción
    let world = &s[6..11]; // Porción
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

Estructuras

• Permiten crear tipos de datos personalizados.
• Ejemplo:

struct Usuario {
    nombre_usuario: String,
    correo_electronico: String,
    inicio_sesion_cuenta: u64,
    activo: bool,
}

fn main() {
    let usuario1 = Usuario {
        correo_electronico: String::from("[email protected]"),
        nombre_usuario: String::from("alguien123"),
        activo: true,
        inicio_sesion_cuenta: 1,
    };
}

Enumeraciones y Coincidencia de patrones

• Las enumeraciones definen un tipo que puede tener varias variantes.

enum WebEvento {
    TeclasPresionadas(String),
    Pegar(String),
    Click { x: i64, y: i64 },
}

fn main() {
    let evento1 = WebEvento::TeclasPresionadas(String::from("hola"));
    let evento2 = WebEvento::Pegar(String::from("mundo"));
    let evento3 = WebEvento::Click { x: 10, y: 20 };

    match evento1 {
        WebEvento::TeclasPresionadas(s) => {
            println!("Teclas presionadas: {}", s);
        }
        WebEvento::Pegar(s) => {
            println!("Pegar: {}", s);
        }
        WebEvento::Click { x, y } => {
            println!("Click en x={}, y={}", x, y);
        }
    }
}

Gestión de errores

• Rust usa el tipo Result para manejar errores recuperables.

use std::fs::File;

fn main() {
    let f = File::open("hola.txt");

    let f = match f {
        Ok(file) => file,
        Err(error) => {
            panic!("Hubo un problema abriendo el archivo: {:?}", error)
        },
    };
}

Genéricos

• Permiten escribir código que funciona con múltiples tipos de datos.

fn largest(list: &[T]) -> T {
    let mut largest = list;

    for &item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("El número más grande es {}", result);

    let char_list = vec!['y', 'm', 'q', 'i'];

    let result = largest(&char_list);
    println!("El caracter más grande es {}", result);
}

Pruebas

• Rust tiene un sistema de pruebas incorporado.
• Las funciones de prueba se anotan con el atributo #[test].

#[test]
fn it_adds_two() {
    assert_eq!(4, 2 + 2);
}

Conclusión

• Rust tiene una curva de aprendizaje pronunciada, pero vale la pena el esfuerzo.

Trading Algorítmico y Ejecución de Órdenes

Definición de Trading Algorítmico

• Uso de programas informáticos para automatizar la ejecución de órdenes.
• Los algoritmos de ejecución dividen grandes órdenes en órdenes más pequeñas y deciden los parámetros de ejecución de la orden.

Razones para Utilizar el Trading Algorítmico

• Costos de Transacción Reducidos:
  • Minimizar el impacto en el mercado.
  • Evitar la fuga de información.
  • Aprovechar los movimientos de precios.
• Velocidad de Ejecución Mejorada:
  • Respuesta automatizada a eventos del mercado.
  • Colocación y cancelación de órdenes más rápidas.
• Mayor Eficiencia:
  • Manejo de grandes volúmenes de órdenes.
  • Operar en múltiples mercados simultáneamente.
• Mejor Toma de Decisiones:
  • Ejecución sistemática y objetiva.
  • Capacidad para incorporar reglas de trading complejas.

Tipos de Algoritmos

• Algoritmos de Ejecución:
  • Se utilizan para ejecutar una orden específica.
  • Ejemplos: VWAP, TWAP, Porcentaje de Volumen (POV).
• Algoritmos de Trading:
  • Se utilizan para generar señales de trading.
  • Ejemplos: Arbitraje estadístico, seguimiento de tendencias.

Algoritmos de Ejecución

• Precio Promedio Ponderado por Volumen (VWAP):

  • Promedia el precio que se paga por una acción con el volumen relativo negociado.
  • Busca ejecutar una orden al precio VWAP.

  $$ \operatorname{VWAP}=\frac{\sum_{i=1}^{n} P_{i} * V_{i}}{\sum_{i=1}^{n} V_{i}} $$

  • $P_i$ = Precio de la operación i
  • $V_i$ = Volumen de la operación i
  • n = Número de operaciones

• Precio Promedio Ponderado por Tiempo (TWAP):

  • Promedia el precio que se paga por una acción durante la duración de la orden. Busca ejecutar una orden al precio TWAP.

  $$ \mathrm{TWAP}=\frac{\sum_{i=1}^{n} P_{i}}{n} $$

  • $P_i$ = Precio de la operación i
  • n = Número de operaciones

• Porcentaje de Volumen (POV):

  • Participa en el mercado a un porcentaje fijo del volumen total.
  • Busca ejecutar un porcentaje constante del volumen total del mercado.

Tipos de Órdenes

• Orden de Mercado:
  • Una orden para comprar o vender un valor inmediatamente al mejor precio disponible.
  • Garantiza la ejecución pero no el precio.
• Orden Límite:
  • Una orden para comprar o vender un valor a un precio específico o mejor.
  • Garantiza el precio pero no la ejecución.
• Orden Stop:
  • Una orden para comprar o vender un valor cuando el precio alcanza un nivel específico.
  • Se convierte en una orden de mercado cuando se alcanza el precio stop.
• Orden Stop-Límite:
  • Combina características de las órdenes stop y límite.
  • Se convierte en una orden límite cuando se alcanza el precio stop.
• Orden Oculta (Orden Iceberg):
  • Solo una porción de la orden se muestra al mercado.
  • Se utiliza para reducir el impacto en el mercado.

Impacto en el Mercado

• El efecto de las órdenes de un operador en el precio de un valor.
• Las órdenes grandes pueden mover el precio en contra del operador.
• El trading algorítmico puede ayudar a minimizar el impacto en el mercado.

Fuga de Información

• La divulgación de información sobre las intenciones de un operador al mercado.
• Puede llevar a movimientos de precios adversos.
• El trading algorítmico puede ayudar a prevenir la fuga de información.

Plataformas de Trading Algorítmico

• Sistemas de software utilizados para desarrollar, probar y desplegar algoritmos de trading.
• Proporcionan acceso a datos de mercado, herramientas de gestión de órdenes y características de gestión de riesgos.

Regulación del Trading Algorítmico

• Diseñada para asegurar mercados justos y ordenados.
• Ejemplos:
  • Regla de Acceso al Mercado (Regla 15c3-5): Requiere que los brokers tengan controles de gestión de riesgos en vigor para el trading algorítmico.
  • Regla de Reporte de Grandes Operadores (Regla 13h-1): Requiere que los grandes operadores se registren en la SEC y reporten su actividad de trading.
  • Límite Arriba-Límite Abajo (LULD): Previene que las operaciones ocurran fuera de las bandas de precios especificadas.

Radio Atómico

• El radio atómico es la mitad de la distancia entre los núcleos de átomos idénticos que están unidos químicamente.

Tendencias del Radio Atómico

• El radio atómico aumenta hacia la izquierda y hacia abajo en la tabla periódica.
  • Al bajar en un grupo, se añaden niveles de energía, lo que agranda el átomo.
  • Al moverse de derecha a izquierda, disminuye el número de protones, reduciendo la carga positiva del núcleo y permitiendo que los electrones se alejen.
• El Francio (Fr) es el átomo más grande en la tabla periódica.
• Las tendencias del radio atómico son opuestas a las de la electronegatividad y la energía de ionización.

Investigación

Pregunta Principal:

• ¿Cuáles son las principales fuentes de información que utiliza para llevar a cabo la investigación?

Resumen de las Respuestas:

• Nota: Los participantes podían seleccionar varias opciones, por lo que los porcentajes no suman el 100%.

Motores de Búsqueda Académicos Utilizados:

• Google Académico (91 menciones)
• Web of Science (25 menciones)
• Scopus (24 menciones)
• IEEE Xplore (13 menciones)

Modo de Acceso a los Motores de Búsqueda Académicos:

• Nota: Los participantes podían seleccionar varias opciones, por lo que los porcentajes no suman el 100%.

Descubrimiento a Entrega (Discovery to Delivery)

Conocimiento:

• ¿Dónde se entera por primera vez de los recursos relevantes para su investigación?
  • Colegas/Expertos (70%)
  • Motores de búsqueda académicos (63.3%)
  • Congresos (57.5%)
  • Bases de datos específicas por tema (47.5%)
  • Motores de búsqueda web generales (45%)
  • Sitio web de la biblioteca (44.2%)
  • Redes sociales (20%)
  • Foros de discusión en línea (19.2%)
  • Otro (4.2%)

Acceso:

• ¿Qué hace cuando se encuentra con un muro de pago para un recurso que quiere utilizar?
  • Acceder a través de la suscripción bibliotecaria (80%)
  • Solicitar al autor (51.7%)
  • Préstamo interbibliotecario (43.3%)
  • Utilizar estrategias de búsqueda alternativas (35%)
  • Encontrar una versión disponible gratuitamente (33.3%)
  • Comprar el recurso (3.3%)
  • Otro (4.2%)
  • Darse por vencido (1.7%)

Software de Análisis de Datos:

• ¿Qué software de análisis de datos utiliza para su investigación?

• Nota: Los participantes podían seleccionar varias opciones, por lo que los porcentajes no suman el 100%.

Algoritmo EM en PLN: Etiquetado de Partes del Discurso (POS)

• Objetivo: Determinar la secuencia de etiquetas POS más probable para una oración dada.
• Aplicaciones:
  • Text-to-speech (pronunciación de palabras).
  • Extracción de información (identificación de empresas/productos).
  • Respuesta a preguntas (identificación del sujeto de la oración).
  • Análisis sintáctico.

HMM para Etiquetado POS

• Se usa un Modelo Oculto de Markov (HMM) para encontrar la secuencia de etiquetas más probable.
  • Estados: Etiquetas POS (sustantivo, verbo, adjetivo, preposición, determinante, etc.).
  • Observaciones: Palabras.
• Probabilidades clave:
  • Probabilidades de transición $P(t_i | t_{i-1})$: probabilidad de una etiqueta dado la etiqueta anterior.
  • Probabilidades de emisión $P(w_i | t_i)$: probabilidad de una palabra dado la etiqueta.
• Ecuación HMM: $$ \hat{t} = arg \max_{t} \prod_{i=1}^n P(w_i | t_i) P(t_i | t_{i-1}) $$
• En la práctica, se utilizan logaritmos para evitar el subdesbordamiento:

$$ \hat{t} = arg \max_{t} \sum_{i=1}^n log P(w_i | t_i) + log P(t_i | t_{i-1}) $$

Entrenamiento HMM

• Entrenamiento supervisado: Se utiliza un corpus de entrenamiento etiquetado para aprender los parámetros del HMM (probabilidades de transición y emisión) mediante conteo y normalización. $$ P(t_i | t_{i-1}) = \frac{count(t_{i-1}, t_i)}{count(t_{i-1})} $$ $$ P(w_i | t_i) = \frac{count(t_i, w_i)}{count(t_i)} $$

Problema de Entrenamiento HMM

¿Qué ocurre si no se dispone de un corpus de entrenamiento etiquetado? ¿Podemos entrenar un HMM con datos no etiquetados? Sí, utilizando el algoritmo Expectation-Maximization (EM).

Entrenamiento HMM con EM

• Se puede utilizar el algoritmo EM para aprender los parámetros del HMM a partir de un corpus de entrenamiento no etiquetado.
• Idea básica:
• Inicializar los parámetros del HMM aleatoriamente.
• Iterar:
• Paso de Expectation (E): Usar el HMM actual para estimar la probabilidad de cada posible secuencia de etiquetas para cada oración en el corpus de entrenamiento.
• Paso de Maximización (M): Usar estas probabilidades de etiquetas estimadas para volver a estimar los parámetros del HMM (probabilidades de transición y emisión).
• Detener cuando los parámetros convergen.

Entrenamiento HMM con EM Paso E

• Se utiliza el HMM actual para estimar la probabilidad de cada posible secuencia de etiquetas para cada oración en el corpus de entrenamiento.
• Más específicamente, para cada oración, calculamos:

$$ P(t_1, t_2,..., t_n | w_1, w_2,..., w_n) $$

para todas las posibles secuencias de etiquetas $t_1, t_2,..., t_n$. El algoritmo de Viterbi nos puede ayudar.

Entrenamiento de HMM con EM Paso M

• Se utilizan estas probabilidades de etiquetas estimadas para volver a estimar los parámetros del HMM (probabilidades de transición y emisión).
• Utilizar "conteos fraccionarios".

$$ count(t_{i-1}, t_i) = \sum_{sentences} \sum_{i=1}^n P(t_i | t_{i-1}) $$

$$ count(t_i, w_i) = \sum_{sentences} \sum_{i=1}^n P(w_i | t_i) $$

• Luego, se volver a estimar los parámetros HMM utilizando estos conteos fraccionarios:

$$ P(t_i | t_{i-1}) = \frac{count(t_{i-1}, t_i)}{count(t_{i-1})} $$

$$ P(w_i | t_i) = \frac{count(t_i, w_i)}{count(t_i)} $$

El proceso r

Introducción

• La síntesis de núcleos más pesados que el hierro no puede ocurrir a través de reacciones de partículas cargadas debido a las altas barreras de Coulomb.
• La captura de neutrones es la única opción viable.
• Dos procesos de captura de neutrones: el proceso s y el proceso r.
• El proceso s (captura lenta de neutrones): $\tau_{\beta} < \tau_{n}$, donde $\tau_{\beta}$ es la vida media de la desintegración beta y $\tau_{n}$ es la vida media de la captura de neutrones.
• El proceso r (captura rápida de neutrones): $\tau_{\beta} > \tau_{n}$.
• El proceso r implica núcleos muy ricos en neutrones lejos de la estabilidad.

La ruta del proceso r

La ruta del proceso r depende de:

• Tasas de captura de neutrones.
• Tasas de fotodesintegración.
• Tasas de desintegración beta.
• La captura de neutrones y la fotodesintegración alcanzan un equilibrio, creando una cadena isotópica con Z constante.
• Tasa de fotodesintegración:

$\lambda_{\gamma}(Z, A+1) \propto T_{9}^{3/2} \exp \left( - \frac{S_{n}(Z, A+1)}{kT} \right) \lambda_{n}(Z, A)$ donde $S_{n}(Z, A+1)$ es la energía de separación de neutrones.

• Cuando se alcanza el equilibrio $(\mathrm{n}, \gamma) \rightleftharpoons (\gamma, \mathrm{n})$:

$\frac{N(Z, A+1)}{N(Z, A)} = \frac{G(Z, A+1)}{G(Z, A)} n_{n} \left( \frac{A+1}{A} \right)^{3/2} \left( \frac{2 \pi \hbar^{2}}{m_{u} kT} \right)^{3/2} \exp \left( \frac{S_{n}(Z, A+1)}{kT} \right)$ donde $G(Z, A)$ es la función de partición, $n_{n}$ es la densidad numérica de neutrones, y $m_{u}$ es la unidad de masa atómica. En general, las funciones de partición son cercanas a la unidad.

• Para un Z dado, las energías de separación de neutrones de los isótopos a lo largo de la cadena isotópica disminuyen al aumentar A.
• La ruta del proceso r está determinada por los valores de $S_{n}$:

$S_{n} = kT \ln \left( \frac{G(Z, A+1)}{G(Z, A)} n_{n} \lambda^{3} \right)$ donde $\lambda = h / \sqrt{2 \pi m_{u} kT}$ es la longitud de onda térmica de de Broglie del neutrón.

• La ruta del proceso r se mueve a un Z más alto a través de la desintegración $\beta$.
• Los puntos de espera ocurren en números mágicos de neutrones (N = 50, 82, 126).
• En los puntos de espera, las vidas medias de la desintegración $\beta$ determinan el flujo.
• Después de que se agota la fuente de neutrones, el material sintetizado se desintegra $\beta$ de vuelta a la estabilidad. Esto produce los picos de abundancia del proceso r.

Condiciones para el proceso r

• Se requieren condiciones extremas: altas densidades de neutrones ($n_{n} \approx 10^{20} - 10^{30} \mathrm{cm}^{-3}$) y altas temperaturas ($T \approx 1-2 \mathrm{GK}$).
• Posibles sitios astrofísicos:
• Supernovas de colapso de núcleo (vientos impulsados por neutrinos).
• Fusiones de estrellas de neutrones.
• Vientos impulsados por neutrinos en supernovas de colapso de núcleo:
• Los neutrinos emitidos desde la protoestrella de neutrones interactúan con la materia por encima de la superficie.
• Esto crea una pequeña cantidad de material rico en protones.
• Los neutrones se producen a través de:
• $\bar{\nu}_{e} + p \rightarrow e^{+} + n$
• $\nu_{e} + n \rightarrow e^{-} + p$
• La relación neutrón a semilla es crucial para un proceso r exitoso:

$\frac{n}{seed} \propto \frac{Y_{n}}{Y_{seed}} \approx \frac{X_{n}}{X_{seed}}$

• Fusiones de estrellas de neutrones:
• Las fuerzas de marea expulsan material rico en neutrones.
• Proceso r muy robusto debido a condiciones muy ricas en neutrones.

El proceso r clásico

• Asume el equilibrio $(\mathrm{n}, \gamma) \rightleftharpoons (\gamma, \mathrm{n})$.
• La ruta del proceso r está determinada por las energías de separación de neutrones $S_{n}$.
• La distribución de abundancia dentro de una cadena isotópica está dada por la ecuación de Saha.
• La abundancia total de un elemento Z está determinada por los isótopos del punto de espera con largas vidas medias de desintegración $\beta$.
• Los cálculos implican:
• Entrada de física nuclear: masas, vidas medias de desintegración $\beta$, tasas de captura de neutrones.
• Condiciones astrofísicas: temperatura y densidad de neutrones.

La aproximación del punto de espera

• Asume que el flujo a lo largo de la ruta del proceso r está gobernado por las vidas medias de desintegración $\beta$ en los puntos de espera.
• La abundancia de un isótopo en un punto de espera es proporcional a su vida media de desintegración $\beta$.
• Esta aproximación simplifica los cálculos de las abundancias del proceso r.

Éxitos y deficiencias

• El proceso r puede reproducir las abundancias solares observadas para $A > 100$.
• Deficiencias:
• El sitio astrofísico aún es incierto.
• La entrada de física nuclear es incierta, especialmente para núcleos muy ricos en neutrones.
• La aproximación del punto de espera no siempre es válida.

Impacto de la física nuclear

• Masas nucleares: determinan la ruta del proceso r a través de energías de separación de neutrones ($S_{n}$).
• Vidas medias de desintegración $\beta$: determinan la velocidad del proceso r y la distribución de abundancia.
• Tasas de captura de neutrones: afectan el equilibrio entre la captura de neutrones y la fotodesintegración.
• Tasas de fisión: terminan el proceso r en números de masa altos.

Algoritmo de Dijkstra

Algoritmo de Dijkstra

• Edsger Wybe Dijkstra fue un brillante científico informático
• Publicó el algoritmo de búsqueda de gráficos en 1959.
• Calcula las rutas más cortas desde un nodo de inicio a todos los demás nodos en un gráfico con pesos de borde no negativos.
• Es un algoritmo codicioso.
• Mantiene un conjunto de nodos visitados y una cola de prioridad de nodos no visitados, donde la prioridad de un nodo es la longitud de la ruta más corta desde el nodo de inicio a ese nodo.
• En cada paso, visita el nodo no visitado con la prioridad más pequeña, actualiza las prioridades de sus vecinos y lo agrega al conjunto de nodos visitados.
• El algoritmo termina cuando se han visitado todos los nodos.

Propiedades

• El algoritmo mantiene como invariante que la prioridad de un nodo visitado es la longitud de la ruta más corta desde el nodo de inicio a ese nodo.
• El algoritmo también mantiene como invariante que la prioridad de un nodo no visitado es la longitud de la ruta más corta desde el nodo de inicio a ese nodo que solo visita los nodos visitados.
• El algoritmo es correcto porque mantiene estos invariantes.

Pseudo-código

Dijkstra(Graph G, Node start) {
    // Initialize distances from start to all other nodes to infinity
    for each node v in G:
        distance[v] = infinity
    // Distance from start to start is zero
    distance[start] = 0
    // Create an empty priority queue
    priorityQueue = new PriorityQueue()
    // Add start node to the priority queue
    priorityQueue.add(start, 0)
    // While the priority queue is not empty
    while priorityQueue is not empty:
        // Get the node with the smallest distance from the priority queue
        current = priorityQueue.remove()
        // For each neighbor of the current node
        for each neighbor in G.neighbors(current):
            // Calculate the distance from start to neighbor through current
            newDist = distance[current] + G.weight(current, neighbor)
            // If the new distance is shorter than the current distance to neighbor
            if newDist < distance[neighbor]:
                // Update the distance to neighbor
                distance[neighbor] = newDist
                // Add neighbor to the priority queue with the new distance
                priorityQueue.add(neighbor, newDist)
    // Return the distances from start to all other nodes
    return distance
}

Complejidad

• Sea $n = |V |$ el número de vértices y $m = |E|$ el número de aristas.
• La complejidad del algoritmo de Dijkstra depende de la implementación de la cola de prioridad:
• Matriz: $O(n^2 + m)$
• Montón binario: $O((n + m) \log n) = O(m \log n)$ (ya que $m \geq n - 1$)
• Montón de Fibonacci: $O(n \log n + m)$
• Nota: si solo queremos encontrar la ruta más corta a un solo nodo de destino, podemos detener el algoritmo cuando visitemos ese nodo.

Algebra lineal

Definiciones

Espacio Vectorial

• Un espacio vectorial es un conjunto E con dos operaciones: Suma (+: E × E → E) y multiplicación por un escalar (. : K × E → E).
• Se deben cumplir las siguientes propiedades: (E,+) es un grupo abeliano, distributividad de la multiplicación escalar, asociatividad de la multiplicación escalar y existencia de un elemento neutro para la multiplicación escalar.

Subespacio Vectorial

• Un subconjunto F de un espacio vectorial E es un subespacio vectorial si: F no está vacío, la suma de dos vectores en F está en F, y la multiplicación de un escalar por un vector en F está en F.

Combinación Lineal

• Una combinación lineal de vectores $u_1,..., u_n$ en un espacio vectorial E es un vector de la forma $\lambda_1 u_1 +... + \lambda_n u_n$, con $\lambda_1,..., \lambda_n \in \mathbb{K}$.

Familia Generadora

• Una familia de vectores $(u_1,..., u_n)$ en un espacio vectorial E es una familia generadora si todo vector de E puede escribirse como una combinación lineal de $u_1,..., u_n$.

Familia Libre

• Una familia de vectores $(u_1,..., u_n)$ en un espacio vectorial E es una familia libre si la única combinación lineal de $u_1,..., u_n$ que da el vector nulo es aquella donde todos los coeficientes son nulos.

Base

• Una base de un espacio vectorial E es una familia de vectores que es a la vez libre y generadora.
• Si $(u_1,..., u_n)$ es una base de E, entonces cualquier vector U de E se escribe de manera UNICA como $\lambda_1 u_1 +... + \lambda_n u_n$.

Dimensión

• La dimensión de un espacio vectorial E es el número de vectores en una base de E.

Función Logaritmo Neperiano

Definición

• La función logaritmo neperiano, notada ln, está definida en ]0; +∞[ y es la única función que cumple: ln(1) = 0 y ln'(x) = 1/x.

Consecuencias

• La función ln es derivable y continua en ]0; +∞[
• Para todo real x > 0, ln'(x) = 1/x > 0, por lo que la función ln es estrictamente creciente en ]0; +∞[.

Propiedades algebraicas

• Para todos reales a y b estrictamente positivos, y para todo entero relativo n:
• ln(ab) = ln(a) + ln(b)
• ln(1/a) = -ln(a)
• ln(a/b) = ln(a) - ln(b)
• ln(a^n) = n*ln(a)
• ln(√a) = (1/2)ln(a)

Límites

• lim x→+∞ ln(x) = +∞
• lim x→0^+ ln(x) = -∞
• lim x→+∞ ln(x)/x = 0
• lim x→0 x*ln(x) = 0
• lim h→0 ln(1+h)/h = 1

Derivadas

• Si u es una función derivable y estrictamente positiva en un intervalo I, entonces ln(u) es derivable en I y (ln(u))' = u'/u.

Ecuaciones y inecuaciones

• Si a y b son reales positivos entonces $\ln(a) = \ln(b) \Leftrightarrow a = b$ y $\ln(a) < \ln(b) \Leftrightarrow a < b$

関数$ln(u)$

If $u$ is on an interval $I$ that is positive, then $ln(u(x))$ is on I.

Note para aprender

• Usar el mismo lenguaje es útil para entender
• Se cuidadoso con la información que copias
• No olvides ver las imágenes y diagramas que se ofrecen pues son importantes para entender