Animate a pendulum: Difference between revisions

 

One good way of making an animation is by simulating a physical system and illustrating the variables in that system using a dynamically changing graphical display.

The classic such physical system is a [[wp:Pendulum|simple gravity pendulum]].

 

 

=={{header|Ada}}==

 

pendulums.ads:

type Float_Type is digits <>;

Gravitation : Float_Type;

Velocity : Float_Type;

end record;

 

pendulums.adb:

package body Pendulums is

package Math is new Ada.Numerics.Generic_Elementary_Functions (Float_Type);

Item.Velocity * Float_Type (Time);

end Update_Pendulum;

 

example main.adb:

with Ada.Calendar;

with Pendulums;

" Y: " & Float'Image (Get_Y (My_Pendulum)));

end loop;

 

{{out}}

X: -5.00352E+00 Y: 8.65822E+00

...</pre>

 

=={{header|AutoHotkey}}==

This version doesn't use an complex physics calculation - I found a faster way.

{{libheader|GDIP}}

;settings

SizeGUI:={w:650,h:400} ;Guisize

 

GuiClose:

 

{{works with|BBC BASIC for Windows}}

*FLOAT 64

VDU 23,23,4;0;0;0; : REM Set line thickness

GCOL 3,11

CIRCLE FILL bobX + 24 * SIN(a), bobY - 24 * COS(a), 24

 

=={{header|C}}==

{{libheader|GLUT}}

#include <math.h>

#include <GL/glut.h>

glutMainLoop();

return 0;

 

 

=={{header|C++}}==

{{libheader|wxWidgets}}

File wxPendulumDlg.hpp

#ifndef __wxPendulumDlg_h__

#define __wxPendulumDlg_h__

 

#endif // __wxPendulumDlg_h__

File wxPendulumDlg.cpp

// ---------------------

/// @author Martin Ettl

Refresh();

}

This program is tested with wxWidgets version 2.8 and 2.9.

The whole project, including makefile for compiling on Linux

can be download from [https://github.com/orbitcowboy/wxPendulum github].

[[File:WxPendulumScreenshot.png]]

 

=={{header|Clojure}}==

 

{{libheader|Swing}} {{libheader|AWT}}

(ns pendulum

(:import

(-main)

 

=={{header|Common Lisp}}==

Pressing the spacebar adds a pendulum.

 

(defvar *damping* 0.99 "Deceleration factor.")

 

(random 90)

(round w 2))

 

=={{header|E}}==

(This logic is more general than necessary; it is designed to be suitable for a larger application as well.)

 

pragma.syntax("0.9")

 

}

 

 

=={{header|Elm}}==

import Collage exposing (..)

import Element exposing (..)

, update = update

, subscriptions = subscriptions

 

Link to live demo: http://dc25.github.io/animatedPendulumElm

 

=={{header|ERRE}}==

PROGRAM PENDULUM

 

END LOOP

END PROGRAM

PC version: Ctrl+Break to stop.

 

=={{header|Euphoria}}==

===DOS32 version===

{{works with|Euphoria|3.1.1}}

include misc.e

 

end procedure

 

 

 

 

 

=={{header|FBSL}}==

 

FBSLSETTEXT(ME, "Pendulum")

DeleteObject(SelectObject(CreateCompatibleDC, SelectObject))

DeleteDC(CreateCompatibleDC)

'''Screenshot:'''

[[File:FBSLPendulum.png]]

 

=={{header|Fortran}}==

Uses system commands (gfortran) to clear the screen. An initial starting angle is allowed between 90 (to the right) and -90 degrees (to the left). It checks for incorrect inputs.

!Implemented by Anant Dixit (October, 2014)

program animated_pendulum

end do

end subroutine

 

A small preview (truncated to a few steps of the pendulum changing direction). Initial angle provided = 80 degrees.

</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Go}}==

Using {{libheader|GXUI}} from [https://github.com/google/gxui Github]

 

import (

func main() {

gl.StartDriver(appMain)

 

=={{header|Haskell}}==

import Graphics.HGL.Draw.Picture

import Graphics.HGL.Utils

import Graphics.HGL.Window

import Graphics.HGL.Run

import Control.Exception (bracket, )

import Control.Arrow

toInt = fromIntegral.round

pendulum = runGraphics $

bracket

closeWindow

(\w -> mapM_ ((\ g -> setGraphic w g >> getWindowTick w).

where

dt = 1/30

g = 9.812

nextAVT (a,v,t) = (a', v', t + v' * dt) where

pts = map (\(_,t,_) -> (toInt.(300+).(300*).cos &&& toInt. (300*).sin) (pi/2+0.6*t) )

*Main> pendulum

 

=={{header|HicEst}}==

[http://www.HicEst.com/DIFFEQ.htm DIFFEQ] and the callback procedure pendulum numerically integrate the pendulum equation.

The display window can be resized during the run, but for window width not equal to 2*height the pendulum rod becomes a rubber band instead:

BobMargins = ALIAS(ls, rs, ts, bs) ! box margins to draw the bob

 

dTheta(1) = Theta(2) ! Theta' = Theta(2) substitution

dTheta(2) = -g/Lrod*SIN(Theta(1)) ! Theta" = Theta(2)' = -g/Lrod*SIN(Theta(1))

 

== Icon and {{header|Unicon}} ==

{{trans|Scheme}}

 

import gui

$include "guih.icn"

w.show_modal ()

end

 

=={{header|J}}==

Works for '''J6'''

coinsert 'jgl2'

 

)

 

Updated for changes in '''J8'''

coinsert 'jgl2'

)

 

 

[[File:J_pendulum.gif|320px|pretend the ball is yellow - gifgrabber grabbed a monochrome image for some reason...]]

=={{header|Java}}==

{{libheader|Swing}} {{libheader|AWT}}

import javax.swing.*;

 

new Thread(p).start();

}

 

=={{header|JavaScript}}==

{{trans|E}} (plus gratuitous motion blur)

 

<title>Pendulum</title>

</head><body style="background: gray;">

</script>

 

 

 

=={{header|Kotlin}}==

Conversion of Java snippet.

import java.util.concurrent.*

import javax.swing.*

val executor = Executors.newSingleThreadScheduledExecutor()

executor.scheduleAtFixedRate(Pendulum(200), 0, 15, TimeUnit.MILLISECONDS)

 

=={{header|Liberty BASIC}}==

WindowWidth = 400

WindowHeight = 300

[quit.main]

close #main

 

=={{header|Logo}}==

{{works with|UCB Logo}}

make "L 1

make "bob 10

 

hideturtle

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}}==

pendulum.m

 

%% User Defined Parameters

[rodPivotPoint(2) position(2)]);

 

 

=={{header|ooRexx}}==

ooRexx does not have a portable GUI, but this version is similar to the Ada version and just prints out the coordinates of the end of the pendulum.

pendulum = .pendulum~new(10, 30)

 

::requires rxmath library

 

 

=={{header|Oz}}==

Inspired by the E and Ruby versions.

 

[QTk] = {Link ['x-oz://system/wp/QTk.ozf']}

 

{Window show}

{Animation go}

 

=={{header|Perl}}==

This does not have the window resizing handling that Tcl does.

 

use strict;

use warnings;

$canvas->bind('<Destroy>' => sub {$after_id->cancel});

 

=={{header|Phix}}==

 

=={{header|PicoLisp}}==

A minimalist solution. The pendulum consists of the center point '+', and the swinging xterm cursor.

 

(de pendulum (X Y Len)

(call 'tput "cup"

(+ Y (*/ Len (cos Angle) 2.2)) # Compensate for aspect ratio

Test (hit any key to stop):

 

=={{header|Prolog}}==

SWI-Prolog has a graphic interface XPCE.

 

pendulum :-

ND = - D;

ND = D).

=={{header|PureBasic}}==

If the code was part of a larger application it could be improved by specifying constants for the locations of image elements.

If Not x

MessageRequester("Error", msg)

Break

EndSelect

 

=={{header|Python}}==

 

{{trans|C}}

from pygame.locals import *

from math import sin, cos, radians

while True:

input(pygame.event.get())

 

=={{header|Racket}}==

#lang racket

 

 

(animate (pendulum))

 

=={{header|RLaB}}==

The RLaB script that solves the problem is

 

//

// example: solve ODE for pendulum

}

 

 

=={{header|Ruby}}==

the Tcl pendulum swings noticibly faster.

 

 

$root = TkRoot.new("title" => "Pendulum Animation")

$canvas.bind('<Destroy>') {$root.after_cancel($after_id)}

 

 

==={{libheader|Shoes}}===

@centerX = 160

@centerY = 25

@Theta = lastTheta

end

 

==={{libheader|Ruby/Gosu}}===

 

begin; require 'rubygems'; rescue; end

puts e.message, e.backtrace

gets

 

=={{header|Scala}}==

{{libheader|Scala}}

import scala.swing.Swing.pair2Dimension

 

 

lazy val ui = new Panel {

background = Color.white

preferredSize = (2 * length + 50, length / 2 * 3)

var angle: Double = Pi / 2

 

super.paintComponent(g)

 

g.setColor(Color.yellow)

g.fillOval(ballX - 7, ballY - 7, 14, 14)

}

}

 

title = "Rosetta Code >>> Task: Animate a pendulum | Language: Scala"

contents = ui

}

 

=={{header|Scheme}}==

This is a direct translation of the Ruby/Tk example into Scheme + PS/Tk.

 

 

;;; R6RS implementation of Pendulum Animation

(tk/after 500 animate)

(tk-event-loop tk)))

 

=={{header|SequenceL}}==

{{libheader|EaselSL}}

Using the [https://github.com/bethune-bryant/Easel Easel Engine for SequenceL] <br>

import <Utilities/Conversion.sl>;

import <Utilities/Math.sl>;

point(x, y);

 

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

 

var root = %s<MainWindow>.new('-title' => 'Pendulum Animation')

 

canvas.bind('<Destroy>' => { after_id.cancel })

 

=={{header|smart BASIC}}==

'By Dutchman

' --- constants

REFRESH ON

RETURN

<pre>

We hope that the webmaster will soon have image uploads enabled again so that we can show a screen shot.

{{works with|Tcl|8.5}}

==={{libheader|Tk}}===

package require Tk

 

bind .c <Configure> {resized %w}

# Callback to stop the animation cleanly when the GUI goes away

 

=={{header|XPL0}}==

 

proc Ball(X0, Y0, R, C); \Draw a filled circle

until KeyHit; \keystroke terminates program

SetVid(3); \restore normal text screen

 

=={{header|ZX Spectrum Basic}}==

{{trans|ERRE}}

In a real Spectrum it is too slow. Use the BasinC emulator/editor at maximum speed for realistic animation.

20 LET theta=1

30 LET g=9.81

1000 PLOT pivotx,pivoty: DRAW bobx-pivotx,boby-pivoty

1010 CIRCLE bobx,boby,3

 

{{omit from|Maxima}}

{{omit from|PARI/GP}}

{{omit from|PHP}}