Animate a pendulum: Difference between revisions

{{task|Temporal media}}

{{requires|Graphics}}

 

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:

 

=={{header|BASIC}}==

==={{header|BBC BASIC}}===

{{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|Commodore BASIC}}===

20 THETA = π/2

30 G = 9.81

1000 FOR I=0 TO 39: X$ = X$+CHR$(29): NEXT

1010 FOR I=0 TO 24: Y$ = Y$+CHR$(17): NEXT

 

==={{header|FreeBASIC}}===

Dim As Double theta, g, l, accel, speed, px, py, bx, by

theta = PI/2

Draw String (0,385), "Press any key to quit"

Sleep 10

 

==={{header|IS-BASIC}}===

110 LET THETA=RAD(50):LET G=9.81:LET L=.5

120 CALL INIC

620 CLOSE #I

630 NEXT

 

=={{header|C}}==

{{libheader|GLUT}}

#include <math.h>

#include <GL/glut.h>

glutMainLoop();

return 0;

 

{{libheader|Windows Forms}}

 

{{libheader|GDI (System.Drawing)}}

 

using System;

using System.Drawing;

}

}

 

=={{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

 

{{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|Delphi}}==

{{libheader| Vcl.Forms}}

{{libheader| Vcl.ExtCtrls}}

{{Trans|C#}}

unit main;

 

end;

 

 

=={{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|EasyLang}}==

[https://easylang.online/apps/pendulum.html Run it]

 

x = 50 + 40 * sin ang

vel += sin ang / 5

ang += vel

.

 

=={{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.

 

===DOS32 version===

{{works with|Euphoria|3.1.1}}

include misc.e

 

end procedure

 

 

=={{header|F_Sharp|F#}}==

A nice application of F#'s support for units of measure.

open System.Drawing

open System.Windows.Forms

 

[<STAThread>]

 

=={{header|Factor}}==

Approximation of the pendulum for small swings : theta = theta0 * cos(omega0 * t)

locals math math.constants math.functions math.rectangles

math.vectors opengl sequences system ui ui.gadgets ui.render ;

[ <pendulum-gadget> "pendulum" open-window ] with-ui ;

MAIN: pendulum-main

 

=={{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.

=={{header|Groovy}}==

Straight translation of Java solution groovified by removing explicit definitions and converting casts to Groovy as style where needed.

import java.awt.*;

import javax.swing.*;

}

}

 

=={{header|Go}}==

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

 

import (

func main() {

gl.StartDriver(appMain)

 

=={{header|Haskell}}==

{{libheader|HGL}}

import Graphics.HGL.Draw.Picture

import Graphics.HGL.Utils

v' = v + a' * dt

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

 

Usage with <code>ghci</code>:

=== Alternative solution ===

{{libheader|Gloss}}

 

-- Initial conditions

fps = round (1/dt)

render xs = pictures $ renderPendulum xs

 

=={{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|Julia}}==

using Colors

using BoundaryValueDiffEq

animate(muv, [Scene(muv, backdrop),

Scene(muv, frame, easingfunction=easeinoutcubic)],

 

=={{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|Lingo}}==

global velocity, acceleration, angle, posX, posY

img.draw(point(200, 100), point(posX, posY), [#color:rgb(0,0,0)])

img.fill(point(posX-20, posY-20), point(posX+20, posY+20), [#shapeType:#oval,#lineSize:1,#bgColor:rgb(0,0,0),#color:rgb(255,255,0)])

 

=={{header|Logo}}==

{{works with|UCB Logo}}

make "L 1

make "bob 10

 

hideturtle

 

=={{header|Lua}}==

Needs L&Ouml;VE 2D Engine

function degToRad( d )

return d * 0.01745329251

g.circle( "fill", posX, posY, 20 )

end

 

=={{header|M2000 Interpreter}}==

Module Pendulum {

back()

}

Pendulum

 

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

 

=={{header|MATLAB}}==

pendulum.m

 

%% User Defined Parameters

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

 

 

=={{header|Nim}}==

 

Conversion from C with some modifications: changing some variable names, adding a display function to make the program work with "freeGlut", choosing another initial angle, etc.

 

import math

var argc: cint = 0

initGfx(addr(argc), nil)

 

===Gtk3 version===

 

This version uses the same equations but replace OpenGL by Gtk3 with the “gintro” bindings.

 

import math

let app = newApplication(Application, "Rosetta.pendulum")

discard app.connect("activate", activate)

 

=={{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}}==

{{libheader|Phix/pGUI}}

You can run this online [http://phix.x10.mx/p2js/animate_pendulum2.htm here].

<span style="color: #000080;font-style:italic;">--

--

-- Author Pete Lomax, March 2017

--

--

-- With help from lesterb, updates now in timer_cb not redraw_cb,

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{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())

 

===Python: using tkinter===

''' Python 3.6.5 code using Tkinter graphical user interface.'''

 

a = Animation(root)

root.mainloop()

 

=={{header|R}}==

 

pendulum<-function(length=5,radius=1,circle.color="white",bg.color="white"){

}

 

 

=={{header|Racket}}==

#lang racket

 

 

(animate (pendulum))

 

=={{header|Raku}}==

Handles window resizing, modifies pendulum length and period as window height changes. May need to tweek $ppi scaling to get good looking animation.

 

use Cairo;

 

}

 

 

=={{header|REXX}}==

this version is similar to the '''Ada''' version and just

<br>displays the coordinates of the end of the pendulum.

parse arg cycles Plength theta . /*obtain optional argument from the CL.*/

if cycles=='' | cycles=="," then cycles= 60 /*Not specified? Then use the default.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

sin: procedure; parse arg x; x=r2r(x); _=x; numeric fuzz min(5, max(1,digits()-3)); q=x*x

Programming note: &nbsp; the &nbsp; '''SIN''' &nbsp; and &nbsp; '''COS''' &nbsp; functions above are abridged versions.

 

 

=={{header|Ring}}==

# Project : Animate a pendulum

 

paint.drawline(pivotx, pivoty, bobx, boby)

paint.drawellipse(bobx + 24 * sin(a), boby - 24 * cos(a), 24, 24)

 

Output video:

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|Rust}}==

 

{{libheader|piston_window}}

// using version 0.107.0 of piston_window

use piston_window::{clear, ellipse, line_from_to, PistonWindow, WindowSettings};

}

}

 

=={{header|Scala}}==

{{libheader|Scala}}

import java.util.concurrent.{Executors, TimeUnit}

 

scheduleAtFixedRate(ui.animate, 0, 15, TimeUnit.MILLISECONDS)

}

 

=={{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|Scilab}}==

The animation is displayed on a graphic window, and won't stop until it shows all positions calculated unless the user abort the execution on Scilab console.

bob_mass=10;

g=-9.81;

sleep(deltaT*1000)

end

 

=={{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|Yabasic}}==

open window 400, 300

window origin "cc"

until(lower$(inkey$(0.02)) = "q")

 

 

=={{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|LFE}}

{{omit from|PHP}}

{{omit from|SQL PL|It does not handle GUI}}