$\textsf{\LARGE A}$

$\textsf{\LARGE C}$

$\textsf{\LARGE B}$

$\textsf{\LARGE D}$

Dualidad

t_{CA}=%v

t_{DB}=%v

Si aplicamos una TENSIÓN (fuerza entre unidad lineal) vertical, el rombo se aplana. El 
deslizador indica el módulo (un escalar) de la tensión y la flecha naranja indica la fuerza 
resultante (tensión por longitud del muelle) en el muelle vertical. Prueba a mover un punto azul.

Tensión vertical (t_{BD})

Tensión horizontal (t_{AC})

Ambas tensiones

Lo mismo sucede al aplicar una tensión horizontal.

Pero si aplicamos dos tensiones de igual módulo, 
como el rombo es un paralelogramo, el equilibrio se alcanza en cualquier posición,
pues la resultante de la suma de fuerzas en cada vértice es nula.
Mueve los deslizadores t_{AC} o t_{BD}, verás que si sus valores difieren se vuelve a desequilibrar.

Tensegridad

Llamamos tensegridad a ese equilibrio. Observa el vértice C (lo mismo pasa en el resto). 
El muelle tensa t_{CA} hacia adentro del rombo. Las dos barras reaccionan hacia afuera 
(t_{CB} y t_{CD}). En C, la suma vectorial de estas tres fuerzas ha de ser cero: 
                                    t_{CA} $\vec{CA}$ + t_{CB} $\vec{CB}$ + t_{CD} $\vec{CD}$ = 0  

Escalado

Podemos dividir la ecuación vectorial anterior por una cualquiera de las tensiones (≠0)
para obtener un grafo ponderado con al menos una arista de valor absoluto 1.

-1

-1

Si intercambiamos las barras y los muelles de una tensegridad, 
obtenemos una nueva tensegridad (dual). Para facilitar la representación, 
a partir de ahora usaremos cables tensos (grises) en vez de muelles.

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 = 66.6 (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