Rechnen mit ^ (Mathematisches Hoch)

  • Rechnen mit ^ (Mathematisches Hoch)

    Hallöchen Liebe Leut'

    ich habe mir den Kofler zu Swift 2 gekauft und wärend des lesen und spielen kam mir etwas in den Sinn, was in dem Buch nicht behandelt wurde.
    Besprochen/beschrieben wurde dort eine Extension für Int, welche Umrechnungen von und zu den einzelnen dezimalen und binären Byte's (Kilo, Mega, etc.) erlaubt.

    Beim (ab)schreiben wollte ich dann aus Gewohnheit heraus anstatt 100000000 10 ^ 9 schreiben, was natürlich fehl schlug.
    Nun erinnerte ich mich an Perl, wo das mathem. Hoch durch ** bewerkstelligt wurde.

    Gibt es ein Äquivalent dazu in Swift 2?
    Für Google bzw. d.a.c nutzte ich wohl die falschen Suchterms.
    Im Buch oder auf der Seite kofler.info/swift-besondere-operatoren/ fand ich auch nichts dazu.

    Müsste ich mir eine eigene Extension für schreiben oder gibt's da was von Rathiopharm?

  • Wie wäre es mit pow(x, y) ... im Sinne von "power" (= math. Potenz)?

    Mattes

    P.S.: Google bzw. SO empfiehlt Dir dann direkt einen eigenen Operator einzuführen (Du musst dringend an Deinem Google-fu arbeiten):

    Quellcode

    1. infix operator **{associativity left precedence 170 }
    3. func **(num: Double, power: Double) -> Double{
    4. return pow(num, power)
    5. }
    Diese Seite bleibt aus technischen Gründen unbedruckt.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von MyMattes ()

  • Völlig richtig :)

    Wenn man zu blöd ist, sein Wissensdurst zu definieren.
    Als ich ein bisserl in anderen Sprachen schaute, fand ich heraus, das C das ebenso mittels pow löst. Als ich dann nach swift math power suchte, vollführte ich das allseits beliebte

    Brainfuck-Quellcode

    1. ............................................________........................
    3. ....................................,.-‘”...................``~.,..................
    5. .............................,.-”...................................“-.,............
    7. .........................,/...............................................”:,........
    9. .....................,?......................................................\,.....
    11. .................../...........................................................,}....
    13. ................./......................................................,:`^`..}....
    15. .............../...................................................,:”........./.....
    17. ..............?.....__.........................................:`.........../.....
    19. ............./__.(.....“~-,_..............................,:`........../........
    21. .........../(_....”~,_........“~,_....................,:`........_/...........
    23. ..........{.._$;_......”=,_.......“-,_.......,.-~-,},.~”;/....}...........
    25. ...........((.....*~_.......”=-._......“;,,./`..../”............../............
    27. ...,,,___.\`~,......“~.,....................`.....}............../.............
    29. ............(....`=-,,.......`........................(......;_,,-”...............
    31. ............/.`~,......`-...............................\....../\...................
    33. .............\`~.*-,.....................................|,./.....\,__...........
    35. ,,_..........}.>-._\...................................|..............`=~-,....
    37. .....`=~-,_\_......`\,.................................\........................
    39. ...................`=~-,,.\,...............................\.......................
    41. ................................`:,,...........................`\..............__..
    43. .....................................`=-,...................,%`>--==``.......
    45. ........................................_\..........._,-%.......`\...............
    47. ...................................,<`.._|_,-&``................`\..............
    Alles anzeigen

  • Dein SO-Link führte dann auch gleich zu einer sehr schönen Methode, von den Doubles in pow abstand zu halten (Ganzzahlen)
    Da das allerdings Nullbasiert ist, muss die Potenz immer um 1 dekrementiert werden.

    Quellcode

    1. let B = 2 << 0 // 2
    2. let KiB = 2 << 9 // 1.024
    3. let MiB = 2 << 19 // 1.048.576


    Bitshifting und so ... wäre ich nicht wirklich drauf gekommen.

  • nein, der erwartet alles, nur kein Int:

    Quellcode

    1. Playground execution failed: /var/folders/fx/v6t6rfp535q6s5sxw8f3mnzh0000gn/T/./lldb/59755/playground114.swift:122:1: error: ambiguous use of 'pow'
    2. pow(2,3)
    3. ^
    4. Darwin.pow:2:13: note: found this candidate
    5. public func pow(lhs: Float, _ rhs: Float) -> Float
    6. ^
    7. Darwin.pow:1:13: note: found this candidate
    8. public func pow(_: Double, _: Double) -> Double
    9. ^
    10. CoreGraphics.pow:2:13: note: found this candidate
    11. public func pow(lhs: CGFloat, _ rhs: CGFloat) -> CGFloat
    Alles anzeigen

    The very, very, vvveeerrryyy dirty! way:

    Quellcode

    1. func pot(basis: Int, potenz: Int) -> Int {
    2. return Int(pow(Double(String("\(basis).0"))!, Double(String("\(potenz).0"))!))
    3. }
    ;)

  • Ist doch eigentlich Unsinn, 2 und 3 sind doch überhaupt noch nicht typgebunden… ^^

    Und warum Double(myInt) nicht gehen sollte verstehe ich auch nicht.
    «Applejack» "Don't you use your fancy mathematics to muddle the issue!"

    Iä-86! Iä-64! Awavauatsh fthagn!

    kmr schrieb:

    Ach, Du bist auch so ein leichtgläubiger Zeitgenosse, der alles glaubt, was irgendwelche Typen vor sich hin brabbeln. :-P

  • Danke @FWerewolf!

    stackoverflow.com/a/33182451 ist genial ;)

    Quellcode

    1. // http://stackoverflow.com/questions/24196689/how-to-get-the-power-of-some-integer-in-swift-language
    2. // Put this at file level anywhere in your project
    3. infix operator ** { associativity left precedence 160 }
    4. func ** (radix: Double, power: Double) -> Double { return pow(radix, power) }
    5. func ** (radix: Int, power: Int) -> Double { return pow(Double(radix), Double(power)) }
    6. func ** (radix: Float, power: Float ) -> Double { return pow(Double(radix), Double(power)) }

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von hirnwunde () aus folgendem Grund: link korregiert

  • Und zwar genau so lange, bis Du irgendwo ein a:Int ** b:Float hast.
    Ein Hoch auf generische Funktionen. Ein Hoch auf überladene Operatoren.
    «Applejack» "Don't you use your fancy mathematics to muddle the issue!"

    Iä-86! Iä-64! Awavauatsh fthagn!

    kmr schrieb:

    Ach, Du bist auch so ein leichtgläubiger Zeitgenosse, der alles glaubt, was irgendwelche Typen vor sich hin brabbeln. :-P