Math

Added on 8/24/2004

Compatibilities:
D8_5 Parent

This item has not yet been rated

(sorry for bad english) This is my math script. You can do reverse kinematics, trigo, bezier, momentum, vector calculation, prime numbers and a lot of things with it. Ceci est le script parent que j'utilise pour réaliser divers calculs comme de l'inverse cinématique, de la trigo, des courbes de bézier, des momentums, du calcul vectoriel, rechercher des nombres premiers etc...

Download PC Source

---------------------------------
-- MATH OBJ                    --
-- Pierre Cornier 2004         --
-- cornier_pierre@hotmail.com  --
---------------------------------

-- degToRad(angle en degrés)
-- fastDegToRad(angle en degrés(entier))
-- radToDeg(angle en radians)
-- rotate2dVector(point1, angle en radians, pivot)
-- fastRotate2dVector(point1, angle en degrés(entier), pivot)
-- fastMag2dVector(point1)
-- mag2dVector(point1)
-- fastDistance2d(point1, point2)
-- distance2d(point1, point2)
-- vectorToRad(point1)
-- vectorToDeg(point1)
-- dot2d(point1, point2)
-- fastDot2d(point1, point2)
-- aCos(angle en radians)
-- getIntersectH(point1, point2, point3)
-- getFarAngle(c, a, b)
-- bezier(p1, p2, p3, p4, t)
-- normalise2d(vecteur)
-- setRange(oldMin, oldMax, newMin, newMax, n)
-- toreSurface(xMax, yMax, point)
-- isInsidePoly(listePoints, point)
-- sigmoid(x, n)
-- stepTo(v, num, cible)
-- stepPoint(v, pt, cible)
-- limitPoint(point, pointMin, pointMax)
-- isPrime(p)

property deg2rad
property rad2deg
property cosinus, sinus
property radians

on new me
  deg2rad = pi / 180
  rad2deg = 180 / pi
  cosinus = []
  sinus = []
  radians = []
  repeat with n = 1 to 360
    cosinus[n] = cos(n)
    sinus[n] = sin(n)
    radians[n] = n * deg2rad
  end repeat
  return me
end

----------------------------------------------------
-- degToRad(angle en degrés)
-- retourne l'angle en radians
----------------------------------------------------
on degToRad me, n
  return n * deg2rad
end

----------------------------------------------------
-- fastDegToRad(angle en degrés)
-- retourne l'angle en radians
-- angle en degrés est une valeur entière
----------------------------------------------------
on fastDegToRad me, n
  return radians[n]
end

----------------------------------------------------
-- radToDeg(angle en radians)
-- retourne l'angle en degrés
----------------------------------------------------
on radToDeg me, n
  return n * rad2deg
end

----------------------------------------------------
-- rotate2dVector(point1, angle en radians, pivot)
-- fait pivoter le point1 autour du pivot
----------------------------------------------------
on rotate2dVector me, p1, aAngle, pivot
  vecteur = p1 - pivot
  x1 = vecteur[1] * cos(aAngle) + vecteur[2] * sin(aAngle)
  y1 = vecteur[1] * sin(aAngle) - vecteur[2] * cos(aAngle)
  return pivot + point(x1, y1)
end

----------------------------------------------------
-- fastRotate2dVector(point1, angle en degrés(entier), pivot)
-- fait pivoter le point1 autour du pivot
----------------------------------------------------
on fastRotate2dVector me, p1, aAngle, pivot
  vecteur = p1 - pivot
  x1 = vecteur[1] * cosinus[aAngle] + vecteur[2] * sinus[aAngle]
  y1 = vecteur[1] * sinus[aAngle] - vecteur[2] * cosinus[aAngle]
  return pivot + point(x1, y1)
end

----------------------------------------------------
-- fastMag2dVector(point1)
-- retourne la magnitude du vecteur
----------------------------------------------------
on fastMag2dVector me, p
  return sqrt(p[1] * p[1] + p[2] * p[2])
end

----------------------------------------------------
-- mag2dVector(point1)
-- retourne la magnitude du vecteur
----------------------------------------------------
on mag2dVector me, p
  v = vector(p[1], p[2], 0)
  return v.magnitude
end

----------------------------------------------------
-- fastDistance2d(point1, point2)
-- retourne la distance entre le point1 et le point2
----------------------------------------------------
on fastDistance2d me, p1, p2
  v1 = vector(p1[1], p1[2], 0)
  v2 = vector(p2[1], p2[2], 0)
  return v1.distanceTo(v2)
end

----------------------------------------------------
-- distance2d(point1, point2)
-- retourne la distance entre le point1 et le point2
----------------------------------------------------
on distance2d me, p1, p2
  p3 = p2 - p1
  return me.mag2dVector(p3)
end

----------------------------------------------------
-- vectorToRad(point1)
-- retourne l'angle en radians formé par le vecteur
----------------------------------------------------
on vectorToRad me, p
  return atan(p[1], p[2])
end

----------------------------------------------------
-- vectorToDeg(point1)
-- retourne l'angle en degrés formé par le vecteur
----------------------------------------------------
on vectorToDeg me, p
  return atan(p[1], p[2]) * rad2deg
end

----------------------------------------------------
-- dot2d(point1, point2)
-- retourne le cosinus de l'angle formé par les 2 vecteurs
----------------------------------------------------
on dot2d me, p1, p2
  v1 = vector(p1[1], p1[2], 0)
  v2 = vector(p2[1], p2[2], 0)
  return v1.dot(v2)
end

----------------------------------------------------
-- fastDot2d(point1, point2)
-- retourne le cosinus de l'angle formé par les 2 vecteurs
----------------------------------------------------
on fastDot2d me, p1, p2
  return p1[1] * p2[1] + p1[2] * p2[2]
end

----------------------------------------------------
-- aCos(angle en radians)
-- retourne l'inverse cosinus de l'angle
----------------------------------------------------
on aCos me, n
  a = Sqrt(-n * n + 1)
  if a = 0 then return 0
  return atan(-n / a) + 2 * 0.7854
end

----------------------------------------------------
-- getIntersectH(point1, point2, point3)
-- retourne le point d'intersection entre la hauteur
-- et la base du triangle
----------------------------------------------------
on getIntersectH me, p1, p2, p3
  --           p3
  --          /|
  --     a  /  |    b
  --      /    h
  --    /      |
  -- p1 ------p4-------- p2
  --       c
  c = p2 - p1
  dota = me.fastDot2d(p3 - p1, c)
  dotb = me.fastDot2d(p2 - p3, c)
  if dota + dotb = 0 then dota = .001
  return p1 + (c * dota) / (dota + dotb)
end

----------------------------------------------------
-- getFarAngle(c, a, b)
-- retourne l'angle opposé à c en radians dans le triangle a, b, c
----------------------------------------------------
on getFarAngle me, c, a, b
  if a*b = 0 then return 0
  return me.aCos((a*a+b*b-c*c)/float(2*a*b))
end

----------------------------------------------------
-- bezier(p1, p2, p3, p4, t)
-- retourne le point à la position(t) sur la courbe de bezier :
-- p1 est le point numéro 1
-- p2 est le point de tangente 1
-- p3 est le point de tangente 2
-- p4 est le point numéro 2
-- t est la position du point sur la courbe (0<=t<=1)
----------------------------------------------------
on bezier me, p1, p2, p3, p4, t
  px = power(1-t,3) * p1[1] + 3 * power(1-t,2) * t * p2[1] + 3 * (1-t) * power(t,2) * p3[1] + power(t,3) * p4[1]
  py = power(1-t,3) * p1[2] + 3 * power(1-t,2) * t * p2[2] + 3 * (1-t) * power(t,2) * p3[2] + power(t,3) * p4[2]
  return point(px, py)
end

----------------------------------------------------
-- normalise2d(vecteur)
-- retourne le vecteur normalisé
----------------------------------------------------
on normalise2d me, p
  mag = me.fastMag2dVector(p)
  return point(p[1] / float(mag), p[2] / float(mag))
end

----------------------------------------------------
-- setRange(oldMin, oldMax, newMin, newMax, n)
-- change la taille du nombre n
-- oldMin et oldMax sont l'intervale de départ
-- newMin et newMax sont l'intervale d'arrivée
----------------------------------------------------
on setRange me, oldMin, oldMax, newMin, newMax, n
  t1 = oldMax - oldMin
  t2 = newMax - newMin
  r = t2 / float(t1)
  return ((n-oldMin) * r) + newMin
end

----------------------------------------------------
-- toreSurface(xMax, yMax, point)
-- limite le point à la surface de tore xMax et yMax
----------------------------------------------------
on toreSurface me, xMax, yMax, p
  return point((p[1] + xMax) mod xMax, (p[2] + yMax) mod yMax)
end

----------------------------------------------------
-- isInsidePoly(listePoints, point)
-- retourne vrai si le point est dans le polygone (listePoints)
----------------------------------------------------
on isInsidePoly me, listePoints, p
  total = 0
  pt = listePoints[1]
  lastQuad = (pt[1] < p[1] and pt[2] < p[2]) +
             (pt[1] > p[1] and pt[2] < p[2]) * 2 +
             (pt[1] > p[1] and pt[2] > p[2]) * 3 +
             (pt[1] < p[1] and pt[2] > p[2]) * 4
  repeat with n = 2 to listePoints.count
    pt = listePoints[n]
    whichQuad = (pt[1] < p[1] and pt[2] < p[2]) +
                (pt[1] > p[1] and pt[2] < p[2]) * 2 +
                (pt[1] > p[1] and pt[2] > p[2]) * 3 +
                (pt[1] < p[1] and pt[2] > p[2]) * 4
    delta = whichQuad - lastQuad
    case delta of
      3: delta = -1
      -3: delta = 1
    end case
    total = total + delta
    lastQuad = whichQuad
  end repeat
  if total = 4 or total = -4 then return true
  return false
end

----------------------------------------------------
-- sigmoid(x, n)
-- fonction sigmoïde Y = 1 / (1 + e(-nX))
----------------------------------------------------
on sigmoid me, a, n
  return 1. / (1 + exp(-n*a))
end

----------------------------------------------------
-- stepTo(v, num, cible)
-- déplace le nombre num vers le nombre cible à la vitesse v
-- retourne num + v si num < cible ou num - v si num > cible
----------------------------------------------------
on stepTo me, v, num, cible
  return num + (num < cible) * v - (num > cible) * v
end

----------------------------------------------------
-- stepPoint(v, pt, cible)
-- v est la vitesse de déplacement du point
-- pt est le point actuel
-- cible est le point cible
-- déplace le point vers la cible à la vitesse v
----------------------------------------------------
on stepPoint me, v, pt, cible
  x = pt[1] + (pt[1] < cible[1]) * v - (pt[1] > cible[1]) * v
  y = pt[2] + (pt[2] < cible[2]) * v - (pt[2] > cible[2]) * v
  return point(x, y)
end

----------------------------------------------------
-- limitPoint(point, pointMin, pointMax)
-- Limite le point au rectangle [a, a, b, b]
----------------------------------------------------
on limitPoint me, pt, a, b
  x = max(min(pt[1], b), a)
  y = max(min(pt[2], b), a)
  return point(x, y)
end

----------------------------------------------------
-- isPrime(p)
-- retourne vrai si le nombre est premier
----------------------------------------------------
on isPrime me, p
  if not(p mod 2) then return 0
  a = 3
  repeat while (a*a-1    if p mod a = 0 then return 0
    a = a + 2
  end repeat
  return 1
end

Upload Provided by ABCUpload ASP

Contact

MMI
22 West Court Sq
Suite 2C
Newnan, GA 30263
USA

Fax - (206) 339-5833

Send e-mail