Стиль/эффективность Haskell

Решение 1:

Для 32-битных: Запустите «mysql.exe» из: C: \ Program Files \ MySQL \ MySQL Server 5.6 \ bin

Для 64-разрядных: Запустите «MySQLInstanceConfig.exe» из: C: \ Program Files \ MySQL \ MySQL Server 5.6 \ bin

Решение 2:

Ошибка (2002) Не удается подключиться к ... обычно означает, что в системе не работает сервер MySQL или вы используете неверное имя файла сокета Unix или номер порта TCP / IP при попытке подключиться к серверу. Вам также следует убедиться, что используемый вами порт TCP / IP не был заблокирован брандмауэром или службой блокировки портов.

Ошибка (2003) «Не удается подключиться к серверу MySQL на сервере» (10061) означает, что в сетевом соединении отказано. Вы должны убедиться, что сервер MySQL работает, на нем включены сетевые подключения и что указанный вами сетевой порт настроен на сервере.

Источник: http://dev.mysql.com/doc/refman/5.6/en/starting-server.html Посетите его для получения дополнительной информации.

6
задан Will Ness 21 December 2012 в 00:48
поделиться

2 ответа

Для чего нужен второй аргумент f ? На мой взгляд, обе эти альтернативы более читабельны и существенно не влияют на производительность ...

...
            let g y = f y && y `mod` x > 0 in
            x : mkPrimes g xs
...

import Control.Arrow  -- instance Monad (-> r)
import Control.Monad  -- liftM2
(.&&.) = liftM2 (&&)
...
            let g y = y `mod` x > 0 in
            x : mkPrimes (f .&&. g) xs
...

В любом случае, вернемся к вопросу. Иногда использование функций в качестве структур данных является лучшим представлением для определенной задачи, а иногда - нет. «Лучшие» с точки зрения простоты кодирования и «лучшие» с точки зрения производительности - не всегда одно и то же. Техника «функций как структур данных» важна для компиляции среды выполнения , но, как предупреждает эта страница,

компиляция среды выполнения иногда может принести вам значительный выигрыш в эффективности, но часто может принести вам почти ничего за счет ваш повышенный стресс и снижение производительности.

В вашем случае это ' Вероятно, что накладные расходы на построение каждого f :: Integer -> ... -> Bool значительно выше, чем накладные расходы на построение каждого ps :: [Integer] , с небольшим или никакой разницы при вызове f ... x против all ... ps .


Чтобы выжать циклы из бесконечного решета простых чисел, избавьтесь от вызовов мод ! Умножение, деление и модуль целых чисел намного медленнее, чем сложение и вычитание целых чисел. На моей машине эта реализация работает на 40% быстрее при вычислении первых 1000 простых чисел (GHC 6.10.3 -O2 ).

import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
  where
    mkPrimes n m = case (M.null m, M.findMin m) of
        (False, (n', skips)) | n == n' ->
            mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
        _ -> n : mkPrimes (succ n) (addSkip n m n)
    addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
    addSkips = foldl' . addSkip

В действии (с использованием небольшого синтаксиса JSON),

   mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...

карта отслеживает будущие кратные, не используя ничего, кроме сложения.

Bool значительно выше, чем накладные расходы на построение каждого ps :: [Integer] , с небольшой разницей или без разницы при вызове f ... x против all. .. ps .


Чтобы выжать циклы из бесконечного решета простых чисел, избавьтесь от вызовов mod ! Умножение, деление и модуль целых чисел намного медленнее, чем сложение и вычитание целых чисел. На моей машине эта реализация работает на 40% быстрее при вычислении первых 1000 простых чисел (GHC 6.10.3 -O2 ).

import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
  where
    mkPrimes n m = case (M.null m, M.findMin m) of
        (False, (n', skips)) | n == n' ->
            mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
        _ -> n : mkPrimes (succ n) (addSkip n m n)
    addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
    addSkips = foldl' . addSkip

В действии (с использованием небольшого синтаксиса JSON),

   mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...

карта отслеживает будущие кратные, не используя ничего, кроме сложения.

Bool значительно выше, чем накладные расходы на построение каждого ps :: [Integer] , с небольшой разницей или без разницы при вызове f ... x против all. .. ps .


Чтобы выжать циклы из бесконечного решета простых чисел, избавьтесь от вызовов mod ! Умножение, деление и модуль целых чисел намного медленнее, чем сложение и вычитание целых чисел. На моей машине эта реализация работает на 40% быстрее при вычислении первых 1000 простых чисел (GHC 6.10.3 -O2 ).

import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
  where
    mkPrimes n m = case (M.null m, M.findMin m) of
        (False, (n', skips)) | n == n' ->
            mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
        _ -> n : mkPrimes (succ n) (addSkip n m n)
    addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
    addSkips = foldl' . addSkip

В действии (с использованием небольшого синтаксиса JSON),

   mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...

карта отслеживает будущие кратные, не используя ничего, кроме сложения.

ps .


Чтобы выжать циклы из бесконечного решета простых чисел, избавьтесь от вызовов mod ! Умножение, деление и модуль целых чисел намного медленнее, чем сложение и вычитание целых чисел. На моей машине эта реализация работает на 40% быстрее при вычислении первых 1000 простых чисел (GHC 6.10.3 -O2 ).

import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
  where
    mkPrimes n m = case (M.null m, M.findMin m) of
        (False, (n', skips)) | n == n' ->
            mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
        _ -> n : mkPrimes (succ n) (addSkip n m n)
    addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
    addSkips = foldl' . addSkip

В действии (с использованием небольшого синтаксиса JSON),

   mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...

карта отслеживает будущие кратные, не используя ничего, кроме сложения.

ps .


Чтобы выжать циклы из бесконечного решета простых чисел, избавьтесь от вызовов mod ! Умножение, деление и модуль целых чисел намного медленнее, чем сложение и вычитание целых чисел. На моей машине эта реализация работает на 40% быстрее при вычислении первых 1000 простых чисел (GHC 6.10.3 -O2 ).

import qualified Data.Map as M
primes' :: [Integer]
primes' = mkPrimes 2 M.empty
  where
    mkPrimes n m = case (M.null m, M.findMin m) of
        (False, (n', skips)) | n == n' ->
            mkPrimes (succ n) (addSkips n (M.deleteMin m) skips)
        _ -> n : mkPrimes (succ n) (addSkip n m n)
    addSkip n m s = M.alter (Just . maybe [s] (s:)) (n+s) m
    addSkips = foldl' . addSkip

В действии (с использованием небольшого синтаксиса JSON),

   mkPrimes 2 {}
=> 2 : mkPrimes 3 {4: [2]}
=> 2 : 3 : mkPrimes 4 {4: [2], 6: [3]}
=> 2 : 3 : mkPrimes 5 {6: [2, 3]}
=> 2 : 3 : 5 : mkPrimes 6 {6: [2, 3], 10: [5]}
=> 2 : 3 : 5 : mkPrimes 7 {8: [2], 9: [3], 10: [5]}
=> 2 : 3 : 5 : 7 : mkPrimes 8 {8: [2], 9: [3], 10: [5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 9 {9: [3], 10: [2, 5], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 10 {10: [2, 5], 12: [3], 14: [7]}
=> 2 : 3 : 5 : 7 : mkPrimes 11 {12: [2, 3], 14: [7], 15: [5]}
...

карта отслеживает будущие кратные, не используя ничего, кроме сложения.

9
ответ дан 10 December 2019 в 00:44
поделиться

Обратите внимание, что primes3 можно сделать более эффективным, изменив ps ++ [x] на (x: ps) . Бегущий (++) линейен по длине своего левого аргумента, но постоянен по длине правого аргумента.

1
ответ дан 10 December 2019 в 00:44
поделиться
Другие вопросы по тегам:

Похожие вопросы: