echo html_entity_decode('&#' . 0xA7 . ';', ENT_NOQUOTES, 'UTF-8');

$uniChar = 0x119;
$byte1 = $uniChar >> 6 | 0xC0;
$byte2 = $uniChar & 0x3F | 0x80

function hexToUTF8HexArray($hexNum)
{
   // konwertujemy na liczbe w razie czego
   if (is_string($hexNum)) $hexNum = hexdec($hexNum);
 
   $hexArray = array();
   if ($hexNum < 0x80) {
      $hexArray[0] = '0x' . dechex($hexNum);
      return $hexArray;
   } elseif ($hexNum < 0x800) {
      $hexArray[0] = '0x' . dechex($hexNum >> 6 | 0xC0);
      $hexArray[1] = '0x' . dechex($hexNum & 0x3F | 0x80);
      return $hexArray;
   } else {
      throw new Exception('Not supported');
   }
}

function utf8ToUnicode(array $utf8Array)
{
   // konwertujemy na liczby
   $utf8ArrayChecked = array();
   foreach ($utf8Array as $utf8) {
      if (is_string($utf8)) $utf8 = hexdec($utf8);
      $utf8ArrayChecked[] = $utf8;
   }
 
   $bytesCount = count($utf8ArrayChecked);
   switch ($bytesCount) {
      case 1:
         return $utf8ArrayChecked[0];
      case 2:
         // wyrzucamy naglowki
         $b1 = $utf8ArrayChecked[0] & 0x1F;
         $b2 = $utf8ArrayChecked[1] & 0x3F;
 
         // tutaj cala magia
         $number = $b1 << 6 | $b2;
         return '0x' . dechex($number);
      default:
         throw new Exception('Not supported'); 
   }
}

function charToUTF8HexArray($char)
{
   $i = 0;
   $hexArray = array();
   while (isset($char[$i])) {
      $hexArray[] = '0x' . dechex(ord($char[$i++]));
   }
   return $hexArray;
}

def wallisFormulaGenerator(counterMax):
   counter = 0
   while(counter <= counterMax):
      counter += 1
      yield (4*(counter**2))/(4*(counter**2)-1)       
 
def gimmePiBaby(loops):
   result = 1
   for value in wallisFormulaGenerator(loops):
      result *= value
      return 2*result
 
print(gimmePiBaby(10000))

minus = True
partial = 1
denominator = 3
for i in range(100000):
   if minus:
      partial -= 1/denominator
      minus = False
   else:
      partial += 1/denominator
      minus = True
   denominator += 2
   result = 4 * partial

import bigfloat
with bigfloat.precision(17000):
   minus = True
   partial = bigfloat.BigFloat(1)
   denominator = 3
   for i in range(1, 500000):
      if minus:
         partial -= (1/((bigfloat.pow(3,i))*denominator))
         minus = False
      else:
         partial += (1/((bigfloat.pow(3,i))*denominator))
         minus = True
      denominator += 2
   result = 6 * ((1/bigfloat.sqrt(3)) * partial)

CREATE TABLE `galleries` (
  `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `created` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updated` TIMESTAMP NOT NULL DEFAULT '0000-00-00 00:00:00',
  `title` VARCHAR(250) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 ;
 
CREATE TABLE IF NOT EXISTS `images` (
  `id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `gallery_id` INT(10) UNSIGNED NOT NULL,
  `filename` VARCHAR(50) NOT NULL,
  `ordr` INT(10) UNSIGNED NOT NULL DEFAULT '1',
  `created` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  KEY `image_to_gallery` (`gallery_id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 ;

DELIMITER $$
CREATE TRIGGER `updated_current_timestamp` BEFORE UPDATE ON `galleries`
   FOR EACH ROW BEGIN
      SET NEW.updated = NOW();
END$$

ALTER TABLE `images`
   ADD CONSTRAINT `image_to_gallery` FOREIGN KEY (`gallery_id`) REFERENCES `galleries` (`id`) ON DELETE CASCADE ON UPDATE CASCADE;

$q = $pdo->prepare('INSERT INTO images (filename,gallery_id,ordr) (SELECT ?,?,MAX(ordr)+1 FROM images WHERE gallery_id=? LIMIT 1)');
$q->bindValue(1, 'obrazek.jpg', PDO::PARAM_STR);
$q->bindParam(2, $galleryId, PDO::PARAM_INT);
$q->bindParam(3, $galleryId, PDO::PARAM_INT);
$q->execute();

DELIMITER $$
CREATE PROCEDURE `insert_image`(IN image_filename VARCHAR(50), IN image_gallery_id INT, OUT last_inserted_id INT)
   MODIFIES SQL DATA
   COMMENT 'Inserts new image at the end of given gallery.'
   BEGIN
      DECLARE max_order INT;
 
      # Zamiast SET zmienna= uzywam SELECT INTO just FOR fun
      SELECT MAX(ordr) INTO max_order FROM images WHERE gallery_id=image_gallery_id LIMIT 1;
 
      # Gdy obrazek jest pierwszy w galerii
      IF max_order IS NULL THEN 
         SET max_order = 1;
      ELSE
         SET max_order = max_order + 1;
      END IF;
      INSERT INTO images (filename, gallery_id, ordr) VALUES (image_filename, image_gallery_id, max_order);
      SELECT LAST_INSERT_ID() INTO last_inserted_id;
END$$

$q = $pdo->prepare('CALL insert_image(?,?,@lastInsertId)');
$q->bindValue(1, 'obrazek.jpg', PDO::PARAM_STR);
$q->bindParam(2, $galleryId, PDO::PARAM_INT);
$q->execute();
$outputArray = $pdo->query('select @lastInsertId')->fetch(PDO::FETCH_ASSOC);
$lastInsertId = $outputArray['@lastInsertId'];

DELIMITER $$
CREATE PROCEDURE `delete_image`(IN image_id INT)
   MODIFIES SQL DATA
   COMMENT 'Deletes and reorders if there is a gap.'
   BEGIN
      DECLARE image_gallery_id, image_order, max_order INT;
      SELECT gallery_id, ordr INTO image_gallery_id, image_order FROM images WHERE id=image_id LIMIT 1;
      DELETE FROM images WHERE id=image_id LIMIT 1;
      SELECT MAX(ordr) INTO max_order FROM images WHERE gallery_id=image_gallery_id LIMIT 1;
 
      # Sprawdzamy czy istnieja jakies obrazki za skasowanym
      IF max_order IS NOT NULL AND max_order > image_order THEN
         WHILE image_order < max_order DO
 
            # Cofamy w petli wypelniajac luke po skasowanym obrazku
            UPDATE images SET ordr=image_order WHERE ordr=image_order+1 AND gallery_id=image_gallery_id;
            SET image_order = image_order + 1;
       END WHILE;
   END IF;
END$$

$q = $pdo->prepare('CALL delete_image(?)');
$q->bindParam(1, $imageId, PDO::PARAM_INT);
$q->execute();

DELIMITER $$
CREATE PROCEDURE `reorder_image`(IN image_id INT, IN new_image_order INT)
   MODIFIES SQL DATA
   COMMENT 'Reorders images. Does nothing if given order is out of scope.'
   BEGIN
      DECLARE current_image_order, image_gallery_id, is_destination_order_exists INT;
 
      # Lapie obecne polozenie obrazka i przy okazji id galerii
      SELECT ordr, gallery_id INTO current_image_order, image_gallery_id FROM images WHERE id=image_id LIMIT 1;
 
      # Sprawdzam czy punkt docelowy w ogole istnieje
      SELECT ordr INTO is_destination_order_exists FROM images WHERE gallery_id=image_gallery_id AND ordr=new_image_order LIMIT 1;
 
      # Jezeli punkt docelowy istnieje i jest inny od obecnego TO rozpoczynam dzialanie
      IF is_destination_order_exists IS NOT NULL AND current_image_order <> new_image_order THEN
 
         # Jezeli przestawiam obrazek do gory
         IF current_image_order >  new_image_order THEN 
            WHILE current_image_order >=  new_image_order DO
               UPDATE images SET ordr=current_image_order+1 WHERE gallery_id=image_gallery_id AND ordr= current_image_order LIMIT 1;
               SET current_image_order = current_image_order - 1;
            END WHILE;
 
         # Jezeli przestawiam obrazek w dol
         ELSEIF  current_image_order <  new_image_order THEN 
            WHILE current_image_order <=  new_image_order DO
               UPDATE images SET ordr=current_image_order-1 WHERE gallery_id=image_gallery_id AND ordr= current_image_order LIMIT 1;
               SET current_image_order = current_image_order + 1;
            END WHILE;
         END IF;
 
         # Mam juz miejsce, wrzucam obrazek tam gdzie ma byc
         UPDATE images SET ordr=new_image_order WHERE id=image_id LIMIT 1;
      END IF;
END$$

$q = $pdo->prepare('CALL reorder_image(?,?)');
$q->bindParam(1, $imageId, PDO::PARAM_INT);
$q->bindParam(2, $wantedImageOrder, PDO::PARAM_INT);
$q->execute();

#!/usr/bin/env python
 
from shaker import Shaker, ShakerDisplayer
 
shaker = Shaker()
shaker.addIngredient('piwo', 500, 5.7)
shaker.addIngredient('wodka', 50, 40)
shaker.addIngredient('sok malinowy', 25, 0)
 
ShakerDisplayer.displayShakerDetails(shaker, 89, True)

#!/usr/bin/env python
 
import unicodedata
from numbers import Number
 
class Shaker:
 
    def __init__(self, shakerCapacity = 1000000):
 
        # Zakladamy, ze pojemnosc shakera jest nieograniczona ;-)
        self._shakerCapacity = shakerCapacity
 
        # Inicjalizuje dictionary dla przechowywania klucz => wartosc
        # Klucz dla alkoholu jest w skladnikach zawsze
        self._drinkIngredients = {'alcohol' : 0}
 
    def addIngredient(self, name, amount, alcoholPercentage = 0):
 
        # Gdyby komus zachcialo sie wprowadzac inne wartosci niz numerki i wartosci dodatnie
        if not isinstance(amount, Number) or not isinstance(alcoholPercentage, Number) or alcoholPercentage < 0 or amount < 0:
 
            # Formatowanie za pomoca {} zadziala od Pythona 3.1+    
            raise ValueError('Podano {} i {} dla {}'.format(amount, alcoholPercentage, name))
 
        # Sprawdzam czy jest wystarczajaco duzo miejsca w shakerze
        spaceInShakerLeft = self._shakerCapacity - self.totalLiquidAmount()
        if spaceInShakerLeft >= amount:
            self._storeNewIngredient(name, amount, alcoholPercentage)
        else:
 
            # Jak za malo to dolewam tylko tyle ile sie zmiesci
            self._storeNewIngredient(name, spaceInShakerLeft, alcoholPercentage)
 
    def _storeNewIngredient(self, name, amount, alcoholPercentage):
 
        # Licze objetosc czystego alkoholu w plynie
        liquidAlcohol = 0
        if alcoholPercentage > 0:
            liquidAlcohol = (amount * alcoholPercentage) / 100
            self._drinkIngredients['alcohol'] += liquidAlcohol
 
        # Sprawdzam czy w drinku jest juz dany skladnik
        if self._drinkIngredients.get(name) == None:
            self._drinkIngredients[name] = amount - liquidAlcohol
        else:
            self._drinkIngredients[name] += amount - liquidAlcohol
 
    def getAllDrinkIngredients(self):
 
        # Wypluwam czysty dictionary ze skladnikami
        return self._drinkIngredients
 
    def totalLiquidAmount(self):
 
        # Zliczam objetosc wszystkich skladnikow w shakerze
        total = 0
        for value in self._drinkIngredients.values():
            total += value
        return total
 
    def getTotalLiquidAlcohol(self):
        return self._drinkIngredients['alcohol']
 
    def getTotalAlcoholPercentage(self):
 
        # Licze calkowity procent alkoholu w drinku
        return (self.getTotalLiquidAlcohol() / self.totalLiquidAmount()) * 100
 
    def getTotalAlcoholInGrams(self):
 
        # Przeliczam ml alkoholu na gramy
        return 0.79 * self.getTotalLiquidAlcohol()
 
    def computeAlcoholPromillesPerWeight(self, weight, man = True):
 
        # PRZYBLIZONA zawartosc procentowa plynow ustrojowych w zaleznosci od plci
        humanFluidsPercentage = 0.7 if man == True else 0.6
        return self.getTotalAlcoholInGrams() / (humanFluidsPercentage * weight)
 
    def pourOutDrink(self, amount):
        """
        Metoda wlasciwie niepotrzebna. Mozna wylac (wypic!) czesc zawartosci
        shakera i sobie potem dolewac kolejne skladniki.
        """
        if amount >= self.totalLiquidAmount():
            self._drinkIngredients = {'alcohol' : 0}
        else:
            percentage = amount / self.totalLiquidAmount()
            for key, value in self._drinkIngredients.items():
                self._drinkIngredients[key] -= self._drinkIngredients[key] * percentage

class ShakerDisplayer:
 
    def displayShakerDetails(shaker, weight, man = True):
        if not isinstance(shaker, Shaker):
            raise ValueError('Podano argument klasy {}'.format(shaker.__class__))
 
        print('Skladniki drinka:')
        for key,value in shaker.getAllDrinkIngredients().items():
            # Zaokraglamy i wymuszamy 2 miejsca po przecinku
            print('{:.2f}ml {}'.format(value,key))
 
        print('Calkowita zawartosc alkoholu w drinku: {:.2f}%'.format(shaker.getTotalAlcoholPercentage()))
        print('Calkowita zawartosc alkoholu w drinku (wyrazona w gramach): {:.2f}g'.format(shaker.getTotalAlcoholInGrams()))
 
        # Nie znam lepszej metody na wyswietlenie znaku promila niz unicodedata.lookup('PER MILLE SIGN')
        # Ma ktos lepszy pomysl?
        print('Prawdopodobna liczba promili dla {} o wadze {}kg wynosi {:.2f}{}'.format('faceta' if man == True else 'kobiety', weight, shaker.computeAlcoholPromillesPerWeight(weight,man), unicodedata.lookup('PER MILLE SIGN')))