Animate a pendulum: Difference between revisions

 

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

BACK-IF-LT( x, y, Print Circle )

RET

{{out}}

<pre>

You can simulate a pseudo graphical mode in an Ubuntu Linux terminal by adding the following lines:

</pre>

SYS("gsettings set org.gnome.Terminal.Legacy.Profile:/org/gnome/terminal/legacy/profiles:/:.../ font 'Ubuntu Mono 1'")

 

SYS("gsettings set org.gnome.Terminal.Legacy.Profile:/org/gnome/terminal/legacy/profiles:/:.../ font 'Ubuntu Mono 12'")

SHOW-CURSOR

<pre>

And substituting the holding coordinates of the pendulum:

</pre>

 

// in "Animate a Pendulum"

{bx, by, 10} GOSUB( CIRCLE )

 

 

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

{{trans|Commodore BASIC}}

Two shapes are used to draw and undraw the pendulum. Undrawing and drawing is done on the page that is not being displayed to make the animation flicker free. Animation code is compacted and hoisted to the beginning of the program. Variables are defined for all non-zero values.

1 FOR X = PX TO BX STEP (BX - PX) / Z:Y = PY + (X - PX) * (BY - PY) / (BX - PX): DRAW T AT X,Y:X(P,N(P)) = X:Y(P,N(P)) = Y:N(P) = N(P) + 1: NEXT X

2 HCOLOR= T: DRAW B AT BX,BY:X(P,N(P)) = BX:Y(P,N(P)) = BY:A = PEEK (R + P):P = NOT P: POKE U,W + W * P:A = G * SIN (F) / L / H:V = V + A / Z:F = F + V: NEXT Q

80 W = 32

85 H = 50

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

 

=={{header|C sharp|C#}}==

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

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>

 

 

===Within SVG===

Also we'll use a dimensionless formulation of the problem (taking unit value for the mass, the length and so on).

 

<line id="string" x1="0" y1="0" x2="1" y2="0" stroke="grey" stroke-width="0.05" />

<circle id="ball" cx="0" cy="0" r="0.1" fill="black" />

</script>

</svg>

 

=={{header|Julia}}==

using Colors

using BoundaryValueDiffEq

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

creategif=true, pathname=giffilename)

 

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

Animate[Graphics[

List[{Line[{{0, 0}, length {Sin[T], -Cos[T]}} /. {T -> (Pi/6) Cos[2 Pi freq t]}], PointSize[Large],

Point[{length {Sin[T], -Cos[T]}} /. {T -> (Pi/6) Cos[2 Pi freq t]}]}],

[[File:mmapendulum.gif]]

 

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

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

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

-- demo\rosetta\animate_pendulum.exw

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

{{trans|FreeBASIC}}

programa {

inclua biblioteca Matematica --> math // math library

}

 

 

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

CONST PI = 3.141592

 

 

'loop the animation until the user presses any key

 

 

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

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

Well, VbScript does'nt have a graphics mode so this is a wobbly textmode pandulum. It should be called from cscript.

option explicit

 

Loop

End Sub 'draw_line

 

=={{header|Wren}}==

{{libheader|DOME}}

{{libheader|Wren-dynamic}}

import "dome" for Window

import "math" for Math

}

 

 

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