Merge pull request #1081 from github/pr-931-updated

Mathematica (part deux) -- replaces #931

lib/linguist/languages.yml

@@ -1071,6 +1071,11 @@ Mask:
   ace_mode: scss
   primary_extension: .mask
 
+Mathematica:
+  type: programming
+  primary_extension: .mathematica
+  lexer: Text only
+
 Matlab:
   type: programming
   color: "#bb92ac"

samples/Mathematica/Init.m

@@ -0,0 +1,3 @@
+(* Mathematica Init File *)
+
+Get[ "Foobar`Foobar`"]

samples/Mathematica/PacletInfo.m

@@ -0,0 +1,17 @@
+(* Paclet Info File *)
+
+(* created 2014/02/07*)
+
+Paclet[
+    Name -> "Foobar",
+    Version -> "0.0.1",
+    MathematicaVersion -> "8+",
+    Description -> "Example of an automatically generated PacletInfo file.",
+    Creator -> "Chris Granade",
+    Extensions -> 
+        {
+            {"Documentation", Language -> "English", MainPage -> "Guides/Foobar"}
+        }
+]
+
+

samples/Mathematica/Predicates.m

@@ -0,0 +1,150 @@
+(* ::Package:: *)
+
+BeginPackage["Predicates`"];
+
+
+(* ::Title:: *)
+(*Predicates*)
+
+
+(* ::Section::Closed:: *)
+(*Fuzzy Logic*)
+
+
+(* ::Subsection:: *)
+(*Documentation*)
+
+
+PossiblyTrueQ::usage="Returns True if the argument is not definitely False.";
+PossiblyFalseQ::usage="Returns True if the argument is not definitely True.";
+PossiblyNonzeroQ::usage="Returns True if and only if its argument is not definitely zero.";
+
+
+(* ::Subsection:: *)
+(*Implimentation*)
+
+
+Begin["`Private`"];
+
+
+PossiblyTrueQ[expr_]:=\[Not]TrueQ[\[Not]expr]
+
+
+PossiblyFalseQ[expr_]:=\[Not]TrueQ[expr]
+
+
+End[];
+
+
+(* ::Section::Closed:: *)
+(*Numbers and Lists*)
+
+
+(* ::Subsection:: *)
+(*Documentation*)
+
+
+AnyQ::usage="Given a predicate and a list, retuns True if and only if that predicate is True for at least one element of the list.";
+AnyElementQ::usage="Returns True if cond matches any element of L.";
+AllQ::usage="Given a predicate and a list, retuns True if and only if that predicate is True for all elements of the list.";
+AllElementQ::usage="Returns True if cond matches any element of L.";
+
+
+AnyNonzeroQ::usage="Returns True if L is a list such that at least one element is definitely not zero.";
+AnyPossiblyNonzeroQ::usage="Returns True if expr is a list such that at least one element is not definitely zero.";
+
+
+RealQ::usage="Returns True if and only if the argument is a real number";
+PositiveQ::usage="Returns True if and only if the argument is a positive real number";
+NonnegativeQ::usage="Returns True if and only if the argument is a non-negative real number";
+PositiveIntegerQ::usage="Returns True if and only if the argument is a positive integer";
+NonnegativeIntegerQ::usage="Returns True if and only if the argument is a non-negative integer";
+
+
+IntegerListQ::usage="Returns True if and only if the input is a list of integers.";
+PositiveIntegerListQ::usage="Returns True if and only if the input is a list of positive integers.";
+NonnegativeIntegerListQ::usage="Returns True if and only if the input is a list of non-negative integers.";
+IntegerOrListQ::usage="Returns True if and only if the input is a list of integers or an integer.";
+PositiveIntegerOrListQ::usage="Returns True if and only if the input is a list of positive integers or a positive integer.";
+NonnegativeIntegerOrListQ::usage="Returns True if and only if the input is a list of positive integers or a positive integer.";
+
+
+SymbolQ::usage="Returns True if argument is an unassigned symbol.";
+SymbolOrNumberQ::usage="Returns True if argument is a number of has head 'Symbol'";
+
+
+(* ::Subsection:: *)
+(*Implimentation*)
+
+
+Begin["`Private`"];
+
+
+AnyQ[cond_, L_] := Fold[Or, False, cond /@ L]
+
+
+AnyElementQ[cond_,L_]:=AnyQ[cond,Flatten[L]]
+
+
+AllQ[cond_, L_] := Fold[And, True, cond /@ L]
+
+
+AllElementQ[cond_, L_] := Fold[And, True, cond /@ L]
+
+
+AnyNonzeroQ[L_]:=AnyElementQ[#!=0&,L]
+
+
+PossiblyNonzeroQ[expr_]:=PossiblyTrueQ[expr!=0]
+
+
+AnyPossiblyNonzeroQ[expr_]:=AnyElementQ[PossiblyNonzeroQ,expr]
+
+
+RealQ[n_]:=TrueQ[Im[n]==0];
+
+
+PositiveQ[n_]:=Positive[n];
+
+
+PositiveIntegerQ[n_]:=PositiveQ[n]\[And]IntegerQ[n];
+
+
+NonnegativeQ[n_]:=TrueQ[RealQ[n]&&n>=0];
+
+
+NonnegativeIntegerQ[n_]:=NonnegativeQ[n]\[And]IntegerQ[n];
+
+
+IntegerListQ[input_]:=ListQ[input]&&Not[MemberQ[IntegerQ/@input,False]];
+
+
+IntegerOrListQ[input_]:=IntegerListQ[input]||IntegerQ[input];
+
+
+PositiveIntegerListQ[input_]:=IntegerListQ[input]&&Not[MemberQ[Positive[input],False]];
+
+
+PositiveIntegerOrListQ[input_]:=PositiveIntegerListQ[input]||PositiveIntegerQ[input];
+
+
+NonnegativeIntegerListQ[input_]:=IntegerListQ[input]&&Not[MemberQ[NonnegativeIntegerQ[input],False]];
+
+
+NonnegativeIntegerOrListQ[input_]:=NonnegativeIntegerListQ[input]||NonnegativeIntegerQ[input];
+
+
+SymbolQ[a_]:=Head[a]===Symbol;
+
+
+SymbolOrNumberQ[a_]:=NumericQ[a]||Head[a]===Symbol;
+
+
+End[];
+
+
+(* ::Section:: *)
+(*Epilogue*)
+
+
+EndPackage[];