Rafiki
Active member
look ma i'm in the paper
http://azdailysun.com/news/local/fl...cle_870868b6-bfb6-11e3-8d44-001a4bcf887a.html
http://azdailysun.com/news/local/fl...cle_870868b6-bfb6-11e3-8d44-001a4bcf887a.html
CTRL-V NOW
- Thread starter MilaKunis
- Start date
CheddarJack
Active member
Bateman
Active member
hi every1 im new!!!!!!! holds up spork my name is katy but u can call me t3h PeNgU1N oF d00m!!!!!!!! lol…as u can see im very random!!!! thats why i came here, 2 meet random ppl like me _… im 13 years old (im mature 4 my age tho!!) i like 2 watch invader zim w/ my girlfreind (im bi if u dont like it deal w/it) its our favorite tv show!!! bcuz its SOOOO random!!!! shes random 2 of course but i want 2 meet more random ppl =) like they say the more the merrier!!!! lol…neways i hope 2 make alot of freinds here so give me lots of commentses!!!!
DOOOOOMMMM!!!!!!!!!!!!!!!!
DOOOOOMMMM!!!!!!!!!!!!!!!!
HarlTheGnarl
Member
to review the site and determine if we are going to stay with this configuration or change
sstricky
Active member
import jsy.lab6.JsyInterpreter
import jsy.lab6.JsyParser
object Lab6 extends jsy.util.JsyApplication {
import jsy.lab6.ast._
/*
* CSCI 3155: Lab 6
*
*
* Partner: U): ParseResult
* }
* case class Success[+T](result: T, next: Input) extends ParseResult[T]
* case class Failure(next: Input) extends ParseResult[Nothing]
*/
def re(next: Input): ParseResult[RegExpr] = union(next)
def union(next: Input): ParseResult[RegExpr] = intersect(next) match {
case Success(r, next) => {
def unions(acc: RegExpr, next: Input): ParseResult[RegExpr] =
if (next.atEnd) Success(acc, next)
else (next.first, next.rest) match {
case ('|', next) => intersect(next) match {
case Success(r, next) => unions(RUnion(acc, r), next)
case _ => Failure("expected intersect", next)
}
case _ => Success(acc, next)
}
unions(r, next)
}
case _ => Failure("expected intersect", next)
}
def intersect(next: Input): ParseResult[RegExpr] = throw new UnsupportedOperationException
def concat(next: Input): ParseResult[RegExpr] = throw new UnsupportedOperationException
def not(next: Input): ParseResult[RegExpr] = throw new UnsupportedOperationException
def star(next: Input): ParseResult[RegExpr] = throw new UnsupportedOperationException
/* This set is useful to check if a Char is/is not a regular expression
meta-language character. Use delimiters.contains(c) for a Char c. */
val delimiters = Set('|', '&', '~', '*', '+', '?', '!', '#', '.', '(', ')')
def atom(next: Input): ParseResult[RegExpr] = throw new UnsupportedOperationException
/* External Interface */
def parse(next: Input): RegExpr = re(next) match {
case Success(r, next) if (next.atEnd) => r
case Success(_, next) => throw new SyntaxError("remaining input", next.pos)
case Failure(msg, next) => throw new SyntaxError(msg, next.pos)
}
def parse(s: String): RegExpr = parse(new CharSequenceReader(s))
}
/*** Regular Expression Matching ***/
def retest(re: RegExpr, s: String): Boolean = {
def test(re: RegExpr, chars: List[Char], sc: List[Char] => Boolean): Boolean = (re, chars) match {
/* Basic Operators */
case (RNoString, _) => throw new UnsupportedOperationException
case (REmptyString, _) => throw new UnsupportedOperationException
case (RSingle(_), Nil) => throw new UnsupportedOperationException
case (RSingle(c1), c2 :: t) => throw new UnsupportedOperationException
case (RConcat(re1, re2), _) => throw new UnsupportedOperationException
case (RUnion(re1, re2), _) => throw new UnsupportedOperationException
case (RStar(re1), _) => throw new UnsupportedOperationException
/* Extended Operators */
case (RAnyChar, Nil) => false
case (RAnyChar, _ :: t) => sc(t)
case (RPlus(re1), _) => throw new UnsupportedOperationException
case (ROption(re1), _) => throw new UnsupportedOperationException
/***** Extra Credit Cases *****/
case (RIntersect(re1, re2), _) => throw new UnsupportedOperationException
case (RNeg(re1), _) => throw new UnsupportedOperationException
}
test(re, s.toList, { chars => chars.isEmpty })
}
/*** JavaScripty Interpreter ***/
/* This part is optional and only for fun.
*
* If you want your own complete JavaScripty interpreter, you can copy your
* Lab 5 interpreter here and extend it for the Lab 6 constructs.
*
* By default, a reference JavaScripty interpreter will run using your
* regular expression tester.
*/
object MyInterpreter extends jsy.lab6.Interpreter {
/* Type checking. */
def typeInfer(env: Map[String,(Mutability,Typ)], e: Expr): Typ =
throw new UnsupportedOperationException
/* A small-step transition. */
def stepre(retest: (RegExpr, String) => Boolean)(e: Expr): DoWith[Mem, Expr] = {
def step(e: Expr): DoWith[Mem, Expr] = {
require(!isValue(e), "stepping on a value: %s".format(e))
throw new UnsupportedOperationException
}
step(e)
}
}
/*** External Interfaces ***/
this.debug = true // comment this out or set to false if you don't want print debugging information
this.maxSteps = Some(500) // comment this out or set to None to not bound the number of steps.
var useReferenceRegExprParser = false /* set to true to use the reference parser */
var useReferenceJsyInterpreter = true /* set to false to use your JavaScripty interpreter */
this.flagOptions = this.flagOptions ++ List(
("ref-reparser", jsy.util.options.SetBool(b => useReferenceRegExprParser = b, Some(b => useReferenceRegExprParser == b)), "using the reference regular expression parser"),
("ref-jsyinterp", jsy.util.options.SetBool(b => useReferenceJsyInterpreter = b, Some(b => useReferenceJsyInterpreter == b)), "using the reference JavaScripty interpreter")
)
// Select the interpreter to use based on the useReferenceJsyInterpreter flag
val interpreter: jsy.lab6.Interpreter =
if (useReferenceJsyInterpreter) jsy.lab6.JsyInterpreter else MyInterpreter
def inferType(e: Expr): Typ = {
if (debug) {
println("------------------------------------------------------------")
println("Type checking: %s ...".format(e))
}
val t = interpreter.typeInfer(Map.empty, e)
if (debug) {
println("Type: " + pretty(t))
}
t
}
// Interface to run your small-step interpreter and print out the steps of evaluation if debugging.
case class TerminationError(e: Expr) extends Exception {
override def toString = JsyParser.formatErrorMessage(e.pos, "TerminationError", "run out of steps in evaluating " + e)
}
def iterateStep(e: Expr): Expr = {
require(closed(e), "not a closed expression: free variables: %s".format(freeVars(e)) )
val step: Expr => DoWith[Mem, Expr] = interpreter.stepre(retest)
def loop(e: Expr, n: Int): DoWith[Mem,Expr] =
if (Some
== maxSteps) throw TerminationError(e)
else if (isValue(e)) doreturn( e )
else {
for {
m
import jsy.lab6.JsyParser
object Lab6 extends jsy.util.JsyApplication {
import jsy.lab6.ast._
/*
* CSCI 3155: Lab 6
*
*
* Partner: U): ParseResult
* }
* case class Success[+T](result: T, next: Input) extends ParseResult[T]
* case class Failure(next: Input) extends ParseResult[Nothing]
*/
def re(next: Input): ParseResult[RegExpr] = union(next)
def union(next: Input): ParseResult[RegExpr] = intersect(next) match {
case Success(r, next) => {
def unions(acc: RegExpr, next: Input): ParseResult[RegExpr] =
if (next.atEnd) Success(acc, next)
else (next.first, next.rest) match {
case ('|', next) => intersect(next) match {
case Success(r, next) => unions(RUnion(acc, r), next)
case _ => Failure("expected intersect", next)
}
case _ => Success(acc, next)
}
unions(r, next)
}
case _ => Failure("expected intersect", next)
}
def intersect(next: Input): ParseResult[RegExpr] = throw new UnsupportedOperationException
def concat(next: Input): ParseResult[RegExpr] = throw new UnsupportedOperationException
def not(next: Input): ParseResult[RegExpr] = throw new UnsupportedOperationException
def star(next: Input): ParseResult[RegExpr] = throw new UnsupportedOperationException
/* This set is useful to check if a Char is/is not a regular expression
meta-language character. Use delimiters.contains(c) for a Char c. */
val delimiters = Set('|', '&', '~', '*', '+', '?', '!', '#', '.', '(', ')')
def atom(next: Input): ParseResult[RegExpr] = throw new UnsupportedOperationException
/* External Interface */
def parse(next: Input): RegExpr = re(next) match {
case Success(r, next) if (next.atEnd) => r
case Success(_, next) => throw new SyntaxError("remaining input", next.pos)
case Failure(msg, next) => throw new SyntaxError(msg, next.pos)
}
def parse(s: String): RegExpr = parse(new CharSequenceReader(s))
}
/*** Regular Expression Matching ***/
def retest(re: RegExpr, s: String): Boolean = {
def test(re: RegExpr, chars: List[Char], sc: List[Char] => Boolean): Boolean = (re, chars) match {
/* Basic Operators */
case (RNoString, _) => throw new UnsupportedOperationException
case (REmptyString, _) => throw new UnsupportedOperationException
case (RSingle(_), Nil) => throw new UnsupportedOperationException
case (RSingle(c1), c2 :: t) => throw new UnsupportedOperationException
case (RConcat(re1, re2), _) => throw new UnsupportedOperationException
case (RUnion(re1, re2), _) => throw new UnsupportedOperationException
case (RStar(re1), _) => throw new UnsupportedOperationException
/* Extended Operators */
case (RAnyChar, Nil) => false
case (RAnyChar, _ :: t) => sc(t)
case (RPlus(re1), _) => throw new UnsupportedOperationException
case (ROption(re1), _) => throw new UnsupportedOperationException
/***** Extra Credit Cases *****/
case (RIntersect(re1, re2), _) => throw new UnsupportedOperationException
case (RNeg(re1), _) => throw new UnsupportedOperationException
}
test(re, s.toList, { chars => chars.isEmpty })
}
/*** JavaScripty Interpreter ***/
/* This part is optional and only for fun.
*
* If you want your own complete JavaScripty interpreter, you can copy your
* Lab 5 interpreter here and extend it for the Lab 6 constructs.
*
* By default, a reference JavaScripty interpreter will run using your
* regular expression tester.
*/
object MyInterpreter extends jsy.lab6.Interpreter {
/* Type checking. */
def typeInfer(env: Map[String,(Mutability,Typ)], e: Expr): Typ =
throw new UnsupportedOperationException
/* A small-step transition. */
def stepre(retest: (RegExpr, String) => Boolean)(e: Expr): DoWith[Mem, Expr] = {
def step(e: Expr): DoWith[Mem, Expr] = {
require(!isValue(e), "stepping on a value: %s".format(e))
throw new UnsupportedOperationException
}
step(e)
}
}
/*** External Interfaces ***/
this.debug = true // comment this out or set to false if you don't want print debugging information
this.maxSteps = Some(500) // comment this out or set to None to not bound the number of steps.
var useReferenceRegExprParser = false /* set to true to use the reference parser */
var useReferenceJsyInterpreter = true /* set to false to use your JavaScripty interpreter */
this.flagOptions = this.flagOptions ++ List(
("ref-reparser", jsy.util.options.SetBool(b => useReferenceRegExprParser = b, Some(b => useReferenceRegExprParser == b)), "using the reference regular expression parser"),
("ref-jsyinterp", jsy.util.options.SetBool(b => useReferenceJsyInterpreter = b, Some(b => useReferenceJsyInterpreter == b)), "using the reference JavaScripty interpreter")
)
// Select the interpreter to use based on the useReferenceJsyInterpreter flag
val interpreter: jsy.lab6.Interpreter =
if (useReferenceJsyInterpreter) jsy.lab6.JsyInterpreter else MyInterpreter
def inferType(e: Expr): Typ = {
if (debug) {
println("------------------------------------------------------------")
println("Type checking: %s ...".format(e))
}
val t = interpreter.typeInfer(Map.empty, e)
if (debug) {
println("Type: " + pretty(t))
}
t
}
// Interface to run your small-step interpreter and print out the steps of evaluation if debugging.
case class TerminationError(e: Expr) extends Exception {
override def toString = JsyParser.formatErrorMessage(e.pos, "TerminationError", "run out of steps in evaluating " + e)
}
def iterateStep(e: Expr): Expr = {
require(closed(e), "not a closed expression: free variables: %s".format(freeVars(e)) )
val step: Expr => DoWith[Mem, Expr] = interpreter.stepre(retest)
def loop(e: Expr, n: Int): DoWith[Mem,Expr] =
if (Some
== maxSteps) throw TerminationError(e)else if (isValue(e)) doreturn( e )
else {
for {
m
disastertourism
Active member
nick_monteleone
Member
Iridiman
hippy.
Active member
spliff.Life
Active member
8.
Premises: (∃x)[(Px∙~Gx)→(Hx∙Dx)],(x)~(Gx∨Hx)
Conclusion: ~(x)Px
Proof attempt:
1. (∃x)[(Px∙~Gx)→(Hx∙Dx)] [exis]
2. (x)~(Gx∨Hx) [univ]
|3. (x)Px Assume [univ]
|4. (Pa∙~Ga)→(Ha∙Da) 1, EI [cond]
|5. ~(Ga∨Ha) 2, UI [nega]
|6. ~Ga∙~Ha 5, DeM [conj]
|7. ~Ga 6, Simp [nega]
|8. Pa 3, UI [pred]
|9. Pa∙~Ga 8,7, Conj [conj]
|10. Ha∙Da 9,4, MP [conj]
|11. Ha 10, Simp [pred]
|12. ~Ha 6, Simp [nega]
|13. Ha∙~Ha 12,11, Conj [conj]
14. ~(x)Px 3-13, RAA [nega]
Congratulations: No errors were found in the proof.
Premises: (∃x)[(Px∙~Gx)→(Hx∙Dx)],(x)~(Gx∨Hx)
Conclusion: ~(x)Px
Proof attempt:
1. (∃x)[(Px∙~Gx)→(Hx∙Dx)] [exis]
2. (x)~(Gx∨Hx) [univ]
|3. (x)Px Assume [univ]
|4. (Pa∙~Ga)→(Ha∙Da) 1, EI [cond]
|5. ~(Ga∨Ha) 2, UI [nega]
|6. ~Ga∙~Ha 5, DeM [conj]
|7. ~Ga 6, Simp [nega]
|8. Pa 3, UI [pred]
|9. Pa∙~Ga 8,7, Conj [conj]
|10. Ha∙Da 9,4, MP [conj]
|11. Ha 10, Simp [pred]
|12. ~Ha 6, Simp [nega]
|13. Ha∙~Ha 12,11, Conj [conj]
14. ~(x)Px 3-13, RAA [nega]
Congratulations: No errors were found in the proof.
spliff.Life
Active member
(as you see ive stopped doing homework and am now on ns)
stickski
Active member
Survey
Please fill out the following survey regarding the way you commute to school at the University of Utah.
1. What means of transportation do you use to get to school?
a. Automobile
b. Mass Transit (trax, bus, etc.)
c. Walk
d. Bike
2. On Average, how long does it take you to get to school?
a. 0 – 15 Minutes
b. 15 – 30 Minutes
c. 30 – 60 Minutes
d. More Than 60 Minutes
3. What gender are you?
a. Male
b. Female
Please fill out the following survey regarding the way you commute to school at the University of Utah.
1. What means of transportation do you use to get to school?
a. Automobile
b. Mass Transit (trax, bus, etc.)
c. Walk
d. Bike
2. On Average, how long does it take you to get to school?
a. 0 – 15 Minutes
b. 15 – 30 Minutes
c. 30 – 60 Minutes
d. More Than 60 Minutes
3. What gender are you?
a. Male
b. Female
MilaKunis
Active member
I'm not sure if I even want the context on some of these
http://www.reddit.com/r/nosleep/comments/19fmjf/autopilot/
http://www.reddit.com/r/nosleep/comments/19fmjf/autopilot/
Brule.
Active member
spliff.Life
Active member
12948933:MilaKunis said:
that was a good read.
Cambrewski
Member
I’m driven up a wall with all of this confusion
nothing I can think of is helping to
ease the tight grip that these question have on me
the answer can only be told be the abyss
that you're falling into
with no bottom in sight you just keep falling and falling
until you simply accept your destiny as an endless pit fall
you may as well replace your fear with elaion now
because since your only faced with two choices at this point
you may as well choose happiness over the terror
that used to strike you down
so why not just be all right in the moment and be excited by
the next
it doesnt make sense to me why you’d
choose any other path when the one in front of
you is so clearly superior
A poem I wrote for school..
nothing I can think of is helping to
ease the tight grip that these question have on me
the answer can only be told be the abyss
that you're falling into
with no bottom in sight you just keep falling and falling
until you simply accept your destiny as an endless pit fall
you may as well replace your fear with elaion now
because since your only faced with two choices at this point
you may as well choose happiness over the terror
that used to strike you down
so why not just be all right in the moment and be excited by
the next
it doesnt make sense to me why you’d
choose any other path when the one in front of
you is so clearly superior
A poem I wrote for school..
7-11_Slurpee
Active member
Is Li⁺ acidic or neutral?
Broken_Rides
Member
KATYUSHAS~~~
The_Beekeeper
Member
.MASSHOLE.
Active member
1. The Treasury had the support of the Federal Reserve in placing Liberty Bonds with banks, which was achieved by keeping the discount rate below market rate, postponed the reversal of the wartime monetary and price expansion.
