$\textsf{\LARGE A}$

$\textsf{\LARGE C}$

$\textsf{\LARGE B}$

$\textsf{\LARGE D}$

Dualidade

t_{CA}=%v

t_{DB}=%v

Se aplicarmos uma TENSÃO (força por unidade de comprimento) vertical, o losango se aplaina.
O controle deslizante indica o módulo (um escalar) da tensão, e o vetor laranja indica a força 
resultante (tensão por comprimento da mola) na mola vertical. Experimente mover um ponto azul.

Tensão vertical (t_{BD})

Tensão horizontal (t_{AC})

Ambas tensões

O mesmo acontece ao aplicar uma tensão horizontal.

Mas se aplicarmos duas tensões de módulo igual, como o losango é um paralelogramo, 
o equilíbrio é alcançado em qualquer posição, pois o resultado da soma das forças 
em cada vértice é nulo. Mova os controles deslizantes t_{AC} o t_{BD},  
você verá que se os valores forem diferentes, ele voltará a desequilibrar.

Tensegridade

Chamamos isso de tensegridade. Observe o vértice C (o mesmo acontece nos demais).  
A mola exerce uma tensão t_{CA} para dentro do losango. As duas barras reagem para fora 
(t_{CB} e t_{CD}). Em C, a soma vetorial dessas três forças deve ser zero:
                                    t_{CA} $\vec{CA}$ + t_{CB} $\vec{CB}$ + t_{CD} $\vec{CD}$ = 0  

Escala

Podemos dividir a equação vetorial anterior por uma das tensões (≠0)
para obter um grafo ponderado com pelo menos uma aresta de valor absoluto 1.

-1

-1

Se trocarmos as barras e as molas de uma tensegridad,
obtemos uma nova tensegridade (dual). Para facilitar a representação,
a partir de agora usaremos cabos tensos em vez de molas.

lado = 5
A = Intersect(xAxis, yAxis)
C = Point(Segment[A, ((2 * lado), 0)])
B = PointIn(x ≥ 0 ∧ y ≤ 0)
D = PointIn(x ≥ 0 ∧ y ≥ 0)
op6 = false
t_{CA} = 0 (slider from 0 to 2, step 0.1)
fH: (t_{CA} * abs(A - C))
t_{DB} = 0.3 (slider from 0 to 2, step 0.1)
fV: (t_{DB} * abs(B - D))
op1 = false
op2 = false
uH = Vector(C, C - (fH, 0))
uV = Vector(D, D - (0, fV))
op3 = false
animaVH = 59 (slider from 0 to 100, step 0.1)
u42: (((Vector[A, D] * OrthogonalVector[uV])) / ((Vector[A, D] * OrthogonalVector[C - D])) * Vector[D, C])
u24: (((Vector[A, D] * OrthogonalVector[uH])) / ((Vector[A, D] * OrthogonalVector[C - D])) * Vector[D, C])
pasos: 30
mAn: 0.1
op4 = false
op5 = false
Q2: C + ((2 * lado) + 1, 0)
Q1: A + ((2 * lado) + 1, 0)
Q4: D + ((2 * lado) + 1, 0)
Q3: B + ((2 * lado) + 1, 0)
muelles6D: {Segment[Q1, Q3], Segment[Q1, Q4], Segment[Q2, Q3], Segment[Q2, Q4]}
barras6D: {Segment[Q1, Q2], Segment[Q3, Q4]}
muelles6: {Segment[A, C], Segment[D, B]}
muelleV: {{Segment[B, B + (mAn, abs(D - B) / pasos)], Segment[B + ((-mAn), ((pasos - 1 / 2) * abs(D - B) / pasos)), D]}, Sequence[Segment[B + ((-mAn), ((i + 1 / 2) * abs(D - B) / pasos)), B + (mAn, ((i + 1) * abs(D - B) / pasos))], i, 1, pasos - 2], Sequence[Segment[B + (mAn, (i * abs(D - B) / pasos)), B + ((-mAn), ((i + 1 / 2) * abs(D - B) / pasos))], i, 1, pasos - 1]}
muelleH: {{Segment[A, (abs(C - A) / pasos, mAn)], Segment[(((pasos - 1 / 2) * abs(C - A) / pasos), (-mAn)), C]}, Sequence[Segment[(((i + 1 / 2) * abs(C - A) / pasos), (-mAn)), (((i + 1) * abs(C - A) / pasos), mAn)], i, 1, pasos - 2], Sequence[Segment[((i * abs(C - A) / pasos), mAn), (((i + 1 / 2) * abs(C - A) / pasos), (-mAn))], i, 1, pasos - 1]}
u42': (((Vector[A, D] * OrthogonalVector[uV])) / ((Vector[A, D] * OrthogonalVector[C - D])) * Vector[D, C])
u32: (((-((Vector[A, B] * OrthogonalVector[uH])))) / ((Vector[A, B] * OrthogonalVector[C - B])) * Vector[B, C])
paralelas: {Segment[D + uV, D + u42], Segment[C + uH, C + u24]}
pol: {Polygon[A, B, C, D]}
KCD: (C + D) / 2
KBC: (C + B) / 2
KAB: (A + B) / 2
KAD: (A + D) / 2
KBD: ((B + D) / 2 + D) / 2
tAC': "" + (If[t_{CA} ≟ t_{DB}, abs(u24) / ((abs(C - D) * t_{CA})), "?"]) + ""
tDB': "" + (If[t_{CA} ≟ t_{DB}, abs(u24) / ((abs(C - D) * t_{CA})), "?"]) + ""
tCD: "t_{CD}=" + (If[t_{CA} ≟ t_{DB}, (" - " * abs(u24) / abs(C - D)), "?"]) + ""
tCB: "t_{CB}=" + (If[t_{CA} ≟ t_{DB}, (" - " * abs(u24) / abs(C - D)), "?"]) + ""
tAB: "t_{AB}=" + (If[t_{CA} ≟ t_{DB}, (" - " * abs(u24) / abs(C - D)), "?"]) + ""
tAD: "t_{AD}=" + (If[t_{CA} ≟ t_{DB}, (" - " * abs(u24) / abs(C - D)), "?"]) + ""
tCA: "t_{CA}=" + t_{CA} + ""
tDB: "t_{DB}=" + t_{DB} + ""
tCD': "" + (If[t_{CA} ≟ t_{DB}, (" - " * abs(u24) / ((abs(C - D) * t_{CA}))), "?"]) + ""
tCB': "" + (If[t_{CA} ≟ t_{DB}, (" - " * abs(u24) / ((abs(C - D) * t_{CA}))), "?"]) + ""
KAC: ((A + C) / 2 + A) / 2