Smdn.Text.Ondulish 4.0.0

Smdn.Text.Ondulish-4.0.0

A text conversion library that provides translation features from Japanese to Ondulish.

Usage

// SPDX-FileCopyrightText: 2022 smdn <smdn@smdn.jp>
// SPDX-License-Identifier: MIT
using Smdn.Text.Ondulish;

using var t = new Translator();

// This code outputs as follows: "ｺﾝﾃﾞｨﾃﾞｨｳﾞｧ､ｵﾝﾄﾞｩﾙｺﾞﾄﾞｾｶｲ!"
Console.WriteLine(t.Translate("こんにちは、オンドゥル語の世界！"));

// This code outputs as follows: "ｵﾝﾄﾞｩﾙﾙﾗｷﾞｯﾀﾝﾃﾞｨｽｶｰ!?"
Console.WriteLine(t.Translate("本当に裏切ったんですか!?"));

MeCab bindings for .NET

This package includes MeCab bindings for .NET and supports the platforms represented by the following RIDs.

• ubuntu.22.04-x64

For other platforms, a wrapper library for the bindings must be built and deployed separately.

API List

List of APIs exposed by assembly Smdn.Text.Ondulish-4.0.0 (net6.0)

// Smdn.Text.Ondulish.dll (Smdn.Text.Ondulish-4.0.0)
//   Name: Smdn.Text.Ondulish
//   AssemblyVersion: 4.0.0.0
//   InformationalVersion: 4.0.0+83e998fd2f6e3822969df4b1b14bf2fab381d0f5
//   TargetFramework: .NETCoreApp,Version=v6.0
//   Configuration: Release
#nullable enable annotations

using System;
using System.Collections.Generic;
using System.IO;
using MeCab;

namespace MeCab {
  public class DictionaryInfo : IDisposable {
    protected bool swigCMemOwn;

    public DictionaryInfo() {}

    public string charset { get; }
    public string filename { get; }
    public uint lsize { get; }
    public DictionaryInfo next { get; }
    public uint rsize { get; }
    public uint size { get; }
    public int type { get; }
    public ushort version { get; }

    protected virtual void Dispose(bool disposing) {}
    public void Dispose() {}
    ~DictionaryInfo() {}
  }

  public class Lattice : IDisposable {
    protected bool swigCMemOwn;

    public Lattice() {}

    protected virtual void Dispose(bool disposing) {}
    public void Dispose() {}
    ~Lattice() {}
    public virtual double Z() {}
    public virtual void add_request_type(int request_type) {}
    public virtual Node begin_nodes(uint pos) {}
    public virtual Node bos_node() {}
    public virtual int boundary_constraint(uint pos) {}
    public virtual void clear() {}
    public virtual Node end_nodes(uint pos) {}
    public virtual string enumNBestAsString(uint N) {}
    public virtual Node eos_node() {}
    public virtual string feature_constraint(uint pos) {}
    public virtual bool has_constraint() {}
    public virtual bool has_request_type(int request_type) {}
    public virtual bool is_available() {}
    public virtual Node newNode() {}
    public virtual bool next() {}
    public virtual void remove_request_type(int request_type) {}
    public virtual int request_type() {}
    public virtual string sentence() {}
    public virtual void set_Z(double Z) {}
    public virtual void set_boundary_constraint(uint pos, int boundary_constraint_type) {}
    public virtual void set_feature_constraint(uint begin_pos, uint end_pos, string feature) {}
    public virtual void set_request_type(int request_type) {}
    public virtual void set_result(string result) {}
    public void set_sentence(string sentence) {}
    public virtual void set_theta(float theta) {}
    public virtual void set_what(string str) {}
    public virtual uint size() {}
    public virtual float theta() {}
    public virtual string toString() {}
    public virtual string toString(Node node) {}
    public virtual string what() {}
  }

  public class MeCab {
    public static readonly int MECAB_ALLOCATE_SENTENCE = 64;
    public static readonly int MECAB_ALL_MORPHS = 32;
    public static readonly int MECAB_ALTERNATIVE = 16;
    public static readonly int MECAB_ANY_BOUNDARY = 0;
    public static readonly int MECAB_BOS_NODE = 2;
    public static readonly int MECAB_EON_NODE = 4;
    public static readonly int MECAB_EOS_NODE = 3;
    public static readonly int MECAB_INSIDE_TOKEN = 2;
    public static readonly int MECAB_MARGINAL_PROB = 8;
    public static readonly int MECAB_NBEST = 2;
    public static readonly int MECAB_NOR_NODE = 0;
    public static readonly int MECAB_ONE_BEST = 1;
    public static readonly int MECAB_PARTIAL = 4;
    public static readonly int MECAB_SYS_DIC = 0;
    public static readonly int MECAB_TOKEN_BOUNDARY = 1;
    public static readonly int MECAB_UNK_DIC = 2;
    public static readonly int MECAB_UNK_NODE = 1;
    public static readonly int MECAB_USR_DIC = 1;
    public static readonly string VERSION = "0.996";

    public MeCab() {}
  }

  public class Model : IDisposable {
    public static string version() {}

    protected bool swigCMemOwn;

    public Model() {}
    public Model(string argc) {}

    protected virtual void Dispose(bool disposing) {}
    public void Dispose() {}
    ~Model() {}
    public virtual Lattice createLattice() {}
    public virtual Tagger createTagger() {}
    public virtual DictionaryInfo dictionary_info() {}
    public virtual Node lookup(string begin, string end, Lattice lattice) {}
    public virtual bool swap(Model model) {}
    public virtual int transition_cost(ushort rcAttr, ushort lcAttr) {}
  }

  public class Node : IDisposable {
    protected bool swigCMemOwn;

    public float alpha { get; }
    public float beta { get; }
    public Node bnext { get; }
    public byte char_type { get; }
    public int cost { get; }
    public Node enext { get; }
    public string feature { get; }
    public uint id { get; }
    public byte isbest { get; }
    public ushort lcAttr { get; }
    public ushort length { get; }
    public Path lpath { get; }
    public Node next { get; }
    public ushort posid { get; }
    public Node prev { get; }
    public float prob { get; set; }
    public ushort rcAttr { get; }
    public ushort rlength { get; }
    public Path rpath { get; }
    public byte stat { get; }
    public string surface { get; }
    public short wcost { get; }

    protected virtual void Dispose(bool disposing) {}
    public void Dispose() {}
    ~Node() {}
  }

  public class Path : IDisposable {
    protected bool swigCMemOwn;

    public int cost { get; }
    public Path lnext { get; }
    public Node lnode { get; }
    public float prob { get; set; }
    public Path rnext { get; }
    public Node rnode { get; }

    protected virtual void Dispose(bool disposing) {}
    public void Dispose() {}
    ~Path() {}
  }

  public class Tagger : IDisposable {
    public static bool parse(Model model, Lattice lattice) {}
    public static string version() {}

    protected bool swigCMemOwn;

    public Tagger() {}
    public Tagger(string argc) {}

    protected virtual void Dispose(bool disposing) {}
    public void Dispose() {}
    ~Tagger() {}
    public virtual bool all_morphs() {}
    public virtual DictionaryInfo dictionary_info() {}
    public virtual string formatNode(Node node) {}
    public virtual int lattice_level() {}
    public virtual string next() {}
    public virtual Node nextNode() {}
    public virtual bool parse(Lattice lattice) {}
    public virtual string parse(string str) {}
    public virtual string parseNBest(uint N, string str) {}
    public virtual bool parseNBestInit(string str) {}
    public virtual Node parseToNode(string str) {}
    public string parseToString(string str) {}
    public string parseToString(string str, uint length) {}
    public virtual bool partial() {}
    public virtual int request_type() {}
    public virtual void set_all_morphs(bool all_morphs) {}
    public virtual void set_lattice_level(int level) {}
    public virtual void set_partial(bool @partial) {}
    public virtual void set_request_type(int request_type) {}
    public virtual void set_theta(float theta) {}
    public virtual float theta() {}
    public virtual string what() {}
  }
}

namespace Smdn.Text.Ondulish {
  public static class KanaUtils {
    public static string ConvertWideHiraganaToKatakana(string input) {}
    public static string ConvertWideKatakanaToHiragana(string input) {}
    public static string ConvertWideKatakanaToNarrowKatakana(string input) {}
  }

  public class Translator : IDisposable {
    public static Tagger CreateTaggerForBundledDictionary() {}

    public Translator() {}
    public Translator(Tagger tagger, bool shouldDisposeTagger) {}

    public IReadOnlyDictionary<string, string> PhraseDictionary { get; }
    public IReadOnlyDictionary<string, string> WordDictionary { get; }

    protected virtual void Dispose(bool disposing) {}
    public void Dispose() {}
    public string Translate(string input, bool convertKatakanaToNarrow = true) {}
    public void Translate(TextReader input, TextWriter output, bool convertKatakanaToNarrow = true) {}
    public void Translate(string input, TextWriter output, bool convertKatakanaToNarrow = true) {}
  }
}

THIRD PARTY NOTICES

This project incorporates material from the projects listed below or described in the code.

The attached notices are provided for information purposes only.

License notice for MeCab

• https://github.com/taku910/mecab/
• https://github.com/taku910/mecab/blob/master/mecab/BSD

Copyright (c) 2001-2008, Taku Kudo
Copyright (c) 2004-2008, Nippon Telegraph and Telephone Corporation
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are
permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above
   copyright notice, this list of conditions and the
   following disclaimer.

 * Redistributions in binary form must reproduce the above
   copyright notice, this list of conditions and the
   following disclaimer in the documentation and/or other
   materials provided with the distribution.

 * Neither the name of the Nippon Telegraph and Telegraph Corporation
   nor the names of its contributors may be used to endorse or
   promote products derived from this software without specific
   prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

License notice for MeCab IPA dictionary

• https://github.com/taku910/mecab/
• https://github.com/taku910/mecab/blob/master/mecab-ipadic/COPYING

Copyright 2000, 2001, 2002, 2003 Nara Institute of Science
and Technology.  All Rights Reserved.

Use, reproduction, and distribution of this software is permitted.
Any copy of this software, whether in its original form or modified,
must include both the above copyright notice and the following
paragraphs.

Nara Institute of Science and Technology (NAIST),
the copyright holders, disclaims all warranties with regard to this
software, including all implied warranties of merchantability and
fitness, in no event shall NAIST be liable for
any special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether in an
action of contract, negligence or other tortuous action, arising out
of or in connection with the use or performance of this software.

A large portion of the dictionary entries
originate from ICOT Free Software.  The following conditions for ICOT
Free Software applies to the current dictionary as well.

Each User may also freely distribute the Program, whether in its
original form or modified, to any third party or parties, PROVIDED
that the provisions of Section 3 ("NO WARRANTY") will ALWAYS appear
on, or be attached to, the Program, which is distributed substantially
in the same form as set out herein and that such intended
distribution, if actually made, will neither violate or otherwise
contravene any of the laws and regulations of the countries having
jurisdiction over the User or the intended distribution itself.

NO WARRANTY

The program was produced on an experimental basis in the course of the
research and development conducted during the project and is provided
to users as so produced on an experimental basis.  Accordingly, the
program is provided without any warranty whatsoever, whether express,
implied, statutory or otherwise.  The term "warranty" used herein
includes, but is not limited to, any warranty of the quality,
performance, merchantability and fitness for a particular purpose of
the program and the nonexistence of any infringement or violation of
any right of any third party.

Each user of the program will agree and understand, and be deemed to
have agreed and understood, that there is no warranty whatsoever for
the program and, accordingly, the entire risk arising from or
otherwise connected with the program is assumed by the user.

Therefore, neither ICOT, the copyright holder, or any other
organization that participated in or was otherwise related to the
development of the program and their respective officials, directors,
officers and other employees shall be held liable for any and all
damages, including, without limitation, general, special, incidental
and consequential damages, arising out of or otherwise in connection
with the use or inability to use the program or any product, material
or result produced or otherwise obtained by using the program,
regardless of whether they have been advised of, or otherwise had
knowledge of, the possibility of such damages at any time during the
project or thereafter.  Each user will be deemed to have agreed to the
foregoing by his or her commencement of use of the program.  The term
"use" as used herein includes, but is not limited to, the use,
modification, copying and distribution of the program and the
production of secondary products from the program.

In the case where the program, whether in its original form or
modified, was distributed or delivered to or received by a user from
any person, organization or entity other than ICOT, unless it makes or
grants independently of ICOT any specific warranty to the user in
writing, such person, organization or entity, will also be exempted
from and not be held liable to the user for any such damages as noted
above as far as the program is concerned.