Animate a pendulum: Difference between revisions

{{task|Temporal media}}

{{requires|Graphics}}

pendulums.ads:

type Float_Type is digits <>;

Gravitation : Float_Type;

pendulums.adb:

package body Pendulums is

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

example main.adb:

with Ada.Calendar;

with Pendulums;

=={{header|Amazing Hopper}}==

{{Trans|FreeBASIC}}

#include <flow.h>

#include <flow-term.h>

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'")

And substituting the holding coordinates of the pendulum:

</pre>

// in "Animate a Pendulum"

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

{{libheader|GDIP}}

;settings

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

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

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

{{works with|BBC BASIC for Windows}}

*FLOAT 64

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

==={{header|Commodore BASIC}}===

20 THETA = π/2

30 G = 9.81

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

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

theta = PI/2

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

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

120 CALL INIC

=={{header|C}}==

{{libheader|GLUT}}

#include <math.h>

#include <GL/glut.h>

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

using System;

using System.Drawing;

{{libheader|wxWidgets}}

File wxPendulumDlg.hpp

#ifndef __wxPendulumDlg_h__

#define __wxPendulumDlg_h__

</syntaxhighlight>

File wxPendulumDlg.cpp

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

/// @author Martin Ettl

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

(ns pendulum

(:import

Pressing the spacebar adds a pendulum.

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

{{libheader| Vcl.ExtCtrls}}

{{Trans|C#}}

unit main;

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

pragma.syntax("0.9")

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

clear

move 50 50

=={{header|Elm}}==

import Collage exposing (..)

import Element exposing (..)

=={{header|ERRE}}==

PROGRAM PENDULUM

===DOS32 version===

{{works with|Euphoria|3.1.1}}

include misc.e

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

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

open System.Drawing

open System.Windows.Forms

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

=={{header|FBSL}}==

FBSLSETTEXT(ME, "Pendulum")

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

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

=={{header|Haskell}}==

{{libheader|HGL}}

import Graphics.HGL.Draw.Picture

import Graphics.HGL.Utils

=== Alternative solution ===

{{libheader|Gloss}}

-- Initial conditions

[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

{{trans|Scheme}}

import gui

$include "guih.icn"

=={{header|J}}==

Works for '''J6'''

coinsert 'jgl2'

pend_run'' NB. run animation</syntaxhighlight>

Updated for changes in '''J8'''

coinsert 'jgl2'

=={{header|Java}}==

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

import javax.swing.*;

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

<title>Pendulum</title>

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

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" />

=={{header|Julia}}==

using Colors

using BoundaryValueDiffEq

=={{header|Kotlin}}==

Conversion of Java snippet.

import java.util.concurrent.*

import javax.swing.*

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

WindowWidth = 400

WindowHeight = 300

=={{header|Lingo}}==

global velocity, acceleration, angle, posX, posY

=={{header|Logo}}==

{{works with|UCB Logo}}

make "L 1

make "bob 10

=={{header|Lua}}==

Needs L&Ouml;VE 2D Engine

function degToRad( d )

return d * 0.01745329251

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

Module Pendulum {

back()

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

=={{header|MATLAB}}==

pendulum.m

%% User Defined Parameters

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

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

import math

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

Inspired by the E and Ruby versions.

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

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

use strict;

use warnings;

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

=={{header|PicoLisp}}==

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

(de pendulum (X Y Len)

(+ X (*/ Len (sin Angle) 1.0)) ) ) ) )</syntaxhighlight>

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

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

{{trans|C}}

from pygame.locals import *

from math import sin, cos, radians

===Python: using tkinter===

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

=={{header|QB64}}==

CONST PI = 3.141592

=={{header|R}}==

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

=={{header|Racket}}==

#lang racket

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;

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.*/

=={{header|Ring}}==

# Project : Animate a pendulum

The RLaB script that solves the problem is

//

// example: solve ODE for pendulum

the Tcl pendulum swings noticibly faster.

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

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

@centerX = 160

@centerY = 25

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

begin; require 'rubygems'; rescue; end

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

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

;;; R6RS implementation of Pendulum Animation

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

{{libheader|EaselSL}}

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

import <Utilities/Conversion.sl>;

import <Utilities/Math.sl>;

=={{header|Sidef}}==

{{trans|Perl}}

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

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

'By Dutchman

' --- constants

{{works with|Tcl|8.5}}

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

package require Tk

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

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

=={{header|Yabasic}}==

open window 400, 300

window origin "cc"

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

1010 CIRCLE bobx,boby,3

1020 RETURN</syntaxhighlight>

{{omit from|LFE}}

{{omit from|PHP}}

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