Artículos

3.1E: Ejercicios


Ejercicio ( PageIndex {1} )

Explica cómo sumar números complejos.

Respuesta

Suma las partes reales y las imaginarias.

Ejercicio ( PageIndex {2} )

¿Cuál es el principio básico de la multiplicación de números complejos?

Ejercicio ( PageIndex {3} )

Da un ejemplo para mostrar que el producto de dos números imaginarios no siempre es imaginario.

Respuesta

(i ) multiplicado por (i ) es igual a –1, que no es imaginario. (las respuestas variarán)

Ejercicio ( PageIndex {4} )

¿Cuál es una característica de la gráfica de un número real en el plano complejo?

Para los siguientes ejercicios, evalúe las expresiones algebraicas.

Ejercicio ( PageIndex {5} )

Si (f (x) = x ^ 2 + x − 4 ), evalúa (f (2i) ).

Respuesta

(- 8 + 2i )

Ejercicio ( PageIndex {6} )

Si (f (x) = x ^ 3−2 ), evalúe (f (i) ).

Ejercicio ( PageIndex {7} )

Si (f (x) = x ^ 2 + 3x + 5 ), evalúa (f (2 + i) ).

Respuesta

(14 + 7i )

Ejercicio ( PageIndex {8} )

Si (f (x) = 2x ^ 2 + x − 3 ), evalúa (f (2−3i) ).

Ejercicio ( PageIndex {9} )

Si (f (x) = frac {x + 1} {2 − x} ), evalúa (f (5i) ).

Respuesta

(- frac {23} {29} + frac {15} {29} i )

Ejercicio ( PageIndex {10} )

Si (f (x) = frac {1 + 2x} {x + 3} ), evalúa (f (4i) ).

Para los siguientes ejercicios, determine el número de soluciones reales y no reales para cada función cuadrática que se muestra.

Ejercicio ( PageIndex {11} )

Respuesta

2 reales y 0 no reales

Ejercicio ( PageIndex {12} )

Para los siguientes ejercicios, grafica los números complejos en el plano complejo.

Ejercicio ( PageIndex {13} )

(1−2i )

Respuesta

Ejercicio ( PageIndex {14} )

(- 2 + 3i )

Ejercicio ( PageIndex {15} )

(I)

Respuesta

Ejercicio ( PageIndex {16} )

(- 3−4i )

Para los siguientes ejercicios, realice la operación indicada y exprese el resultado como un número complejo simplificado.

Ejercicio ( PageIndex {17} )

((3 + 2i) + (5−3i) )

Respuesta

(8 − i )

Ejercicio ( PageIndex {18} )

((- 2−4i) + (1 + 6i) )

Ejercicio ( PageIndex {19} )

((- 5 + 3i) - (6 − i) )

Respuesta

(- 11 + 4i )

Ejercicio ( PageIndex {20} )

((2−3i) - (3 + 2i) )

Ejercicio ( PageIndex {21} )

((- 4 + 4i) - (- 6 + 9i) )

Respuesta

(2−5i )

Ejercicio ( PageIndex {22} )

((2 + 3i) (4i) )

Ejercicio ( PageIndex {23} )

((5−2i) (3i) )

Respuesta

(6 + 15i )

Ejercicio ( PageIndex {24} )

((6−2i) (5) )

Ejercicio ( PageIndex {25} )

((- 2 + 4i) (8) )

Respuesta

(- 16 + 32i )

Ejercicio ( PageIndex {26} )

((2 + 3i) (4 − i) )

Ejercicio ( PageIndex {27} )

((- 1 + 2i) (- 2 + 3i) )

Respuesta

(- 4−7i )

Ejercicio ( PageIndex {28} )

((4−2i) (4 + 2i) )

Ejercicio ( PageIndex {29} )

((3 + 4i) (3−4i) )

Respuesta

25

Ejercicio ( PageIndex {30} )

( frac {3 + 4i} {2} )

Ejercicio ( PageIndex {31} )

( frac {6−2i} {3} )

Respuesta

(2− frac {2} {3} i )

Ejercicio ( PageIndex {32} )

( frac {−5 + 3i} {2i} )

Ejercicio ( PageIndex {33} )

( frac {6 + 4i} {i} )

Respuesta

(4−6i )

Ejercicio ( PageIndex {34} )

( frac {2−3i} {4 + 3i} )

Ejercicio ( PageIndex {35} )

( frac {3 + 4i} {2 − i} )

Respuesta

( frac {2} {5} + frac {11} {5} i )

Ejercicio ( PageIndex {36} )

( frac {2 + 3i} {2−3i} )

Ejercicio ( PageIndex {37} )

( sqrt {−9} +3 sqrt {−16} )

Respuesta

(15i )

Ejercicio ( PageIndex {38} )

(- sqrt {−4} −4 sqrt {−25} )

Ejercicio ( PageIndex {39} )

( frac {2+ sqrt {−12}} {2} )

Respuesta

(1 + i sqrt {3} )

Ejercicio ( PageIndex {40} )

( frac {4+ sqrt {−20}} {2} )

Ejercicio ( PageIndex {41} )

(i ^ 8 )

Respuesta

(1)

Ejercicio ( PageIndex {42} )

(i ^ {15} )

Ejercicio ( PageIndex {43} )

(i ^ {22} )

Respuesta

(−1)

Para los siguientes ejercicios, use una calculadora para ayudar a responder las preguntas.

44. Evalúa ((1 + i) ^ k ) para (k = 4, 8, ) y (12 ). Predice el valor si (k = 16 ).

45. Evalúa ((1 − i) ^ k ) para (k = 2, 6, ) y (10 ​​). Predice el valor si (k = 14 ).

Respuesta: 128i

46. ​​Evalúa (1 + i) k− (1 − i) k para (k = 4 ), 8 y 12. Predice el valor de (k = 16 ).

47. Muestre que una solución de (x ^ 6 + 1 = 0 ) es ( frac { sqrt {3}} {2} + frac {1} {2} i ).

Respuesta: (( frac { sqrt {3}} {2} + frac {1} {2} i) ^ 6 = −1 )

48. Muestre que una solución de (x ^ 8−1 = 0 ) es ( frac { sqrt {2}} {2} + frac { sqrt {2}} {2} i ).

Para los siguientes ejercicios, evalúe las expresiones, escribiendo el resultado como un número complejo simplificado.

49. ( frac {1} {i} + frac {4} {i ^ 3} )

Respuesta: (3i )

50. ( frac {1} {i ^ {11}} - frac {1} {i ^ {21}} )

51. (i ^ 7 (1 + i ^ 2) )

Respuesta: 0

52. (i ^ {- 3} + 5i ^ 7 )

53. ( frac {(2 + i) (4−2i)} {(1 + i)} )

Respuesta: (5 - 5i )

54. ( frac {(1 + 3i) (2−4i)} {(1 + 2i)} )

55. ( frac {(3 + i) ^ 2} {(1 + 2i) ^ 2} )

Respuesta: (- 2i )

56. ( frac {3 + 2i} {2 + i} + (4 + 3i) )

57. ( frac {4 + i} {i} + frac {3−4i} {1 − i} )

Respuesta: ( frac {9} {2} - frac {9} {2} i )

58. ( frac {3 + 2i} {1 + 2i} - frac {2−3i} {3 + i} )


3.1E: Ejercicios

Ejercicio 3.1a (Reescribir el ejercicio 1.9 usando declaraciones)

Ejercicio 3.1b (Reescriba el ejercicio 1.10 usando declaraciones)

Ejercicio 3.1c (Reescriba el ejercicio 1.11 usando declaraciones)

Ejercicio 3.1d (Reescriba el ejercicio 2.41a usando declaraciones)

Ejercicio 3.1e (Reescriba el ejercicio 2.41b usando declaraciones)

Ejercicio 3.1f (Reescriba el ejercicio 2.41c usando declaraciones)

Ejercicio 3.1g (Reescriba el ejercicio 2.41d usando declaraciones)

Ejercicio 3.1h (Reescriba el ejercicio 2.41f usando declaraciones)

Ejercicio 3.2a Leer de la entrada estándar a línea a la vez.

Ejercicio 3.2b Leer de la entrada estándar a palabra a la vez.

El operador de entrada de cadena recorta los espacios en blanco iniciales y finales y devuelve solo los caracteres intermedios. Por ejemplo, si el usuario ingresó la cadena

el operador de entrada recortaría el espacio en blanco desde el principio de la cadena (los primeros cinco espacios), luego leería los caracteres hasta llegar al siguiente espacio en blanco. El resultado de la primera lectura estaría allí. Básicamente, la entrada de cadena utiliza espacios en blanco como delimitador.

En su lugar, la función getline () retendrá todos los espacios en blanco y usará una nueva línea como delimitador. Usando la entrada de ejemplo anterior, la función getline () lee cada carácter (espacio en blanco incluido) hasta que alcanza un carácter de nueva línea. Entonces, después de la primera lectura, la salida sería

Ejercicio 3.4a Verifique la igualdad o la cadena más grande.

Ejercicio 3.4b Verifique la igualdad de longitud o la cuerda más larga.

Ejercicio 3.5a Cadenas concatenadas, sin espacio.

Ejercicio 3.5b Cadenas concatenadas, con espacios.

Si tuviéramos que cambiar de auto & amp a char & amp, el programa funcionaría como se esperaba ya que el tipo deducido de auto es char de todos modos. Si asumimos que la pregunta es eliminar el & amp todos juntos, entonces el programa no funcionaría como se esperaba. Si se descarta la referencia, la cadena original nunca se modificaría, sino que la variable local dentro del rango se cambiaría a 'X' y luego se sobrescribirá en la siguiente iteración. La cadena original se imprimirá sin haber sido alterada nunca.

Ejercicio 3.7 El ejercicio 3.6 con rango revisado para eso no hace esencialmente nada.

Ejercicio 3.8a Vuelva a escribir el ejercicio 3.6 utilizando un ciclo while.

Ejercicio 3.8b Vuelva a escribir el ejercicio 3.6 utilizando un bucle for tradicional.

Un rango para bucle es, con mucho, la solución más limpia para estos ejercicios. No hay variables adicionales para declarar o incrementar como en el ciclo while y es más fácil de leer que el ciclo tradicional for.

Este código es válido porque el compilador no se quejará, aunque es funcionalmente incorrecto. Una cadena inicializada predeterminada es una cadena vacía "" que no tiene contenido en el índice 0. El acceso a un índice de una cadena vacía no está definido.

Legal. c es un carácter const & amp. Mientras el cuerpo de la rabia por no intente modificar c, será legal.

Legal, crea un vector que contiene un vector inicializado predeterminado de tipo int.

Ilegal, como tratar de ajustar la forma de estrella en el agujero redondo, los vectores deben tener el mismo tipo para realizar la inicialización de la copia.

Legal, construye el vector usando el constructor de clase dando como resultado un vector con 10 elementos de cadena inicializados a "nulo".

(b) Utiliza el constructor de clases para construir un vector con 10 ints inicializados por defecto en 0.

Utiliza el constructor de clases para construir un vector con 10 entradas inicializadas en 42.

Utiliza la inicialización de lista para crear un vector con un elemento 'int' inicializado en 10.

Utiliza la inicialización de lista para crear un vector con dos elementos int inicializados en 10 y 42 respectivamente.

Utiliza la inicialización de lista para crear un vector con 10 cadenas inicializadas (vacías) predeterminadas.

Utiliza la inicialización de lista para crear un vector con 10 elementos de cadena inicializados en "hi".

El programa anterior no es legal. ivec es un vector vacío que no tiene ningún elemento en el índice 0. Intentar acceder a un índice fuera de rango no está definido. Para solucionar el problema tenemos tres opciones lógicas. Podemos listar inicializar el vector

Podemos inicializar el vector con un elemento inicializado predeterminado

O podríamos usar la función miembro push_back

La inicialización de listas es mi método preferido para este ejemplo.

Cree un vector vacío y complételo usando la función de miembro push_back

lista inicializar el vector

Usa el constructor de clases

El método preferido es utilizar el constructor de clases. Este método se adapta perfectamente a la tarea, es compacto, eficiente y menos propenso a errores que escribir cada valor individualmente.

Ejercicio 3.20b (Suma de primero y último, segundo y penúltimo, y así sucesivamente).

Ejercicio 3.24a (Reescriba el ejercicio 3.20a usando iteradores)

Ejercicio 3.24b (Reescriba el ejercicio 3.20b usando iteradores)

Primero entendamos cómo y por qué mid = beg + (end - beg) / 2, luego averigüemos por qué min = (beg + end) / 2 no se usó en esta solución. Tanto beg como end son iteradores de tipo int. Los iteradores funcionan de forma muy parecida a los punteros que piden puntos al primer elemento del vector, puntos finales a 'uno más allá del final'. Con esta información podemos dibujar un diagrama para representar un vector con 5 elementos y marcar dónde están el principio y el final. Esto debería ayudarnos a comprender qué está pasando.

Ahora, ¿qué pasa cuando rogamos menos desde el final? Cuando realizamos este tipo de aritmética en iteradores (un iterador menos y un iterador), el tipo devuelto es no un iterador es, en cambio, un difference_type, es decir, un valor numérico que es la distancia entre 2 iteradores en el contenedor proporcionado. En el caso del vector anterior, beg representa el primer elemento, end representa el sexto elemento (uno más allá del final), por lo que nuestra definición básicamente se reduce a mid = beg + (6 - 1) / 2 o mid = beg + 2 (no +2,5 ya que la división de enteros elimina el componente fraccionario). Sumar o restar un tipo numérico de un iterador significa incrementar / disminuir el iterador por el valor numérico dado. En este caso, avance 2 plazas.

Así es como terminamos con mid en el punto medio del vector. Si intentamos usar la segunda opción mid = (beg + end) / 2 podemos ver inmediatamente algunos problemas. Tanto beg como end son iteradores, la adición de iteradores no es legal. No tiene sentido agregar dos iteradores juntos, ya que son solo punteros a una dirección en la memoria, no proporcionaría ninguna información útil (resta lo hace tiene sentido ya que producirá una distancia basada en el tipo entre los dos iteradores como hemos visto anteriormente). Incluso si beg + end fuera legal, como end - beg, no produciría un iterador. Entonces Si esta definición era legal, mid sería un número en lugar de un iterador (puntero) al punto medio del vector.


1.6.1 Plan de lección de pasado simple

En la película BrainPOP ELL, The Thief Walked In (L1U6L1), Ben le cuenta a Moby sobre la extraña experiencia que tuvo cuando llegó a casa de la escuela el día anterior. En este plan de lección, adaptable para los grados K-8, los estudiantes practican la forma pasada simple de los verbos regulares.

Plan de lección Alineaciones con los estándares estatales básicos comunes

Serán estudiantes:

  1. Categorizar los verbos pasados ​​simples de acuerdo con sus sonidos finales.
  2. Vuelve a contar los eventos de la película usando una lista de verbos.
  3. Colabore en un proyecto de equipo para demostrar y enseñar creativamente una regla ortográfica.
  4. Invente una historia colaborativa en el pasado.

Materiales:

Vocabulario:

Procedimiento de la lección:

  1. Escuche los sonidos. Cuando agregamos -ed a los verbos, a veces suena como D (como en arrived) a veces suena como t (como en looked) y a veces suena como identificación (como en necesidaded). A continuación se muestran los verbos que los estudiantes han aprendido en películas BrainPOP ELL anteriores en el Nivel 1. A medida que pronuncia cada verbo en su forma pasada simple, escríbalo en la pizarra en una de las tres columnas de acuerdo con sus sonidos finales (d / t / id) pero no identifique las categorías. Después de algunos ejemplos, pida a los estudiantes que identifiquen las categorías. Continúe pronunciando y agregando verbos hasta que los estudiantes puedan identificar los patrones de sonidos finales. Desafíe a los estudiantes a probar sus conclusiones pidiéndoles que identifiquen en qué columna colocar los verbos restantes. / d / sonido:Amaba, lavaba, pasaba, jugaba, sonreía, vitoreaba, vivía, abría, escuchaba, recordaba, limpiaba./ t / sonido:gustaba, preguntaba, miraba, ayudaba, hablaba, tocaba, trabajaba, paraba, agradecía, brincaba, practicaba, adivinaba, caminaba, cocinaba./ id / sonido:necesitaba, quería, esperaba, odiaba, visitaba, empezaba.
  2. Categoriza los sonidos. Deje el cuadro de tres columnas de la Actividad 1 en la pizarra. Mientras los estudiantes miran la película BrainPOP ELL The Thief Walked In (L1U6L1), pídales que escriban todos los verbos en pasado regular que escuchan / ven. También puede asignar la tarea como tarea. Dígales a los estudiantes que pongan los verbos en las columnas correspondientes de acuerdo con sus sonidos finales. Con la lista de verbos aún en la pizarra, pida a los estudiantes que vuelvan a contar los eventos de la película usando la imagen de El ladrón como guía.
  3. Contar una historia. Después de que los estudiantes vuelvan a contar la historia de la película, pida a la clase que invente una nueva historia. Comience la historia proporcionando la primera oración. Por ejemplo, Oí un ruido terrible afuera anoche. Indíqueles que usen el tiempo pasado simple a medida que cada estudiante agrega una oración a la historia. Escriba la historia en la pizarra, papel cuadriculado o pizarra interactiva, a medida que la clase la crea. Cuando la historia esté completa, puede usarla como una actividad LEA (Enfoque de experiencia lingüística). Léanlo juntos como clase y usen su historia para practicar el vocabulario y el lenguaje, como rodear con un círculo todos los ejemplos de verbos en tiempo pasado.
  4. Demuestre las reglas ortográficas. La forma pasada simple de los verbos regulares tiene diferentes reglas de ortografía. Las cuatro reglas de ortografía se enumeran a continuación. Después de revisar las reglas, asigne una regla a cada pequeño grupo de estudiantes. Cada grupo debe decidir una forma de demostrar, enseñar y dar ejemplos de su regla ortográfica. Anímelos a que sean creativos con sus demostraciones. Puede proporcionar algunos ejemplos, como un póster, un cuestionario, un juego, una presentación de PowerPoint, una caricatura, un mini libro, una parodia, una canción, un poema, etc. A través de su demostración, deben explicar la regla y proporcionar ejemplos, incluidas las excepciones a su regla. Si bien cada estudiante es responsable de investigar, encontrar información y aportar ideas, es posible que desee asignar roles a cada miembro del grupo, según sus fortalezas, o hacer que los estudiantes dividan las tareas de acuerdo con los roles que elijan.Reglas ortográficas de los verbos regulares en pasado simple1. Con la mayoría de los verbos regulares, simplemente agregamos -ed a la forma base.Por ejemplo: suceder = sucedered.2. Con verbos que terminan en mi, añadimos D.Por ejemplo: sonrisa = sonrisaD, llegar = llegarD.3. Con verbos que terminan en consonante y y, dejamos caer el y y añadir -ied.Por ejemplo: probar = tried, llevar = carried.Excepción: si hay una vocal antes de la y, dejamos la y y solo agregamos -ed.Por ejemplo: jugar = jugared.4. Con los verbos de una sílaba que terminan en combinaciones de consonante-vocal-consonante (CVC), duplicamos la última consonante.Por ejemplo: detener = detenerped.Excepción: Con los verbos de dos sílabas, duplicamos la última consonante si el acento está en la última sílaba.Por ejemplo: admitir = admitirted.Pero cuando el acento está en la primera sílaba, simplemente agregamos -ed.Por ejemplo: escuchar = escuchared.

Actividad de ampliación

Había una anciana que tragó una mosca. Este es un poema y una canción populares para niños que está lleno de ejemplos de verbos regulares en tiempo pasado. Puede encontrar muchas versiones en YouTube y las palabras están disponibles en Internet. Antes de cantarlo con los alumnos, pueden realizar una actividad de Cloze, crear un cartel, crear sus propios libros con las palabras y las ilustraciones, o incluso representar una parodia.


2.6.3 Plan de lección de revisión de tiempo futuro

En la película BrainPOP ELL, ¿Qué veremos? (L2U6L3), Ben y Moby no pueden decidir qué película ver. En este plan de lección, adaptable para los grados K-8, los estudiantes hablan y escriben sobre eventos futuros y diferencian entre las cuatro formas del tiempo futuro: will + verbo, be going to + verbo, presente progresivo, y presente simple.

Plan de lección Alineaciones con los estándares estatales básicos comunes

Serán estudiantes:

  1. Haz predicciones basadas en una imagen.
  2. Diferenciar entre cuatro formas del tiempo futuro.
  3. Clasifica situaciones y ejemplos según las formas del tiempo futuro.
  4. Escriba y presente un diálogo con un compañero y escuche los detalles y ejemplos del tiempo futuro.
  5. Invente preguntas sobre el futuro y juegue el papel de un adivino.

Materiales:

Preparación:

Para la Actividad 3, Tiras de oraciones de Formas futuras, rotule 4 hojas de papel cuadriculado con cada una de las cuatro formas del tiempo futuro: Be Going to + Verbo / Will + Verbo / Presente progresivo / Presente simple. Haz tiras de oraciones para cada situación, así como para cada ejemplo. Utilice cartulina de un color diferente para la situación y tiras de ejemplo.

Sugerencias:
Presente progresivo
Situaciones: Planes futuros que ya están hechos
Ejemplos: Ella está cuidando niños el sábado por la noche. / Estoy trabajando esta noche.

Presente simple
Situaciones: Hechos o eventos establecidos / Horarios de películas, programas de televisión, viajes / Eventos en un calendario o programa
Ejemplos: La tienda abre a las 9:00 am. / ¿A qué hora sale mañana tu vuelo? / La reunión comienza a las 7:00.

Be Going to + Verbo
Situaciones: Planes u objetivos / predicciones futuros basados ​​en evidencia
Ejemplos: Voy a ser doctor. / Ella va a estudiar español el año que viene. / Mira esas nubes. Va a llover.

Will + Verbo
Situaciones: Evento futuro general / Predicciones sin evidencia / Promesas
Ejemplos: Te veré más tarde. / Creo que España ganará el próximo Mundial. / Limpiaré mi habitación mañana.

Procedimiento de la lección:

  1. Predice la historia. Muestre la imagen de apertura de ¿Qué veremos? (L2U6L3). Señale el póster de la película que Ben y Moby están mirando y pida a la clase que prediga de qué creen que se tratará la película. Escriba sus predicciones en la pizarra. Si usan diferentes formas del tiempo futuro, escriba las oraciones en columnas separadas, de acuerdo con la forma (be going to + verbo, will + verbo, presente progresivo, o presente simple).
  2. Preguntas rápidas sobre el futuro. Haga el siguiente ejercicio para que los estudiantes practiquen el uso de cada una de las cuatro formas futuras. Escriba las siguientes preguntas en la pizarra, uno a la vez. Después de escribir cada oración, y sin identificar la forma del tiempo futuro, u ofrecer una explicación, dé a los estudiantes un minuto para hacer y responder la pregunta con un compañero. Cuando hayan terminado, pregúnteles si notan alguna diferencia sobre cuándo usar cada forma de tiempo futuro. Esto servirá como introducción a la Actividad n. ° 3.


1.4.4 Tiene / tiene plan de lección

En la película BrainPOP ELL We Have a Good Time (L1U4L4), Ben mantiene a Moby adivinando quién es su mejor amigo al darle pistas sobre su identidad. Ben introduce el verbo presente simple tiene / tiene como describe a este misterioso mejor amigo. En este plan de lección, adaptable para los grados K-8, los estudiantes toman notas sobre las similitudes y diferencias que tienen, y describen y escuchan los detalles, usando el verbo tener.

Plan de lección Alineaciones con los estándares estatales básicos comunes

Serán estudiantes:

Materiales:

Vocabulario:

Procedimiento de la lección:

Igual y diferente. Trabajando en parejas, haga que los estudiantes tomen notas en un diagrama de Venn sobre cómo son iguales y diferentes. Luego, pueden usar las notas a medida que describen los rasgos que tienen o no tienen en común con la clase. Por ejemplo, los estudiantes pueden decir: Yo tengo ojos marrones y ella tiene ojos azuless. O, Ambos tenemos camisas rojas. Anime a los estudiantes a usar también lo negativo, como "Yo no tengo anteojos, pero él tiene anteojos". La clase puede agregar comparaciones que no se mencionaron.

Mi nombre es y tengo. Haga una actividad de Roundrobin con la clase. Indique a los estudiantes que digan sus nombres y un objeto que comience con la misma letra o sonido que sus nombres. Cada estudiante agrega su propio nombre y objeto, y luego repite lo que las personas anteriores han dicho.

Estudiante 1: Mi nombre es Sam. Tengo un sándwich.

Estudiante 2: Mi nombre es Kim. Tengo una cometa. Sam tiene un sándwich.

Estudiante 3: Mi nombre es Ben. Yo tengo un plátano. Kim tiene una cometa y Sam un sándwich ...

Describe y dibuja. Haga que todos los estudiantes hagan un dibujo de una persona e incluyan tantos detalles como puedan. Dígales que NO muestren sus fotos a sus parejas. Cuando han terminado, un estudiante describe la imagen usando tiene / tiene, y el compañero lo dibuja. Una vez completado, comparan los dos dibujos. Luego, los socios cambian de roles y lo vuelven a hacer.


Lógica socrática 3.1e: método socrático Preguntas platónicas

Acerca de

Esta nueva y revisada edición de Peter Kreeft & rsquos & # 160 Socratic Logic & # 160 se actualiza, agregando nuevos ejercicios y ejemplos más completos, todo con la claridad e ingenio característicos de Kreeft & rsquos. Desde su introducción en la primavera de 2004, Socratic Logic ha demostrado ser un tipo diferente de texto lógico:

(1) Este es el único sistema completo de lógica aristotélica clásica impreso. La "lógica antigua" sigue siendo la lógica natural de las cuatro artes del lenguaje (leer, escribir, hablar y escuchar). La lógica simbólica o "quomatemática" no es para las humanidades. (¿Con qué frecuencia ha escuchado a alguien discutir con lógica simbólica?)

(2) Este libro es simple y fácil de usar. Es muy interactivo, con una gran cantidad de ejercicios y un estilo ligero y atractivo.

(3) Es práctico. Está diseñado para aficionados al bricolaje y para aulas. Enfatiza temas en proporción al uso probable de los estudiantes: por ejemplo, interpretar el lenguaje ordinario, no solo analizar sino también construir argumentos efectivos, eliminar supuestos ocultos, hacer mapas de argumentos y usar el método socrático en diversas circunstancias.

(4) Es filosófico. Sus ejercicios exponen a los estudiantes a muchas citas clásicas, y los capítulos adicionales presentan cuestiones filosóficas de una manera socrática y desde un punto de vista realista y de sentido común. Prepara a los estudiantes para leer Grandes libros en lugar de Dick y Jane, y modela a Sócrates como el maestro y filósofo ideal para principiantes.


Ir2110 datasheet - ejercicio

####### VS Voltaje de compensación de suministro flotante del lado alto VB - 25 VB + 0.

####### VHO Voltaje de salida flotante del lado alto VS - 0.3 VB + 0.

####### VCC Voltaje de suministro fijo de lado bajo -0,3 25

####### VLO Voltaje de salida del lado bajo -0,3 VCC + 0.

####### VDD Voltaje de suministro lógico -0,3 VSS + 25

####### Voltaje de compensación de suministro lógico VSS VCC - 25 VCC + 0.

####### VIN Voltaje de entrada lógica (HIN, LIN y ampamp SD) VSS - 0.3 VDD + 0.

####### dVs / dt Tensión de alimentación de compensación permitida Transitoria (Figura 2) - 50 V / ns

####### Disipación de potencia del paquete PD @ TA ≤ + 25 ° C (14 derivaciones DIP) - 1.

####### (DIP de 16 derivaciones sin derivaciones 5 y ampamp 6) - 1.

####### RθJA Resistencia térmica, unión a ambiente (DIP de 14 conductores) - 75

####### (14 derivaciones DIP sin derivación 4) - 85

####### (16 derivaciones DIP sin derivaciones 5 y amperaje 6) - 75

####### Temperatura de unión TJ - 150

####### TS Temperatura de almacenamiento -55 150 ° C

####### TL Temperatura del cable (soldadura, 10 segundos) - 300

Valor de parámetro
Símbolo Definición Mín. Max. Unidades

####### VB Voltaje absoluto de suministro flotante de lado alto VS + 10 VS + 20

####### VS Voltaje de compensación de suministro flotante del lado alto Nota 1500

####### VHO Voltaje de salida flotante del lado alto VS VB

####### VCC Voltaje de suministro fijo de lado bajo 10 20

####### VLO Voltaje de salida del lado bajo 0 VCC

####### VDD Voltaje de suministro lógico VSS + 5 VSS + 20

####### Tensión de compensación de alimentación lógica VSS -5 5

####### VIN Voltaje de entrada lógica (HIN, LIN y ampamp SD) VSS VDD

####### TA Temperatura ambiente -40125 ° C

Índices absolutos máximos

####### Las clasificaciones máximas absolutas indican límites sostenidos más allá de los cuales se pueden producir daños en el dispositivo. Todos los parámetros de voltaje son

####### voltajes absolutos referenciados a COM. Las clasificaciones de resistencia térmica y disipación de energía se miden debajo de la tabla

####### montada y con aire en calma. En las Figuras 28 a 35 se muestra información adicional.

Condiciones de funcionamiento recomendadas

####### El diagrama de temporización de la lógica de entrada / salida se muestra en la Figura 1. Para un funcionamiento correcto, el dispositivo debe usarse dentro del

####### condiciones recomendadas. Las clasificaciones de compensación VS y VSS se prueban con todas las fuentes polarizadas a un diferencial de 15 V. Típico

Las clasificaciones ####### en otras condiciones de sesgo se muestran en las Figuras 36 y 37.

####### Nota 1: Lógica operativa para VS de -4 a + 500V. Estado lógico mantenido para VS de -4V a -VBS.


1.3 Pronóstico

Para pronosticar hacia adelante, podemos hacer uso del comando de predicción, donde en este caso estamos pronosticando 8 pasos hacia adelante. También buscamos hacer uso de intervalos de confianza del 95% para el pronóstico.

Estos también podrían mostrarse con la ayuda de fancharts para los pronósticos.


Tasas relativas de reacción

La velocidad de una reacción puede expresarse en términos del cambio en la cantidad de cualquier reactivo o producto, y puede derivarse simplemente de la estequiometría de la reacción. Considere la reacción representada por la siguiente ecuación:

Los factores estequiométricos derivados de esta ecuación se pueden usar para relacionar las velocidades de reacción de la misma manera que se usan con las cantidades relacionadas de reactivo y producto. La relación entre las velocidades de reacción expresadas en términos de producción de nitrógeno y consumo de amoníaco, por ejemplo, es:

Podemos expresar esto de manera más simple sin mostrar las unidades del factor estequiométrico:

Tenga en cuenta que se ha agregado un signo negativo para tener en cuenta los signos opuestos de los dos cambios de cantidad (la cantidad de reactivo disminuye mientras que la cantidad de producto aumenta). Si los reactivos y productos están presentes en la misma solución, las cantidades molares pueden reemplazarse por concentraciones:

Del mismo modo, la tasa de formación de H2 es tres veces la tasa de formación de N2, porque tres moles de H2 forma durante el tiempo necesario para la formación de un mol de N2:

La Figura 4 ilustra el cambio en las concentraciones a lo largo del tiempo para la descomposición del amoníaco en nitrógeno e hidrógeno a 1100 ° C. Podemos ver desde las pendientes de las tangentes dibujadas en t = 500 segundos que las tasas instantáneas de cambio en las concentraciones de los reactivos y productos están relacionadas por sus factores estequiométricos. Se observa, por ejemplo, que la tasa de producción de hidrógeno es tres veces mayor que la de la producción de nitrógeno:

Ejemplo 1

Expresiones para tasas de reacción relativas

El primer paso en la producción de ácido nítrico es la combustión de amoníaco:

Escribe las ecuaciones que relacionen las tasas de consumo de los reactivos y las tasas de formación de los productos.

Solución

Considerando la estequiometría de esta reacción homogénea, las tasas de consumo de reactivos y formación de productos son:

Compruebe su aprendizaje

La tasa de formación de Br2 es [látex] 6.0 veces <10> ^ <-6> [/ látex] mol / L / s en una reacción descrita por la siguiente ecuación iónica neta:

Escribe las ecuaciones que relacionen las tasas de consumo de los reactivos y las tasas de formación de los productos.

Ejemplo 2

Expresiones de tasa de reacción para la descomposición de H2O2

El gráfico de la Figura 4 muestra la tasa de descomposición de H2O2 tiempo extraordinario:

Con base en estos datos, la tasa instantánea de descomposición de H2O2 a t = 11.1 h se determina que es [látex] 3.20 times <10> ^ <-2> [/ látex] mol / L / h, es decir:

¿Cuál es la tasa instantánea de producción de H?2O y O2?

Solución

Usando la estequiometría de la reacción, podemos determinar que:

Compruebe su aprendizaje

Si la tasa de descomposición del amoníaco, NH3, a 1150 K es 2.10 × 10 -6 mol / L / s, ¿cuál es la tasa de producción de nitrógeno e hidrógeno?


Entrada / salida de archivos C ++

Un archivo es una colección de datos relacionados. C ++ trata un archivo como una serie de bytes. Muchos archivos residen en el disco; sin embargo, los dispositivos como impresoras, cintas magnéticas y líneas de comunicación también se consideran archivos.

Este capítulo analiza tres paquetes de E / S diferentes. La primera son las clases de flujo de E / S de C ++. Este es el sistema de E / S más utilizado y el que hemos estado utilizando hasta ahora. A continuación, examinamos las rutinas de E / S sin procesar que nos dan acceso directo a las E / S de bajo nivel. Finalmente miramos el sistema C I / O. Aunque está algo desactualizado, las llamadas de E / S C todavía aparecen en código antiguo. Además, en algunos casos, las rutinas de E / S de estilo C son superiores a las proporcionadas con C ++.

E / S de archivos C ++

La E / S de archivos C ++ se basa en tres clases: la clase istream para entrada, la clase ostream para salida y la clase iostream para entrada / salida. C ++ se refiere a los archivos como flujos ya que los considera un flujo de bytes. Se crean automáticamente cuatro variables de clase cuando inicia un programa. Estos se enumeran en la Tabla 16-1.

Entrada de consola (entrada estándar)

Salida de consola (salida estándar)

Error de consola (error estándar)

Estas variables se definen en el archivo de inclusión estándar & ltiostream & gt. Normalmente, std :: cin se asigna al teclado y std :: cout, std :: cerr y std :: clog se asignan a la pantalla. La mayoría de los sistemas operativos le permiten cambiar estas asignaciones a través de la redirección de E / S (consulte el manual de su sistema operativo para obtener más detalles).

Si desea leer una línea de datos, debe usar la función getline. Se define como: [1]

Rutinas de conversión

Hasta ahora solo hemos considerado escribir caracteres y cadenas. En esta sección, consideramos algunas de las operaciones de E / S más sofisticadas: conversiones.

Para escribir un número en una impresora o terminal, debe convertir el número a caracteres. La impresora solo entiende caracteres, no números. Por ejemplo, el número 567 debe convertirse a los tres caracteres & quot5 & quot, & quot6 & quot y & quot7 & quot; para imprimir.

El operador & lt & lt se utiliza para convertir datos en caracteres y ponerlos en un archivo. Esta función es extremadamente flexible. Puede convertir un entero simple en una cadena de tamaño fijo o variable como un número hexadecimal, octal o decimal con justificación a la izquierda oa la derecha. Hasta ahora, ha estado utilizando la conversión predeterminada para su salida. Sirve bastante bien, pero si desea controlar su salida exactamente, necesita aprender sobre los indicadores de conversión.

Las funciones miembro setf y unsetf se utilizan para establecer y borrar los indicadores que controlan el proceso de conversión. La forma general de las funciones es:

El resultado de este programa es:

Sugerencia: Aquí hay un volcado hexadecimal del archivo MS-DOS / Windows:

Número real de bytes escritos. Un número negativo indica un error.

Descriptor de archivo de un archivo abierto.

Puntero a los datos que se van a escribir.

Tamaño de los datos a escribir. El sistema intentará escribir esta cantidad de bytes, pero si el dispositivo está lleno o hay algún otro problema, se puede escribir una cantidad menor de bytes.

Finalmente, la llamada de cierre cierra el archivo:

0 para éxito, negativo para error.

Descriptor de archivo de un archivo abierto.

El ejemplo 16-5 copia un archivo. Se utilizan E / S sin búfer debido al gran tamaño del búfer. No tiene sentido usar E / S en búfer para leer 1K de datos en un búfer (usando un std :: ifstream) y luego transferirlo a un búfer de 16K.

Se deben tener en cuenta varias cosas sobre este programa. En primer lugar, el tamaño del búfer se define como una constante, por lo que se modifica fácilmente. En lugar de tener que recordar que 16K son 16,384, el programador usó la expresión (16 * 1024). Esta forma de la constante es obviamente 16K.

Si el usuario usa incorrectamente el programa, aparece un mensaje de error. Para ayudar al usuario a hacerlo bien, el mensaje le dice cómo usar el programa.

Es posible que no lea un búfer completo para la última lectura. Es por eso que read_size se usa para determinar el número de bytes a escribir.

Diseño de formatos de archivo

Suponga que está diseñando un programa para producir un gráfico. La altura, el ancho, los límites y las escalas deben definirse en un archivo de configuración de gráfico. También se le asigna la tarea de escribir un programa fácil de usar que le haga preguntas al operador y escriba un archivo de configuración para que no tenga que aprender el editor de texto. ¿Cómo debería diseñar un archivo de configuración?

Una forma sería la siguiente:

Un archivo de configuración de trazador típico podría verse así:

Existe una función similar, std :: fputc, para escribir un solo carácter. Su formato es:

¿Por qué 21/7 = 0? (Sus resultados pueden variar).

Ejemplo 16-8:
float3 / float3.c

The function std::fprintf is similar to std::printf except that it takes one additional argument, the file to print to:

C- Versus C++- Style I/O

Both C- and C++- style I/O have their own features and quirks. In this section we’ll discuss some of the differences between these two systems.

Sencillez

Let’s say we want to write a simple checkbook program. We need to print an account statement. We need some code to print each line of the account statement (date, check number, payee, and amount).

In C the print statement looks like:

std::printf("%2d/%2d/%02d %4d: %-40s %f6.2\n",
check.date.month, check.date.day, check.date.year,
check.number, check.payee, check.amount)

In C++ the print statement is:

From this example we can clearly see that the C-style I/O is more compact. It is not clear that compact is better. This author prefers the compact style of the C std::printf functions, while many others prefer the verbosity of the C++ I/O system. Besides if you’re C++ programmers, you probably should program in C++ and not bring legacy I/O systems into the mix.

Although it looks like C is more compact, things are not as obvious as they look. A well-designed date class would have its own output operator. Thus we can simplify our C++ code down to:

But this assumes that only the date has an output operator. If we designed our check class correctly, it should have one as well. This means that our code now has been simplified down to:

Now this doesn’t mean that complexity has gone away. It’s merely been moved from outside the class to inside it.

This example serves to illustrate one of the key differences between C and C++. In C-style I/O, the information on how to manipulate the data (in this case, how to print it) is contained outside the data itself. In C++ it’s possible to put the manipulation code and the data into a single class.

If we are writing out our checkbook information in only one place, the C version may be simpler and easier to work with. So for simple programs, you may want to consider using C-style I/O. But suppose that we wanted to print out the data to a number of places. If we used C-style I/O, we would have to replicate our format code all over the place or create a small function to do the printing. With C++’s classes, we can keep the printing information in one logical place. (As a person who’s just had to rewrite all the C-style format statements in a rather large piece of code, I can tell you that putting the formatting information in one place, the object, has some advantages.)

Reliability

When you use C++-style I/O, the system automatically detects the type of the variable and performs the approbate conversion. It’s impossible to get the types wrong.

With C-style I/O, it’s easy to get the arguments to a std::printf mixed up, resulting in very strange results when you run the program. What’s worse is that most compilers do not check std::printf calls and warn you if you make a mistake.

One special C I/O function you should be aware of is std::gets . This function gets a line from standard input with no bounds-checking. So:

std::fgets(line, INFINITY, stdin)

If there are too many characters in an input line, the std::gets function will cause a buffer overflow and trash memory. This single function and its lack of bounds-checking has to be responsible for more crashes and security holes than any other single C function.[2] You should never use it. You can get in enough trouble with the more reliable C functions without having to play Russian roulette with this one.

Speed

I’ve done some benchmarks on C and C++ I/O for binary files. In general I’ve found the C I/O to be much faster. That’s because the C I/O system is less flexible and has to deal with less overhead than the C++ system.

TIP:
I’m not talking about formatted I/O, just raw binary I/O. If you do formatted I/O in either system, you can expect your speed to go down tremendously. It’s the single slowest system in the entire C and C++ library.

Which Should You Use?

Which I/O system is best? That depends on a large number of factors. First of all, any system you know is always going to be easier to use and more reliable than a system you don’t know.

However, if you know both systems, C-style I/O is good for the simple stuff. If you’re not doing anything fancy with classes and just want to write simple formatted reports, the C I/O system will do the job. However, for larger jobs, the C++-object oriented system with its object-oriented I/O system handles complexity and organizes complex information much better than C-style I/O.

But if you’re learning I/O for the first time, I suggest that you stick with one I/O system, the C++ one. Learn C-style I/O only if you’re forced to. (Say, for instance, you have to maintain some legacy code that uses the old C-style system.)

Programming Exercises

Write a program that reads a file and counts the number of lines in it.

Write a program to copy a file, expanding all tabs to multiple spaces. (For historical reasons–the Teletype again–almost all text files use a tab setting of 8 characters.)

Write a program that reads a file containing a list of numbers and writes two files, one containing all the numbers divisible by 3 and another containing all the other numbers.

Write a program that reads an ASCII file containing a list of numbers and writes a binary file containing the same list. Write a program that goes the other way so you can check your work.

Write a program that copies a file and removes all characters with the high bit set ( ((ch & 0x80) != 0) ).

Design a file format to store a person’s name, address, and other information. Write a program to read this file and produce a file containing a set of mailing labels.

Answers to Chapter Questions

The problem is that you are writing an ASCII file, but you wanted a binary file. In Unix, ASCII is the same as binary, so the program runs fine. In MS-DOS/Windows, the end-of-line issue causes problems. When you write a newline character (0x0a) to the file, a carriage return (0x0D) is added to the file. (Remember that end-of-line in MS-DOS/Windows is <carriage return><line feed>, or 0x0d, 0x0a.) Because of this editing, you get an extra carriage return (0x0d) in the output file.

To write binary data (without output editing) you need to open the file with the binary option:

out_file.open("test.out", std::ios::out | std::ios::binary)

The std::printf call does not check for the correct number of parameters. The statement:

tells the std::printf to print the string "The answer is" followed by the answer. The problem is that the parameter containing the answer was omitted. When this happens, std::printf gets the answer from a random location and prints garbage.

Properly written, the std::printf statement is:

std::printf("The answer is %d\n", answer)

The std::printf call does not check the type of its parameters. You tell std::printf to print an integer number ( %d ) and supply it with a floating-point parameter ( result ). This mismatch causes unexpected results, such as printing the wrong answer.

When printing a floating-point number, you need a %f conversion. Properly written, our std::printf statement is:

std::printf("The answer is %f\n", result)

The problem is that std::fgets gets the entire line, including the newline character ( \n ). If you have a file named sam, the program reads sam\n and tries to look for a file by that name. Because there is no such file, the program reports an error.

The fix is to strip the newline character from the name:

name[strlen(name) – 1] = ‘Θ’ /* Get rid of last character */

The error message in this case is poorly designed. True, you did not open the file, but the programmer could supply the user with more information. Are you trying to open the file for input or output? What is the name of the file you are trying to open? You don’t even know whether the message you are getting is an error, a warning, or just part of the normal operation. A better error message is:

std::fprintf(stderr, "Error: Unable to open %s for input\n", name)

Notice that this message would also help us detect the programming error. When you typed in "sam", the error would be:

Error: Unable to open sam
for input

This clearly shows us that you are trying to open a file with a newline in its name.

1.
If you take a look at the C++ standard, you’ll notice that the formal definition of these functions is somewhat more complex. I’ve simplified the definition for this book, but this definition is compatible with the formal one.

2.
As I am writing this, Microsoft has just released a security patch to Windows XP to fix a buffer overflow bug.


Ver el vídeo: hibbeler estatica ejercicios de estatica hibbeler capitulo 2, decomposição de vetores força (Septiembre 2021).