$ \frac{dy}{dx} $

Interpolación

Variar perfil

Elegir intervalo

Punto en la gráfica

Punto móvil en eje X

Gráfica

Extremos intervalo

Extremos absolutos

Banda horizontal

% inclinación en P

Tasa de Variación Media

Ángulo de inclinación

Recta de pendiente media

Recta tangente

Vector unitario tangente

Función derivada

Extremos relativos

Vector unitario curvatura

Círculo osculador

Función 2ª derivada

Puntos inflexión

Función área (Animación)

Primitiva de la derivada

F(x) =

a

b

Gráfica

Recorrido

T.V.M.

Primera derivada

Segunda derivada

Integral

0 \; \%

Trapecios

Coordenadas

Recorrido: [2, 5]

nada = 0.9 (slider from 0 to 1, step 0.1)
epsilon = 1.0E-6
panel0 = 6 (slider from 1 to 6, step 1)
panel: round(7 - panel0)
J = (-0.75, 2.5)
H = (-0.8866666666666674, 6.14)
I = (1.953333333333338, 2.86)
K = (1.6333333333333375, 1.8)
Vesq1 = (1.0E-5, 1.5)
Se0 = (-4.060000000000001, 3.479999999999998)
Se1: Se0 + (0.88, 1.6)
Se2: Se0 + (1.14, 1.6)
E1 = 1
E2 = 2
E3: (2 * E2) - E1
E4: (2 * E3) - E2
E5: (2 * E4) - E3
E6: (2 * E5) - E4
E7: (2 * E6) - E5
E8: (2 * E7) - E6
E9: (2 * E8) - E7
E10: (2 * E9) - E8
E11: (2 * E10) - E9
E12: (2 * E11) - E10
E13: (2 * E12) - E11
E14: (2 * E13) - E12
E15: (2 * E14) - E13
E16: (2 * E15) - E14
E17: (2 * E16) - E15
E18: (2 * E17) - E16
E19: (2 * E18) - E17
E20: (2 * E19) - E18
G1 = true
G2 = true
G3 = true
G4 = true
G5 = true
G6 = false
G7 = true
G8 = true
G9 = true
G10 = true
G11 = true
G12 = true
G13 = true
G14 = true
G15 = true
G16 = true
G17 = true
G18 = true
G19 = true
listaG: G1:G19
n = 12 (slider from 3 to 20, step 1)
Vesq2 = Point(Ray[Vesq1 + (0.2, 0), Vesq1 + (1, 0)])
Vesq3 = Point(Ray[Vesq2 + (0, 0.2), Vesq2 + (0, 1)])
ancho: x(Vesq2 - Vesq1)
alto: y(Vesq3 - Vesq1)
m: round(n)
h: ancho / (m - 1)
B1 = Segment(Vesq1 + ((E1 - 1) * (h, 0)), Vesq1 + ((E1 - 1) * (h, 0)) + (0, alto))
B2 = Segment(Vesq1 + ((E2 - 1) * (h, 0)), Vesq1 + ((E2 - 1) * (h, 0)) + (0, alto))
B3 = Segment(Vesq1 + ((E3 - 1) * (h, 0)), Vesq1 + ((E3 - 1) * (h, 0)) + (0, alto))
B4 = Segment(Vesq1 + ((E4 - 1) * (h, 0)), Vesq1 + ((E4 - 1) * (h, 0)) + (0, alto))
B5 = Segment(Vesq1 + ((E5 - 1) * (h, 0)), Vesq1 + ((E5 - 1) * (h, 0)) + (0, alto))
B6 = Segment(Vesq1 + ((E6 - 1) * (h, 0)), Vesq1 + ((E6 - 1) * (h, 0)) + (0, alto))
B7 = Segment(Vesq1 + ((E7 - 1) * (h, 0)), Vesq1 + ((E7 - 1) * (h, 0)) + (0, alto))
B8 = Segment(Vesq1 + ((E8 - 1) * (h, 0)), Vesq1 + ((E8 - 1) * (h, 0)) + (0, alto))
B9 = Segment(Vesq1 + ((E9 - 1) * (h, 0)), Vesq1 + ((E9 - 1) * (h, 0)) + (0, alto))
B10 = Segment(Vesq1 + ((E10 - 1) * (h, 0)), Vesq1 + ((E10 - 1) * (h, 0)) + (0, alto))
B11 = Segment(Vesq1 + ((E11 - 1) * (h, 0)), Vesq1 + ((E11 - 1) * (h, 0)) + (0, alto))
B12 = Segment(Vesq1 + ((E12 - 1) * (h, 0)), Vesq1 + ((E12 - 1) * (h, 0)) + (0, alto))
B13 = Segment(Vesq1 + ((E13 - 1) * (h, 0)), Vesq1 + ((E13 - 1) * (h, 0)) + (0, alto))
B14 = Segment(Vesq1 + ((E14 - 1) * (h, 0)), Vesq1 + ((E14 - 1) * (h, 0)) + (0, alto))
B15 = Segment(Vesq1 + ((E15 - 1) * (h, 0)), Vesq1 + ((E15 - 1) * (h, 0)) + (0, alto))
B16 = Segment(Vesq1 + ((E16 - 1) * (h, 0)), Vesq1 + ((E16 - 1) * (h, 0)) + (0, alto))
B17 = Segment(Vesq1 + ((E17 - 1) * (h, 0)), Vesq1 + ((E17 - 1) * (h, 0)) + (0, alto))
B18 = Segment(Vesq1 + ((E18 - 1) * (h, 0)), Vesq1 + ((E18 - 1) * (h, 0)) + (0, alto))
B19 = Segment(Vesq1 + ((E19 - 1) * (h, 0)), Vesq1 + ((E19 - 1) * (h, 0)) + (0, alto))
B20 = Segment(Vesq1 + ((E20 - 1) * (h, 0)), Vesq1 + ((E20 - 1) * (h, 0)) + (0, alto))
A1 = Point(B1)
A2 = Point(B2)
A3 = Point(B3)
A4 = Point(B4)
A5 = Point(B5)
A6 = Point(B6)
A7 = Point(B7)
A8 = Point(B8)
A9 = Point(B9)
A10 = Point(B10)
A11 = Point(B11)
A12 = Point(B12)
A13 = Point(B13)
A14 = Point(B14)
A15 = Point(B15)
A16 = Point(B16)
A17 = Point(B17)
A18 = Point(B18)
A19 = Point(B19)
A20 = Point(B20)
L: A1:A20
Lm = First(L, m)
Aa: A1
Az = Element(Last[Lm], 1)
Lx: x(Lm)
Ly: y(Lm)
Ls = Sequence(Element[Ly, k + 1] - Element[Ly, k], k, 1, m - 1)
M = Sequence(Sequence[If[j ≟ m - 1, (6 / h * (Element[Ls, i + 1] - Element[Ls, i])), If[j ≟ i + 1 ∨ j ≟ i - 1, h, If[j ≟ i, (4 * h), 0]]], j, 1, m - 1], i, 1, m - 2)
Me = ReducedRowEchelonForm(M)
Mi = Join({{0}, Sequence[Element[Me, k, m - 1], k, 1, m - 2], {0}})
d2F = Sequence(Element[Mi, k] + ((Element[Mi, k + 1] - Element[Mi, k]) / h * (x - Element[Lx, k])), k, 1, m - 1)
base = Segment((Element[Lx, 1], 0), (Element[Lx, m], 0))
X = Point(base)
i = Ray(Aa, ((x(Az), y(Aa)) + Az) / 2)
intervalos = Sequence(If[x(X) > Element[Lx, k], 1, 0], k, 1, m)
itv = Max(1, Length[KeepIf[x > 0, intervalos]])
d2gP: (Element[listaG, itv] * Element[IterationList[Element[d2F, itv], x(X), 1], 2])
extr1 = Sequence((If[0 < (((((-Element[Mi, k])) / 2 + sqrt(Element[Mi, k]^(2) / 4 - ((3 * (Element[Ls, k] / h - (Element[Mi, k] * h / 3) - (Element[Mi, k + 1] * h / 6))) * (Element[Mi, k + 1] - Element[Mi, k]) / ((6 * h))))) * 2) * h / (Element[Mi, k + 1] - Element[Mi, k])) ∧ (((((-Element[Mi, k])) / 2 + sqrt(Element[Mi, k]^(2) / 4 - ((3 * (Element[Ls, k] / h - (Element[Mi, k] * h / 3) - (Element[Mi, k + 1] * h / 6))) * (Element[Mi, k + 1] - Element[Mi, k]) / ((6 * h))))) * 2) * h / (Element[Mi, k + 1] - Element[Mi, k])) < h, Element[Lx, k] + (((((-Element[Mi, k])) / 2 + sqrt(Element[Mi, k]^(2) / 4 - ((3 * (Element[Ls, k] / h - (Element[Mi, k] * h / 3) - (Element[Mi, k + 1] * h / 6))) * (Element[Mi, k + 1] - Element[Mi, k]) / ((6 * h))))) * 2) * h / (Element[Mi, k + 1] - Element[Mi, k]))], k), k, 1, m - 1)
extr2 = Sequence((If[0 < (((((-Element[Mi, k])) / 2 - sqrt(Element[Mi, k]^(2) / 4 - ((3 * (Element[Ls, k] / h - (Element[Mi, k] * h / 3) - (Element[Mi, k + 1] * h / 6))) * (Element[Mi, k + 1] - Element[Mi, k]) / ((6 * h))))) * 2) * h / (Element[Mi, k + 1] - Element[Mi, k])) ∧ (((((-Element[Mi, k])) / 2 - sqrt(Element[Mi, k]^(2) / 4 - ((3 * (Element[Ls, k] / h - (Element[Mi, k] * h / 3) - (Element[Mi, k + 1] * h / 6))) * (Element[Mi, k + 1] - Element[Mi, k]) / ((6 * h))))) * 2) * h / (Element[Mi, k + 1] - Element[Mi, k])) < h, Element[Lx, k] + (((((-Element[Mi, k])) / 2 - sqrt(Element[Mi, k]^(2) / 4 - ((3 * (Element[Ls, k] / h - (Element[Mi, k] * h / 3) - (Element[Mi, k + 1] * h / 6))) * (Element[Mi, k + 1] - Element[Mi, k]) / ((6 * h))))) * 2) * h / (Element[Mi, k + 1] - Element[Mi, k]))], k), k, 1, m - 1)
extr3 = Sort(Join[{extr1, extr2}])
extr4 = Sequence(If[Element[listaG, y(Element[extr3, k])], Element[extr3, k]], k, 1, Length[extr3])
v = 5 (slider from 1 to 9, step 1)
F1 = Function(Element[Ly, E1] + ((Element[Ls, E1] / h - ((Element[listaG, E1] * (Element[Mi, E1] + Element[Mi, E2] / 2)) * h / 3)) * (x - Element[Lx, E1])) + (Element[listaG, E1] * ((Element[Mi, E1] / 2 * (x - Element[Lx, E1])^(2)) + ((Element[Mi, E2] - Element[Mi, E1]) / ((6 * h)) * (x - Element[Lx, E1])^(3)))), Element[Lx, E1], Element[Lx, E2])
F2 = Function(Element[Ly, E2] + ((Element[Ls, E2] / h - ((Element[listaG, E2] * (Element[Mi, E2] + Element[Mi, E3] / 2)) * h / 3)) * (x - Element[Lx, E2])) + (Element[listaG, E2] * ((Element[Mi, E2] / 2 * (x - Element[Lx, E2])^(2)) + ((Element[Mi, E3] - Element[Mi, E2]) / ((6 * h)) * (x - Element[Lx, E2])^(3)))), Element[Lx, E2], Element[Lx, E3])
F3 = Function(Element[Ly, E3] + ((Element[Ls, E3] / h - ((Element[listaG, E3] * (Element[Mi, E3] + Element[Mi, E4] / 2)) * h / 3)) * (x - Element[Lx, E3])) + (Element[listaG, E3] * ((Element[Mi, E3] / 2 * (x - Element[Lx, E3])^(2)) + ((Element[Mi, E4] - Element[Mi, E3]) / ((6 * h)) * (x - Element[Lx, E3])^(3)))), Element[Lx, E3], Element[Lx, E4])
F4 = Function(Element[Ly, E4] + ((Element[Ls, E4] / h - ((Element[listaG, E4] * (Element[Mi, E4] + Element[Mi, E5] / 2)) * h / 3)) * (x - Element[Lx, E4])) + (Element[listaG, E4] * ((Element[Mi, E4] / 2 * (x - Element[Lx, E4])^(2)) + ((Element[Mi, E5] - Element[Mi, E4]) / ((6 * h)) * (x - Element[Lx, E4])^(3)))), Element[Lx, E4], Element[Lx, E5])
F5 = Function(Element[Ly, E5] + ((Element[Ls, E5] / h - ((Element[listaG, E5] * (Element[Mi, E5] + Element[Mi, E6] / 2)) * h / 3)) * (x - Element[Lx, E5])) + (Element[listaG, E5] * ((Element[Mi, E5] / 2 * (x - Element[Lx, E5])^(2)) + ((Element[Mi, E6] - Element[Mi, E5]) / ((6 * h)) * (x - Element[Lx, E5])^(3)))), Element[Lx, E5], Element[Lx, E6])
F6 = Function(Element[Ly, E6] + ((Element[Ls, E6] / h - ((Element[listaG, E6] * (Element[Mi, E6] + Element[Mi, E7] / 2)) * h / 3)) * (x - Element[Lx, E6])) + (Element[listaG, E6] * ((Element[Mi, E6] / 2 * (x - Element[Lx, E6])^(2)) + ((Element[Mi, E7] - Element[Mi, E6]) / ((6 * h)) * (x - Element[Lx, E6])^(3)))), Element[Lx, E6], Element[Lx, E7])
F7 = Function(Element[Ly, E7] + ((Element[Ls, E7] / h - ((Element[listaG, E7] * (Element[Mi, E7] + Element[Mi, E8] / 2)) * h / 3)) * (x - Element[Lx, E7])) + (Element[listaG, E7] * ((Element[Mi, E7] / 2 * (x - Element[Lx, E7])^(2)) + ((Element[Mi, E8] - Element[Mi, E7]) / ((6 * h)) * (x - Element[Lx, E7])^(3)))), Element[Lx, E7], Element[Lx, E8])
F8 = Function(Element[Ly, E8] + ((Element[Ls, E8] / h - ((Element[listaG, E8] * (Element[Mi, E8] + Element[Mi, E9] / 2)) * h / 3)) * (x - Element[Lx, E8])) + (Element[listaG, E8] * ((Element[Mi, E8] / 2 * (x - Element[Lx, E8])^(2)) + ((Element[Mi, E9] - Element[Mi, E8]) / ((6 * h)) * (x - Element[Lx, E8])^(3)))), Element[Lx, E8], Element[Lx, E9])
F9 = Function(Element[Ly, E9] + ((Element[Ls, E9] / h - ((Element[listaG, E9] * (Element[Mi, E9] + Element[Mi, E10] / 2)) * h / 3)) * (x - Element[Lx, E9])) + (Element[listaG, E9] * ((Element[Mi, E9] / 2 * (x - Element[Lx, E9])^(2)) + ((Element[Mi, E10] - Element[Mi, E9]) / ((6 * h)) * (x - Element[Lx, E9])^(3)))), Element[Lx, E9], Element[Lx, E10])
F10 = Function(Element[Ly, E10] + ((Element[Ls, E10] / h - ((Element[listaG, E10] * (Element[Mi, E10] + Element[Mi, E11] / 2)) * h / 3)) * (x - Element[Lx, E10])) + (Element[listaG, E10] * ((Element[Mi, E10] / 2 * (x - Element[Lx, E10])^(2)) + ((Element[Mi, E11] - Element[Mi, E10]) / ((6 * h)) * (x - Element[Lx, E10])^(3)))), Element[Lx, E10], Element[Lx, E11])
F11 = Function(Element[Ly, E11] + ((Element[Ls, E11] / h - ((Element[listaG, E11] * (Element[Mi, E11] + Element[Mi, E12] / 2)) * h / 3)) * (x - Element[Lx, E11])) + (Element[listaG, E11] * ((Element[Mi, E11] / 2 * (x - Element[Lx, E11])^(2)) + ((Element[Mi, E12] - Element[Mi, E11]) / ((6 * h)) * (x - Element[Lx, E11])^(3)))), Element[Lx, E11], Element[Lx, E12])
F12 = Function(Element[Ly, E12] + ((Element[Ls, E12] / h - ((Element[listaG, E12] * (Element[Mi, E12] + Element[Mi, E13] / 2)) * h / 3)) * (x - Element[Lx, E12])) + (Element[listaG, E12] * ((Element[Mi, E12] / 2 * (x - Element[Lx, E12])^(2)) + ((Element[Mi, E13] - Element[Mi, E12]) / ((6 * h)) * (x - Element[Lx, E12])^(3)))), Element[Lx, E12], Element[Lx, E13])
F13 = Function(Element[Ly, E13] + ((Element[Ls, E13] / h - ((Element[listaG, E13] * (Element[Mi, E13] + Element[Mi, E14] / 2)) * h / 3)) * (x - Element[Lx, E13])) + (Element[listaG, E13] * ((Element[Mi, E13] / 2 * (x - Element[Lx, E13])^(2)) + ((Element[Mi, E14] - Element[Mi, E13]) / ((6 * h)) * (x - Element[Lx, E13])^(3)))), Element[Lx, E13], Element[Lx, E14])
F14 = Function(Element[Ly, E14] + ((Element[Ls, E14] / h - ((Element[listaG, E14] * (Element[Mi, E14] + Element[Mi, E15] / 2)) * h / 3)) * (x - Element[Lx, E14])) + (Element[listaG, E14] * ((Element[Mi, E14] / 2 * (x - Element[Lx, E14])^(2)) + ((Element[Mi, E15] - Element[Mi, E14]) / ((6 * h)) * (x - Element[Lx, E14])^(3)))), Element[Lx, E14], Element[Lx, E15])
F15 = Function(Element[Ly, E15] + ((Element[Ls, E15] / h - ((Element[listaG, E15] * (Element[Mi, E15] + Element[Mi, E16] / 2)) * h / 3)) * (x - Element[Lx, E15])) + (Element[listaG, E15] * ((Element[Mi, E15] / 2 * (x - Element[Lx, E15])^(2)) + ((Element[Mi, E16] - Element[Mi, E15]) / ((6 * h)) * (x - Element[Lx, E15])^(3)))), Element[Lx, E15], Element[Lx, E16])
F16 = Function(Element[Ly, E16] + ((Element[Ls, E16] / h - ((Element[listaG, E16] * (Element[Mi, E16] + Element[Mi, E17] / 2)) * h / 3)) * (x - Element[Lx, E16])) + (Element[listaG, E16] * ((Element[Mi, E16] / 2 * (x - Element[Lx, E16])^(2)) + ((Element[Mi, E17] - Element[Mi, E16]) / ((6 * h)) * (x - Element[Lx, E16])^(3)))), Element[Lx, E16], Element[Lx, E17])
F17 = Function(Element[Ly, E17] + ((Element[Ls, E17] / h - ((Element[listaG, E17] * (Element[Mi, E17] + Element[Mi, E18] / 2)) * h / 3)) * (x - Element[Lx, E17])) + (Element[listaG, E17] * ((Element[Mi, E17] / 2 * (x - Element[Lx, E17])^(2)) + ((Element[Mi, E18] - Element[Mi, E17]) / ((6 * h)) * (x - Element[Lx, E17])^(3)))), Element[Lx, E17], Element[Lx, E18])
F18 = Function(Element[Ly, E18] + ((Element[Ls, E18] / h - ((Element[listaG, E18] * (Element[Mi, E18] + Element[Mi, E19] / 2)) * h / 3)) * (x - Element[Lx, E18])) + (Element[listaG, E18] * ((Element[Mi, E18] / 2 * (x - Element[Lx, E18])^(2)) + ((Element[Mi, E19] - Element[Mi, E18]) / ((6 * h)) * (x - Element[Lx, E18])^(3)))), Element[Lx, E18], Element[Lx, E19])
F19 = Function(Element[Ly, E19] + ((Element[Ls, E19] / h - ((Element[listaG, E19] * (Element[Mi, E19] + Element[Mi, E20] / 2)) * h / 3)) * (x - Element[Lx, E19])) + (Element[listaG, E19] * ((Element[Mi, E19] / 2 * (x - Element[Lx, E19])^(2)) + ((Element[Mi, E20] - Element[Mi, E19]) / ((6 * h)) * (x - Element[Lx, E19])^(3)))), Element[Lx, E19], Element[Lx, E20])
listaF: F1:F19
LySup = Sequence(Element[IterationList[Element[listaF, k], Element[Lx, k] + epsilon, 1], 2], k, 1, m - 1)
LyInf = Sequence(Element[IterationList[Element[listaF, k - 1], Element[Lx, k] - epsilon, 1], 2], k, 1, m - 1)
LyPicos = Sequence(If[Element[LyInf, k] ≤ Element[Ly, k] ∧ Element[LySup, k] < Element[Ly, k] ∨ Element[LyInf, k] > Element[Ly, k] ∧ Element[LySup, k] ≥ Element[Ly, k], k], k, 1, m - 1)
g = Element(listaF, itv)
P: (x(X), g(X))
segPX = Segment(P, X)
rectaTangente = Line(P, (x(X) + epsilon, g(x(X) + epsilon)))
dgP = Slope(rectaTangente)
DF: X + (0, dgP)
tangente = UnitVector(Vector[P, P + (1, dgP)])
d1 = Segment(P + (1, 0), P + (1, dgP))
d2 = Segment(X, DF)
ExtremosPicos = Sequence(Element[L, Element[LyPicos, k]], k, 1, m - 1)
ExtremosCub = Sequence((x(Element[extr4, k]), Element[IterationList[Element[listaF, y(Element[extr4, k])], x(Element[extr4, k]), 1], 2]), k, 1, (2 * m) - 2)
ExtremosCubX = Sequence((x(Element[extr4, k]), 0), k, 1, (2 * m) - 2)
ExtremosAbs1 = RemoveUndefined(Join[{{A1}, ExtremosCub, ExtremosPicos, Last[Lm]}])
ExtremosAbs2 = Sort(Sequence[(y(Element[ExtremosAbs1, k]), x(Element[ExtremosAbs1, k])), k, 1, Length[ExtremosAbs1]])
ExtremoAbsMin: (y(Element[ExtremosAbs2, 1]), x(Element[ExtremosAbs2, 1]))
ExtremoAbsMax: (y(Element[ExtremosAbs2, Length[ExtremosAbs2]]), x(Element[ExtremosAbs2, Length[ExtremosAbs2]]))
sE = Segment(((-x(A1)) - 0.6, y(ExtremoAbsMin)), ((-x(A1)) - 0.6, y(ExtremoAbsMax)))
E = Point(sE)
ExtremosPicosX = Sequence((x(Element[ExtremosPicos, k]), 0), k, 1, m - 1)
extrSeg = Sequence(Segment[Element[ExtremosCub, k], Element[ExtremosCubX, k]], k, 1, (2 * m) - 2)
extrPicosSeg = Sequence(Segment[Element[ExtremosPicos, k], Element[ExtremosPicosX, k]], k, 1, m - 1)
B: (X + DF) / 2
lugar1 = Locus(DF, X)
d2b = Segment(X, DF)
interpolar = true
elegirPuntos = false
elegirIntervalo = false
verP = true
verX = true
verFuncion = true
verExtremosIntervalo = true
verExtremosAbsolutos = true
verHorizontal = true
verPorcentaje = false
verTVM = true
verAngulo = true
verRectaPendienteMedia = false
verRectaTangente = false
verTangente = false
verDerivada = false
verExtremos = false
verNormal = true
verOsculador = true
verDerivada2 = false
verInflexion = false
verArea = false
verPrimitivaDerivada = false
polígono1, poli1altura, poli1base, poli1hipotenusa = Polygon(Az, (x(Az), y(Aa)), Aa)
b: y = y(E)
bandaHorizontal: {Polygon[{ExtremoAbsMin - (100, 0), ExtremoAbsMin + (100, 0), ExtremoAbsMax + (100, 0), ExtremoAbsMax - (100, 0)}]}
D2F: (x(X), d2gP)
normal = Vector(P, Rotate[P + tangente, (sgn(d2gP) * π / 2), P])
sXD2F = Segment(X, D2F)
tvm = Slope(poli1hipotenusa)
cc = Circle(Aa, poli1base / 3)
α = Angle(Aa + (1, 0), Aa, Az)
f(x) = (0.2 * (x - 5)^(2)) - 3
campoDeTexto1 = Textfield(f)
rectaPendienteMedia = Line(P, poli1hipotenusa)
D: P - (0, Element[Ly, 1])
G = Intersect(cc, i)
F = Intersect(cc, poli1hipotenusa)
N = Intersect(cc, poli1base)
k = CircumcircleArc(F, G, N)
texto1 = RotateText("" + (abs(round((100 * dgP)))) + " \%", (30° * sgn(dgP)))
texto1b = RotateText("" + (abs(round((100 * dgP)))) + " \%", 330°)
texto2: "" + dgP + ""
texto3: "" + α + ""
ff = Function(f, x(Vesq1), x(Vesq2))
Pff: (x(X), ff(X))
segPXf = Segment(Pff, X)
Aaff: (x(Vesq1), ff(Vesq1))
Azff: (x(Vesq2), ff(Vesq2))
Extremosff: {Extremum[ff, x(Vesq1), x(Vesq2)]}
ExtremosAbsff1 = RemoveUndefined(Join[{{Aaff}, Extremosff, {Azff}}])
ExtremosAbsff2 = Sort(Sequence[(y(Element[ExtremosAbsff1, k]), x(Element[ExtremosAbsff1, k])), k, 1, Length[ExtremosAbsff1]])
ExtremoAbsMaxff: (y(Element[ExtremosAbsff2, Length[ExtremosAbsff2]]), x(Element[ExtremosAbsff2, Length[ExtremosAbsff2]]))
ExtremoAbsMinff: (y(Element[ExtremosAbsff2, 1]), x(Element[ExtremosAbsff2, 1]))
bandaHorizontalff: {Polygon[{ExtremoAbsMinff - (100, 0), ExtremoAbsMinff + (100, 0), ExtremoAbsMaxff + (100, 0), ExtremoAbsMaxff - (100, 0)}]}
polígono1ff, poli1alturaff, poli1baseff, poli1hipotenusaff = Polygon(Azff, (x(Azff), y(Aaff)), Aaff)
sEff = Segment(((-x(Vesq1)) - 0.6, y(ExtremoAbsMinff)), ((-x(Vesq1)) - 0.6, y(ExtremoAbsMaxff)))
Eff = Point(sEff)
bff: y = y(Eff)
ccff = Circle(Aaff, poli1baseff / 3)
Fff = Intersect(ccff, poli1hipotenusaff)
Nff = Intersect(ccff, poli1baseff)
iff = Ray(Aaff, ((x(Azff), y(Aaff)) + Azff) / 2)
Gff = Intersect(ccff, iff)
kff = CircumcircleArc(Fff, Gff, Nff)
αff = Angle(Aaff + (1, 0), Aaff, Azff)
tvmff = Slope(poli1hipotenusaff)
rectaTangenteff = Line(Pff, (x(X) + epsilon, f(x(X) + epsilon)))
dgPff = Slope(rectaTangenteff)
DFff: X + (0, dgPff)
Bff: (X + DFff) / 2
d1ff = Segment(Pff + (1, 0), Pff + (1, dgPff))
d2ff = Segment(X, DFff)
Se3ff = If(dgPff < 0, Se2, Se1)
tangenteff = UnitVector(Vector[Pff, Pff + (1, dgPff)])
f'' = Derivative(f, 2)
d2gPff = Element(IterationList[f'', x(X), 1], 2)
rectaPendienteMediaff = Line(Pff, poli1hipotenusaff)
ExtremosXff = Sequence((x(Element[Extremosff, k]), 0), k, 1, Length[Extremosff])
extrSegff = Sequence(Segment[Element[Extremosff, k], Element[ExtremosXff, k]], k, 1, Length[Extremosff])
sXDF = Segment(X, DF)
sXDFff = Segment(X, DFff)
D2Fff: (x(X), d2gPff)
sXD2Fff = Segment(X, D2Fff)
d2bff = Segment(X, DFff)
Dff: Pff - (0, y(Aaff))
normalff = Vector(Pff, Rotate[Pff + tangenteff, (sgn(d2gPff) * π / 2), Pff])
texto1ff = RotateText("" + (abs(round((100 * dgPff)))) + " \%", (30° * sgn(dgPff)))
texto2ff: "" + dgPff + ""
texto3ff: "" + αff + ""
texto1ffb = RotateText("" + (abs(round((100 * dgPff)))) + " \%", 330°)
f' = Derivative(f)
textoDf = LaTeX(f', true, true)
textoD2f = LaTeX(f'', true, true)
verTrapecios = false
A = (-0.9866666666666676, 0.34)
C = (2, -1)
O = (-1.0466666666666677, -0.2)
verCoordenadas = false
C3: ("" * "A_") + E3 + " " + ((A3 * ""))
C4: ("" * "A_") + E4 + " " + ((A4 * ""))
C5: ("" * "A_") + E5 + " " + ((A5 * ""))
C6: ("" * "A_") + E6 + " " + ((A6 * ""))
C7: ("" * "A_") + E7 + " " + ((A7 * ""))
C8: ("" * "A_") + E8 + " " + ((A8 * ""))
C9: ("" * "A_") + E9 + " " + ((A9 * ""))
C10: "A_{" + E10 + "} " + A10 + ""
C1: "A_{" + E1 + "} " + A1 + ""
C2: "A_" + E2 + " " + A2 + ""
C11: "A_{" + E11 + "} " + A11 + ""
C12: "A_{" + E12 + "} " + A12 + ""
C13: "A_{" + E13 + "} " + A13 + ""
C14: "A_{" + E14 + "} " + A14 + ""
C15: "A_{" + E15 + "} " + A15 + ""
C16: "A_{" + E16 + "} " + A16 + ""
C17: "A_{" + E17 + "} " + A17 + ""
C18: "A_{" + E18 + "} " + A18 + ""
C19: "A_{" + E19 + "} " + A19 + ""
C20: "A_{" + E20 + "} " + A20 + ""
dx = 1 (slider from 0.01 to 2, step 0.01)
Xdx: X + (dx, 0)
intervalosXdx = Sequence(If[x(Xdx) > Element[Lx, k], 1, 0], k, 1, m)
itvXdx = Max(1, Length[KeepIf[x > 0, intervalosXdx]])
gXdx = Element(listaF, itvXdx)
Pdx: (x(Xdx), gXdx(Xdx))
secante = Line(P, Pdx)
Xmdx: X - (dx, 0)
intervalosXmdx = Sequence(If[x(Xmdx) > Element[Lx, k], 1, 0], k, 1, m)
itvXmdx = Max(1, Length[KeepIf[x > 0, intervalosXmdx]])
gXmdx = Element(listaF, itvXmdx)
Pmdx: (x(Xmdx), gXmdx(Xmdx))
secantem = Line(P, Pmdx)
smdx = Segment(Pmdx, Xmdx)
sdx = Segment(Pdx, Xdx)