Sandbox: Difference between revisions

From Rosetta Code
Content added Content deleted
m (Links, 2, 3, 4)
m (* Removed old stuff from sandbox)
Line 484: Line 484:
! Design goals
! Design goals
|}
|}
{{usertop}}
|-
|<div class="infobox" style="width: 2in">DIVBOX<br>DIVBOX<br>DIVBOX<br>DIVBOX<br>DIVBOX<br></div>
|-
|<div class="infobox" style="width: 2in">DIVBOX<br>DIVBOX<br>DIVBOX<br>DIVBOX<br>DIVBOX<br></div>
|-
|<div class="infobox" style="width: 2in">DIVBOX<br>DIVBOX<br>DIVBOX<br>DIVBOX<br>DIVBOX<br></div>
|-
|<div class="infobox" style="width: 2in">DIVBOX<br>DIVBOX<br>DIVBOX<br>DIVBOX<br>DIVBOX<br></div>
{{userbottom}}
==a==

[[kjhfdkjdsfosfdhlaslhdjkadsf|Non-existant link"]]

== Math ==

<math>a_i = \sum_{k=0}^n 1/over k * b_i</math>

Doesn't work ....

==c==
''blah''
<pre>''blaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa this looks horrible aaaaaaaaaaaaaaaaaaaa we should fix this somehow aaaaaaaaaaaaaaaaaaaaaaaaah''</pre>
<pre><nowiki>''blah''</nowiki></pre>


[[#Your Language Here]]


[[#Python]]
<Python>
def avr24(data):
if len(data)==0:
return 0
else:
return sum(data)/float(len(data))
</Python>

== XFeeds ==

<xfeeds contentcolour="#eeeeee" feedlimit="3" totallimit="10">
http://blog.rosettacode.org/?feed=rss2
http://blog.rosettacode.org/?feed=comments-rss2
</xfeeds>

== Syntax highlighting ==
<c>#include <iostream>
#include <gmpxx.h>

mpf_class f(mpf_class x);
double f(double x);

int main()
{
unsigned int start = 1;
unsigned int end = 1000;
mpf_class sum = 0;
double dsum = 0;
for( unsigned int x = start;
x <= end;
++x )
{
sum += f(mpf_class(x));
dsum += f((double) x);
}
std::cout << "Sum of f(x) from " << start << " to " << end << " is " << sum << " (GMP float) or " << dsum << " (IEEE 64-bit float)" << std::endl;
return 0;
}


mpf_class f(mpf_class x)
{
return ( 1 / ( x * x ) );
}

double f(double x)
{
return ( 1 / ( x * x ) );
}
</c>

'''Expression test'''

Currently there are {{NUMBEROFARTICLES}} articles, but if someone added another, there would be {{#expr: {{NUMBEROFARTICLES:R}} + 1}} articles. Totally, there are {{NUMBEROFPAGES}} pages, which means that {{#expr: {{NUMBEROFPAGES:R}} - {{NUMBEROFARTICLES:R}} }} pages are not articles.

=={{header|Your Language Here}}==
{{Works with|Yourlanguagehere}}
Testing a standard language solution header.

{{Works with|Yourlanguagehere|2.5}}

{{Works with|Yourlanguagehere|Display name|2.5}}
=={{header|Your Language Here|Display Name}}==
Testing a standard language solution header with different display name.


{{BoxImage|Fifo.gif|Animated FIFO}}
<font color=red>color</font><font color=green>Forth</font>

source
<font color=red>color</font><font color=green>Forth</font>
code

26 →

170 ¬

224-234 αßΓπΣσµτΦΘΩ

236 ∞

241-243 ±≥≤


244 ⌠

245 ⌡


246 ÷

247 ≈

248 °

251 √

253 ²

<nowiki><sub> </nowiki>normal<sub>sub</sub>

<nowiki><sup> </nowiki>normal<sup>sup</sup>

Revision as of 05:20, 15 July 2008

Language Paradigm(s) Standarized Type strength Type safety Expression of types Type Compatability Type checking Intended use Design goals
ActionScript imperative programming, object-oriented, event-driven programming Yes

, ECMA

strong safe static Web design
Ada concurrent, distributed programming, generic programming, imperative programming, object-oriented Yes

, ANSI, ISO

strong safe explicit nominative static Embedded, Realtime applications Reliability
ALGOL 68 concurrent, imperative programming No strong safe structural static or dynamic Application Readability, Structure
BASIC procedural programming Yes

, ANSI, ISO

varies by dialect Education Simplicity
C imperative programming Yes

, ANSI C89, ISO C90/C99

weak unsafe explicit nominative static System Low level access, Minimal constraint
C# imperative programming, object-oriented, generic programming, reflective programming Yes

, ECMA, ISO

strong safe (but unsafe allowed) implicit nominative static Application Rapid application development
C++ imperative programming, object-oriented, generic programming Yes

, ISO

strong safe (but unsafe allowed) explicit, partially implicit nominative, structural static, dynamic Application, System Abstraction, Efficiency, Compatibility
Clean functional programming, generic programming No strong implicit static General Correctness, Modularity
COBOL imperative programming, object-oriented Yes strong static Business and Financial Applications Readability
ColdFusion procedural programming, object-oriented No weak implicit dynamic Web Development Rapid Application Development, Ease of use
Common Lisp imperative programming, functional programming, object-oriented Yes strong safe dynamic General Standardize Lisp
D imperative programming, object-oriented, generic programming No strong safe explicit static Application, System Compilability, Correctness, Efficiency
Eiffel imperative programming, object-oriented, generic programming Yes

, ECMA-367, ISO/IEC 25436:2006

strong safe nominative static Application Correctness, Efficiency, Design by contract
Erlang functional programming, concurrent, distributed programming No strong dynamic Telecom and distributed applications Fault tolerance, Scalability
Forth imperative programming, stack-oriented Yes

, ANSI

none n/a n/a n/a n/a Application, Embedded systems Compact implementations
Fortran imperative programming, procedural programming, object-oriented Yes strong safe nominative static Scientific and numeric applications Runtime efficiency, Simple syntax
Groovy imperative programming, object-oriented, aspect-oriented programming No strong safe implicit dynamic Application JVM compatibility
Haskell functional programming, generic programming, lazy evaluation No strong implicit structural static Application lazy evaluation, Explicit side-effect
J array programming, function-level programming, tacit programming No strong safe dynamic Data processing Terseness, Expressiveness, Powerful Data Manipulation
Java imperative programming, object-oriented, generic programming, reflective programming No strong safe explicit nominative static Application Write once run anywhere
JavaScript imperative programming, object-oriented, functional programming, reflective programming Yes weak dynamic Client side web scripting
Joy functional programming, stack-oriented No strong safe dynamic functional programming research concatenative
Lisp functional programming, reflective; others vary by dialect No strong dynamic General Simple notation for Lambda calculus, Homoiconicity
Lua procedural programming, imperative programming, reflective No strong safe implicit dynamic Host-driven Scripting Small, embedded, configuration.
Mathematica functional programming, procedural programming No strong dynamic Numeric computation and visualization
Object Pascal (Delphi) imperative programming, object-oriented, generic programming No strong safe (but unsafe allowed) explicit nominative static Application, System Readability, Rapid application development, Modularity
Objective-C imperative programming, object-oriented, reflective programming Yes weak explicit static Application Smalltalk like, Component based code reuse, C compatibility
Ocaml object-oriented, functional programming, imperative programming, generic programming No strong safe implicit structural static Application Efficiency, Robustness, Correctness
Oz logic programming, functional programming, imperative programming, object-oriented, concurrent programming - multi paradigm No dynamic Education
Pascal imperative programming, procedural programming Yes strong safe explicit static Education Readability, Discipline, Modularity
Perl imperative programming, procedural programming, reflective programming, functional programming, object-oriented, generic programming No weak implicit dynamic Text processing, Scripting Terseness, Expressiveness
PHP imperative programming, object-oriented, reflective programming No weak dynamic Web Application, CLI Robustness and Simplicity
Prolog logic programming Yes

, ISO

strong dynamic Problem solving, Artificial intelligence declarative programming
Python imperative programming, object-oriented, functional programming, aspect-oriented programming, reflective programming No strong safe implicit dynamic Application, Education, Scripting Simplicity, Readability, Expressiveness, Modularity
Ruby imperative programming, object-oriented, aspect-oriented programming, reflective programming No strong implicit dynamic Application, Scripting Expressiveness, Readability
Scala object-oriented, functional programming, generic programming No strong partially implicit static Education
Scheme functional programming Yes strong dynamic (latent) General, Education Minimalistic, Lexical Scoping
Smalltalk object-oriented, concurrent programming, event-driven programming, imperative programming, declarative programming Yes

, ANSI

strong safe implicit dynamic Application, Education Uniformity, Pure object oriented
Tcl imperative programming, procedural programming, event-driven programming No dynamic Application, Scripting
Visual Basic component-oriented programming, event-driven programming No strong safe nominative static Application Rapid application development, Simplicity
Visual Basic .NET object-oriented, event-driven programming No strong static Application Rapid application development, Simplicity
Windows PowerShell imperative programming, object-oriented, functional programming, pipeline programming, reflective programming No strong safe implicit dynamic
Language Paradigm(s) Standarized Type strength Type safety Expression of types Type Compatability Type checking Intended use Design goals
Retrieved from "https://rosettacode.org/wiki/Sandbox?oldid=20619"